parsbank 0.0.4 → 0.0.8

data/lib/parsbank/restfull.rb

@@ -1,7 +1,16 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
 module Parsbank
   class Restfull
     attr_accessor :connection
 
+    MAX_RETRIES = 3
+    RETRY_INTERVAL = 5 # In seconds
+
     def initialize(args = {})
       @endpoint = args.fetch(:endpoint)
       @action = args.fetch(:action)
@@ -16,16 +25,14 @@ module Parsbank
     def call
       response = send_request
 
-      Rails.logger.info("Received response with status: #{response.status}, body: #{response.body.inspect}")
+      log_response(response)
 
-      if response.success?
-        response
+      if response.is_a?(Net::HTTPSuccess)
+        parse_response(response)
       else
         log_and_raise_error(response)
       end
-    rescue Faraday::ConnectionFailed => e
-      handle_error("Connection failed: #{e.message}", e)
-    rescue Faraday::TimeoutError => e
+    rescue Timeout::Error => e
       handle_error("Request timed out: #{e.message}", e)
     rescue StandardError => e
       handle_error("An unexpected error occurred: #{e.message}", e)
@@ -33,103 +40,155 @@ module Parsbank
 
     private
 
-    def webhook(_message)
-     webhook_url = Parsbank.configuration.webhook
+    def setup_connection
+      @uri = URI.parse(@endpoint)
+      @connection = Net::HTTP.new(@uri.host, @uri.port)
+      @connection.use_ssl = @uri.scheme == 'https'
+      @connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      @connection.set_debug_output($stdout) if Parsbank.configuration.debug
+      # Setting timeouts
+      @connection.open_timeout = 10 # Time to wait for the connection to open
+      @connection.read_timeout = 10 # Time to wait for a response
+    end
 
-     webhook_url.gsub!('MESSAGE', _message) if Parsbank.configuration.webhook_method == :get
-     webhook_url.gsub!('TITLE', "Webhook of Connection Error at #{Time.now}") if Parsbank.configuration.webhook_method == :get
+    def send_request
+      retries = 0
+      begin
+        request = build_request
+        @connection.start do
+          response = @connection.request(request)
 
-      connection = Faraday.new() do |conn|
-        conn.request :json if @response_type == :json # Automatically converts payload to JSON
-        conn.response :json if @response_type == :json # Automatically parses JSON response
-        conn.adapter Faraday.default_adapter
-        conn.request :retry, max: 3, interval: 0.05,
-                             interval_randomness: 0.5, backoff_factor: 2,
-                             exceptions: [Faraday::TimeoutError, Faraday::ConnectionFailed]
-        conn.use FaradayMiddleware::FollowRedirects
-      end
+          # Handling redirects manually (max 5 redirects)
+          handle_redirects(response)
 
-      case Parsbank.configuration.webhook_method
-      when :post
-        connection.post('&parsbank') do |req|
-          req.headers = headers
-          req.body = {}
+          return response
         end
-
-      when :get
-        connection.get('&parsbank')
+      rescue Timeout::Error => e
+        retries += 1
+        raise "Request timed out after #{MAX_RETRIES} retries: #{e.message}" unless retries < MAX_RETRIES
+
+        log_to_rails("Timeout occurred. Retrying... (#{retries}/#{MAX_RETRIES})", :warn)
+        sleep(RETRY_INTERVAL)
+        retry
+      rescue StandardError => e
+        log_to_rails("Request failed: #{e.message}", :error)
+        raise e
       end
-    rescue Faraday::ConnectionFailed => e
-      Rails.logger.error("Webhook Connection failed: #{e.message}", e)
-    rescue Faraday::TimeoutError => e
-      Rails.logger.error("Webhook Request timed out: #{e.message}", e)
-    rescue StandardError => e
-      Rails.logger.error("Webhook An unexpected error occurred: #{e.message}", e)
     end
 
-    def setup_connection
-      @connection = Faraday.new(@endpoint) do |conn|
-        conn.request :json if @response_type == :json # Automatically converts payload to JSON
-        conn.response :json if @response_type == :json # Automatically parses JSON response
-        conn.adapter Faraday.default_adapter
-        conn.request :retry, max: 3, interval: 0.05,
-                             interval_randomness: 0.5, backoff_factor: 2,
-                             exceptions: [Faraday::TimeoutError, Faraday::ConnectionFailed]
-        conn.use FaradayMiddleware::FollowRedirects
-      end
-    end
-
-    def send_request
-      headers = default_headers.merge(@headers)
-
+    def build_request
       case @http_method
       when :post
-        perform_post(headers)
+        build_post_request
       when :get
-        perform_get(headers)
+        build_get_request
       when :options
-        perform_options(headers)
+        build_options_request
       else
         raise ArgumentError, "HTTP Method Not Allowed: #{@http_method}"
       end
     end
 
-    def perform_post(headers)
-      @connection.post(@action) do |req|
-        req.headers = headers
-        req.body = @request_message
-      end
+    def build_post_request
+      request = Net::HTTP::Post.new(@action, default_headers)
+      request['Connection'] = 'close' # Avoid HTTP/2 issues
+      request.body = JSON.generate(@request_message) if @request_message.any?
+      puts "Request Header: #{default_headers}" if Parsbank.configuration.debug
+      puts "Request Body: #{request.body}" if Parsbank.configuration.debug
+      request
     end
 
-    def perform_get(headers)
-      @connection.get(@action) do |req|
-        req.headers = headers
-        req.params = @request_message
-      end
+    def build_get_request
+      request = Net::HTTP::Get.new(@action, default_headers)
+      request.set_form_data(@request_message) if @request_message.any?
+      request
     end
 
-    def perform_options(headers)
-      @connection.options(@action) do |req|
-        req.headers = headers
-      end
+    def build_options_request
+      Net::HTTP::Options.new(@action, default_headers)
     end
 
     def default_headers
       {
-        'Content-Type' => 'application/json',
-        'Parsbank-RubyGem' => Parsbank::VERSION
-      }
+        'content-type' => 'application/json',
+        'accept' => 'application/json',
+        'user-agent' => 'ParsBank Ruby Gem',
+        'app-version' => Parsbank::VERSION
+      }.merge(@headers)
+    end
+
+    def log_response(response)
+      log_to_rails("Received response with status: #{response.code}, body: #{response.body.inspect}", :info)
+    end
+
+    def parse_response(response)
+      return response.body if @response_type == :raw
+
+      case @response_type
+      when :json
+        JSON.parse(response.body)
+      else
+        response.body
+      end
     end
 
     def log_and_raise_error(response)
-      Rails.logger.error("Request to #{@endpoint}/#{@action} failed with status: #{response.status}, error: #{response.body.inspect}")
-      raise "API request failed with status #{response.status}: #{response.body}"
+      log_to_rails(
+        "Request to #{@endpoint}/#{@action} failed with status: #{response.code}, error: #{response.body.inspect}", :error
+      )
+      raise "API request failed with status #{response.code}: #{response.body}"
     end
 
     def handle_error(message, exception)
-      Rails.logger.error(message)
+      log_to_rails(message, :error)
       webhook(message) if Parsbank.configuration.webhook.present?
       raise exception
     end
+
+    def log_to_rails(message, level = :info)
+      case level
+      when :error
+        Rails.logger.error(message) if defined?(Rails)
+      when :warn
+        Rails.logger.warn(message) if defined?(Rails)
+      else
+        Rails.logger.info(message) if defined?(Rails)
+      end
+    end
+
+    def webhook(message)
+      webhook_url = Parsbank.configuration.webhook
+      webhook_url.gsub!('MESSAGE', message) if Parsbank.configuration.webhook_method == :get
+      if Parsbank.configuration.webhook_method == :get
+        webhook_url.gsub!('TITLE',
+                          "Webhook of Connection Error at #{Time.now}")
+      end
+
+      uri = URI.parse(webhook_url)
+      connection = Net::HTTP.new(uri.host, uri.port)
+      connection.use_ssl = uri.scheme == 'https'
+
+      case Parsbank.configuration.webhook_method
+      when :post
+        request = Net::HTTP::Post.new(uri.path, default_headers)
+        request.body = {}.to_json
+        connection.request(request)
+      when :get
+        request = Net::HTTP::Get.new(uri.path, default_headers)
+        connection.request(request)
+      end
+    rescue StandardError => e
+      log_to_rails("Webhook Error: #{e.message}", :error)
+    end
+
+    def handle_redirects(response)
+      return unless response.is_a?(Net::HTTPRedirection)
+
+      location = response['Location']
+      log_to_rails("Redirecting to: #{location}", :warn)
+      redirect_uri = URI.parse(location)
+      request = Net::HTTP::Get.new(redirect_uri)
+      @connection.request(request)
+    end
   end
 end

data/lib/parsbank/soap.rb

@@ -0,0 +1,106 @@
+require 'net/http'
+require 'uri'
+require 'rexml/document'
+require 'logger'
+
+module Parsbank
+  # SOAP Client Class - Standard SOAP generation with namespaces and headers
+  class SOAP
+    attr_reader :endpoint, :namespace, :logger
+
+    # Initialize SOAP Client with endpoint, namespace, and optional logger
+    def initialize(endpoint, namespace)
+      @endpoint = URI.parse(endpoint)
+      @namespace = namespace
+      @logger = Logger.new(STDOUT)
+      @logger.level = Parsbank.configuration.debug ? Logger::DEBUG : Logger::WARN
+    end
+
+    # Main method to make a SOAP request
+    def call(action, body, headers = {})
+      log_request(action, body)
+      
+      xml = build_envelope(action, body.map { |k, v| "<s:#{k}>#{v}</#{k}>" }.join(''))
+
+      http = Net::HTTP.new(@endpoint.host, @endpoint.port)
+      http.use_ssl = (@endpoint.scheme == 'https')
+
+      request = Net::HTTP::Post.new(@endpoint.request_uri)
+      request.content_type = 'text/xml; charset=utf-8'
+      request['SOAPAction'] = "#{@namespace}/#{action}"
+      request.body = xml
+
+      headers.store('Parsbank-RubyGem', Parsbank::VERSION)
+      headers.each { |key, value| request[key] = value }
+
+      begin
+        response = http.request(request)
+        log_response(response)
+        parse_response(response)
+      rescue Timeout::Error => e
+        handle_error("Request timed out", e)
+      rescue SocketError => e
+        handle_error("Network connection failed", e)
+      rescue Errno::ECONNREFUSED => e
+        handle_error("Connection refused by server", e)
+      rescue StandardError => e
+        handle_error("Unexpected error: #{e.message}", e)
+      end
+    end
+
+    private
+
+    # Build the SOAP XML Envelope
+    def build_envelope(action, body)
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+                       xmlns:s="#{@namespace}">
+          <soap:Header/>
+          <soap:Body>
+            <s:#{action}>
+              #{body}
+            </s:#{action}>
+          </soap:Body>
+        </soap:Envelope>
+      XML
+    end
+
+    # Parse the XML response body
+    def parse_response(response)
+      if response.is_a?(Net::HTTPSuccess)
+        puts "Response Success"
+        puts response.body
+        parse_xml(response.body)
+      else
+        { error: "HTTP Error #{response.code}: #{response.message}" }
+      end
+    end
+
+    # Convert XML to Hash
+    def parse_xml(xml)
+      begin
+        doc = REXML::Document.new(xml)
+        { success: true, body: doc }
+      rescue REXML::ParseException => e
+        { success: false, error: "Invalid XML response: #{e.message}" }
+      end
+    end
+
+    # Error handling and logging
+    def handle_error(message, exception)
+      @logger.error("#{message}: #{exception.message}")
+      { success: false, error: message }
+    end
+
+    # Log the SOAP request for debugging
+    def log_request(action, body)
+      @logger.debug("Sending SOAP request: Action = #{action}, Body = #{body}")
+    end
+
+    # Log the SOAP response for debugging
+    def log_response(response)
+      @logger.debug("Received SOAP response: Status = #{response.code}, Body = #{response.body}")
+    end
+  end
+end

data/lib/parsbank/transaction_request.rb

@@ -0,0 +1,134 @@
+module Parsbank
+  class TransactionRequest
+    def self.create(args = {})
+      bank = fetch_bank(args)
+      validate_bank(bank)
+
+      description = args.fetch(:description)
+      callback_url = generate_callback_url(bank, description)
+
+      crypto_amount, fiat_amount, real_amount = fetch_amounts(args)
+      validate_amounts(bank, crypto_amount, fiat_amount, real_amount)
+
+      transaction = initialize_transaction(args, description, fiat_amount, crypto_amount, bank, callback_url)
+      process_gateway(bank, transaction, description, callback_url, crypto_amount, fiat_amount, args)
+
+      { transaction: transaction, html_form: @result }
+    end
+
+    def self.fetch_bank(args)
+      args.fetch(:bank, Parsbank.available_gateways_list.keys.sample)
+    end
+
+    def self.validate_bank(bank)
+      selected_bank = Parsbank.available_gateways_list[bank]
+      raise "Bank not enabled or not exists in #{Parsbank.configuration.secrets_path}: #{bank}" unless selected_bank
+    end
+
+    def self.generate_callback_url(bank, _description)
+      selected_bank = Parsbank.available_gateways_list[bank]
+      "#{selected_bank['callback_url'] || Parsbank.configuration.callback_url}&bank_name=#{bank}"
+    end
+
+    def self.fetch_amounts(args)
+      [
+        args.fetch(:crypto_amount, nil),
+        args.fetch(:fiat_amount, nil),
+        args.fetch(:real_amount, nil)
+      ]
+    end
+
+    def self.validate_amounts(bank, crypto_amount, fiat_amount, real_amount)
+      raise 'Amount fields are empty: crypto_amount OR fiat_amount OR real_amount' if [crypto_amount, fiat_amount,
+                                                                                       real_amount].all?(&:nil?)
+
+      tags = Parsbank.supported_psp[bank]['tags']
+      if tags.include?('crypto') && crypto_amount.nil? && real_amount.nil?
+        raise "#{bank} needs crypto_amount or real_amount"
+      end
+
+      return unless tags.include?('rial') && fiat_amount.nil? && real_amount.nil?
+
+      raise "#{bank} needs fiat_amount or real_amount"
+    end
+
+    def self.initialize_transaction(args, description, fiat_amount, crypto_amount, bank, callback_url)
+      model_class = Parsbank.configuration.model || 'Transaction'
+      @transaction= Object.const_get(model_class).new(
+        description: description,
+        amount: fiat_amount || crypto_amount,
+        gateway: bank,
+        callback_url: callback_url,
+        status: 'start',
+        user_id: args.fetch(:user_id, nil),
+        cart_id: args.fetch(:cart_id, nil),
+        local_id: args.fetch(:local_id, nil),
+        ip: args.fetch(:ip, nil)
+      )
+      @transaction.save
+
+      @transaction
+    end
+
+    def self.process_gateway(bank, transaction, description, callback_url, crypto_amount, fiat_amount, args)
+      case bank
+      when 'mellat'
+        process_mellat(transaction, description, callback_url, fiat_amount)
+      when 'zarinpal'
+        process_zarinpal(transaction, description, callback_url, fiat_amount)
+      when 'zibal'
+        process_zibal(description, callback_url, fiat_amount)
+      when 'bscbitcoin'
+        process_bscbitcoin(transaction, description, crypto_amount, args)
+      else
+        raise "Unsupported gateway: #{bank}"
+      end
+    end
+
+    def self.process_mellat(transaction, description, callback_url, fiat_amount)
+      mellat = Parsbank::Mellat.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url,
+        orderId: transaction.id
+      )
+      mellat.call
+      transaction.update!(gateway_response: mellat.response, unit: 'irr')
+      @result = mellat.redirect_form
+    end
+
+    def self.process_zarinpal(transaction, description, callback_url, fiat_amount)
+      zarinpal = Parsbank::Zarinpal.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url
+      )
+      zarinpal.call
+      transaction.update!(
+        gateway_response: zarinpal.response,
+        track_id: zarinpal.ref_id,
+        unit: 'irt'
+      )
+      @result = zarinpal.redirect_form
+    end
+
+    def self.process_zibal(description, callback_url, fiat_amount)
+      zibal = Parsbank::Zibal.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url
+      )
+      zibal.call
+      @result = zibal.redirect_form
+    end
+
+    def self.process_bscbitcoin(transaction, description, crypto_amount, args)
+      bscbitcoin = Parsbank::BscBitcoin.new(
+        additional_data: description
+      )
+      convert_real_amount_to_assets if crypto_amount.nil? && args.key?(:real_amount)
+      @result = bscbitcoin.generate_payment_address(amount: crypto_amount)
+      transaction.update!(gateway_response: @result, unit: 'bitcoin')
+    end
+  end
+end

data/lib/parsbank/transaction_verify.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Parsbank
+  class TransactionVerify
+    def self.verify(args = {})
+      validate_params(args.params)
+
+      transaction = initialize_transaction(args, description, fiat_amount, crypto_amount, bank, callback_url)
+      process_gateway(bank, transaction, description, callback_url, crypto_amount, fiat_amount, args)
+
+      { transaction: transaction, html_form: @result }
+    end
+
+    def self.validate_params(params)
+      model_class = Parsbank.configuration.model || 'Transaction'
+      tack_transaction = Object.const_get(model_class).find(params[:transaction_id].to_i)
+      { status: 404, message: I18n.t('model.not_found') } unless tack_transaction.present?
+    end
+
+    def self.fetch_bank(args)
+      args.fetch(:bank)
+    end
+
+    def self.validate_bank(bank)
+      selected_bank = Parsbank.available_gateways_list[bank]
+      raise "Bank not enabled or not exists in #{Parsbank.configuration.secrets_path}: #{bank}" unless selected_bank
+    end
+
+    def self.generate_callback_url(bank, _description)
+      selected_bank = Parsbank.available_gateways_list[bank]
+      "#{selected_bank['callback_url'] || Parsbank.configuration.callback_url}&bank_name=#{bank}"
+    end
+
+    def self.fetch_amounts(args)
+      [
+        args.fetch(:crypto_amount, nil),
+        args.fetch(:fiat_amount, nil),
+        args.fetch(:real_amount, nil)
+      ]
+    end
+
+    def self.validate_amounts(bank, crypto_amount, fiat_amount, real_amount)
+      raise 'Amount fields are empty: crypto_amount OR fiat_amount OR real_amount' if [crypto_amount, fiat_amount,
+                                                                                       real_amount].all?(&:nil?)
+
+      tags = $SUPPORTED_PSP[bank]['tags']
+      if tags.include?('crypto') && crypto_amount.nil? && real_amount.nil?
+        raise "#{bank} needs crypto_amount or real_amount"
+      end
+
+      return unless tags.include?('rial') && fiat_amount.nil? && real_amount.nil?
+
+      raise "#{bank} needs fiat_amount or real_amount"
+    end
+
+    def self.initialize_transaction(args, description, fiat_amount, crypto_amount, bank, callback_url)
+      model_class = Parsbank.configuration.model || 'Transaction'
+      @transaction = Object.const_get(model_class).new(
+        description: description,
+        amount: fiat_amount || crypto_amount,
+        gateway: bank,
+        callback_url: callback_url,
+        status: 'start',
+        user_id: args.fetch(:user_id, nil),
+        cart_id: args.fetch(:cart_id, nil),
+        local_id: args.fetch(:local_id, nil),
+        ip: args.fetch(:ip, nil)
+      )
+      @transaction.save
+
+      @transaction
+    end
+
+    def self.process_gateway(bank, transaction, description, callback_url, crypto_amount, fiat_amount, args)
+      case bank
+      when 'mellat'
+        process_mellat(transaction, description, callback_url, fiat_amount)
+      when 'zarinpal'
+        process_zarinpal(transaction, description, callback_url, fiat_amount)
+      when 'zibal'
+        process_zibal(description, callback_url, fiat_amount)
+      when 'bscbitcoin'
+        process_bscbitcoin(transaction, description, crypto_amount, args)
+      else
+        raise "Unsupported gateway: #{bank}"
+      end
+    end
+
+    def self.process_mellat(transaction, description, callback_url, fiat_amount)
+      mellat = Parsbank::Mellat.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url,
+        orderId: transaction.id
+      )
+      mellat.call
+      transaction.update!(gateway_response: mellat.response, unit: 'irr')
+      @result = mellat.redirect_form
+    end
+
+    def self.process_zarinpal(transaction, description, callback_url, fiat_amount)
+      zarinpal = Parsbank::Zarinpal.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url
+      )
+      zarinpal.call
+      transaction.update!(
+        gateway_response: zarinpal.response,
+        track_id: zarinpal.ref_id,
+        unit: 'irt'
+      )
+      @result = zarinpal.redirect_form
+    end
+
+    def self.process_zibal(description, callback_url, fiat_amount)
+      zibal = Parsbank::Zibal.new(
+        amount: fiat_amount,
+        additional_data: description,
+        callback_url: callback_url
+      )
+      zibal.call
+      @result = zibal.redirect_form
+    end
+
+    def self.process_bscbitcoin(transaction, description, crypto_amount, args)
+      bscbitcoin = Parsbank::BscBitcoin.new(
+        additional_data: description
+      )
+      convert_real_amount_to_assets if crypto_amount.nil? && args.key?(:real_amount)
+      @result = bscbitcoin.generate_payment_address(amount: crypto_amount)
+      transaction.update!(gateway_response: @result, unit: 'bitcoin')
+    end
+  end
+end

data/lib/parsbank/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsbank
-  VERSION = '0.0.4'
+  VERSION = '0.0.8'
 end

data/lib/parsbank/zarinpal/logo.svg

@@ -1,4 +1,4 @@
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 1575 350">
+<svg data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100%" viewBox="0 0 1575 350">
   <defs>
     <style>
       .cls-1 {