veritrans 1.2.6 → 2.0.0beta

data/lib/generators/veritrans/install_generator.rb

@@ -0,0 +1,32 @@
+module Veritrans
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("../../templates", __FILE__)
+
+desc %{
+Description:
+    Copies Veritrans configuration file to your application's initializer directory.
+}
+
+    desc "copy veritrans.yml"
+    def copy_config_file
+      copy_file "veritrans.yml", "config/veritrans.yml"
+    end
+
+    desc "copy initializer veritrans.rb"
+    def copy_initializer_file
+      copy_file "./veritrans.rb", "config/initializers/veritrans.rb"
+
+say_status "", %{
+
+We copy configs in your rails application
+Please edit:
+
+  config/veritrans.yml
+
+}
+
+
+    end
+
+  end
+end

data/lib/generators/veritrans/payment_form_generator.rb

@@ -0,0 +1,45 @@
+module Veritrans
+  class PaymentFormGenerator < ::Rails::Generators::Base
+    source_root File.expand_path("../../templates", __FILE__)
+
+desc %{
+Description:
+    Copies Veritrans payment form example to your rails application.
+}
+
+    def copy_shared_views
+      copy_file "views/_veritrans_include.erb", "app/views/shared/_veritrans_include.erb"
+      copy_file "views/_credit_card_form.erb", "app/views/shared/_credit_card_form.erb"
+    end
+
+    def copy_controller
+      copy_file "payments_controller.rb", "app/controllers/payments_controller.rb"
+
+      route "resources :payments do\n" +
+          "    collection do\n" +
+          "      post :receive_webhook\n" +
+          "    end\n" +
+          "  end"
+
+      copy_file "views/payments/new.erb", "app/views/payments/new.erb"
+      copy_file "views/payments/create.erb", "app/views/payments/create.erb"
+    end
+
+    def append_javascript_file
+      copy_file "assets/credit_card_form.js", "app/assets/javascripts/credit_card_form.js"
+      insert_into_file "app/assets/javascripts/application.js", :after => %r{//= require +['"]?jquery['"]?$} do
+        "\n//= require credit_card_form"
+      end
+
+say_status "", %{
+
+Sample form installed in you app!
+It contains example for VT-Web and VT-Direct
+
+Now open http://localhost:3000/payments/new
+
+}
+
+    end
+  end
+end

data/lib/veritrans/api.rb

@@ -0,0 +1,90 @@
+# Veritrans API methods
+
+require 'uri'
+
+module Veritrans
+  module Api
+
+    # POST /v2/charge { payment_type: "vtlink" }
+    # Docs http://docs.veritrans.co.id/vtdirect/integration_cc.html#step2
+    # Docs http://docs.veritrans.co.id/sandbox/charge.html
+    #
+    # Example:
+    # Veritrans.charge(
+    #   payment_type: "credit_card",
+    #   credit_card: { token_id: "<token from client>" },
+    #   transaction_details: {
+    #     order_id: "order_123",
+    #     gross_amount: 100_000
+    #   }
+    # )
+    def charge(payment_type, data = nil)
+      if payment_type.kind_of?(Hash) && data.nil?
+        data = payment_type
+        payment_type = nil
+      end
+
+      data = data.deep_symbolize_keys if data.respond_to?(:deep_symbolize_keys)
+
+      data[:payment_type] = payment_type if payment_type
+
+      if data.has_key?(:payment_options)
+        data[ payment_type.to_sym ] = data.delete(:payment_options)
+      end
+
+      # Rename keys:
+      # payment     -> transaction_details
+      # transaction -> transaction_details
+      # items       -> item_details
+      # customer    -> customer_details
+
+      data[:transaction_details]  = data.delete(:payment)     if data[:payment]
+      data[:transaction_details]  = data.delete(:transaction) if data[:transaction]
+      data[:item_details]         = data.delete(:items)       if data[:items]
+      data[:customer_details]     = data.delete(:customer)    if data[:customer]
+
+      request_with_logging(:post, config.api_host + "/v2/charge", data)
+    end
+
+    # POST /v2/{id}/cancel
+    # Docs http://docs.veritrans.co.id/sandbox/other_commands.html
+    def cancel(payment_id, options = {})
+      request_with_logging(:post, config.api_host + "/v2/#{URI.escape(payment_id)}/cancel", options)
+    end
+
+    # POST /v2/{id}/approve
+    # Docs http://docs.veritrans.co.id/sandbox/other_commands.html
+    def approve(payment_id, options = {})
+      request_with_logging(:post, config.api_host + "/v2/#{URI.escape(payment_id)}/approve", options)
+    end
+
+    # GET /v2/{id}/status
+    # Docs http://docs.veritrans.co.id/sandbox/other_commands.html
+    def status(payment_id)
+      if !payment_id || payment_id == ""
+        raise ArgumentError, "parameter payment_id can not be bank"
+      end
+
+      get(config.api_host + "/v2/#{URI.escape(payment_id)}/status")
+    end
+
+    # POST /v2/capture
+    # Docs http://docs.veritrans.co.id/sandbox/other_features.html
+    def capture(payment_id, gross_amount, options = {})
+      post(config.api_host + "/v2/capture", options.merge(transaction_id: payment_id, gross_amount: gross_amount))
+    end
+
+    # POST /v2/charge { payment_type: "vtlink" }
+    def create_vtlink(data)
+      data = data.dup
+      data[:payment_type] = "vtlink"
+      request_with_logging(:post, config.api_host + "/v2/charge", data)
+    end
+
+    # DELETE /v2/vtlink/{id}
+    def delete_vtlink(id, options)
+      request_with_logging(:delete, config.api_host + "/v2/vtlink/#{URI.escape(id)}", options)
+    end
+
+  end
+end

data/lib/veritrans/cli.rb

@@ -0,0 +1,166 @@
+require 'json'
+require 'securerandom'
+require 'logger'
+
+class Hash
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+
+  def except(*keys)
+    dup.except!(*keys)
+  end
+end
+
+module Veritrans
+  module CLI
+    # can't find order
+    class OrderNotFound < Exception; end
+    class AuthenticationError < Exception; end
+
+    extend self
+
+    def test_webhook(args)
+      url = args.shift
+      raise ArgumentError, "missing required parameter URL" unless url && url != ""
+
+      options = {
+        body: json_data,
+        headers: {
+          :Accept => "application/json",
+          :"Content-Type" => "application/json",
+          :"User-Agent" => "Veritrans gem #{Veritrans::VERSION} - webhook tester"
+        },
+        read_timeout: 10,
+        write_timeout: 10,
+        connect_timeout: 10
+      }
+
+      puts "Sending #{options[:body].length} bytes to:"
+      puts " => #{cyan(url)}"
+      # Print body if it's custom
+      puts options[:body] + "\n\n" if CONFIG[:order]
+
+      s_time = Time.now
+      response = Excon.post(url, options)
+      response.body = response.body.to_s.encode('UTF-8', {:invalid => :replace, :undef => :replace, :replace => '?'})
+
+      puts "Got response: (#{((Time.now - s_time) * 1000).round}ms)"
+      puts "  status: #{response.status}"
+      puts "  body: #{response.body}"
+
+      if response.status >= 200 && response.status < 300
+        puts green("Success!")
+      else
+        puts red("Failed!")
+        puts "Response status is #{response.status} not 200"
+      end
+    #rescue Object => error
+    #  puts red("Failed!")
+    #  puts error.message
+    end
+
+    def load_local_config!
+      if CONFIG[:config_path]
+        if File.exists?(CONFIG[:config_path])
+          config_file = CONFIG[:config_path]
+        else
+          raise ArgumentError, "Can not find config at #{CONFIG[:config_path]}" unless config_file
+        end
+      end
+
+
+      if File.exists?("./veritrans.yml")
+        config_file = "./veritrans.yml"
+      end
+      if File.exists?("./config/veritrans.yml")
+        config_file = "./config/veritrans.yml"
+      end
+
+      raise ArgumentError, "Can not find config at ./config/veritrans.yml or ./veritrans.yml" unless config_file
+
+      puts "#{green('*')} Load config #{config_file}"
+      ENV['RAILS_ENV'] ||= 'development'
+      Veritrans.setup.load_yml("#{config_file}##{ENV['RAILS_ENV']}")
+
+      if !Veritrans.config.client_key || Veritrans.config.client_key == ""
+        puts red("Error")
+        raise ArgumentError, "Can not find client_key in #{config_file}"
+      end
+
+      if !Veritrans.config.server_key || Veritrans.config.server_key == ""
+        puts red("Error")
+        raise ArgumentError, "Can not find server_key in #{config_file}"
+      end
+
+    end
+
+    def get_order_info(order_id)
+      puts "#{green('*')} Getting order #{order_id}"
+      Veritrans.logger = Logger.new("/dev/null")
+      response = Veritrans.status(order_id)
+      if response.success?
+        return response
+      else
+        puts red("Error")
+
+        if response.status_code == 401
+          raise AuthenticationError, "Can not find order with id=#{order_id} (#{response.status_message})"
+        else
+          raise OrderNotFound, "Can not find order with id=#{order_id} (#{response.status_message})"
+        end
+      end
+    end
+
+    def json_data
+      data = {
+        status_code: "200",
+        status_message: "Veritrans payment notification",
+        transaction_id: SecureRandom.uuid,
+        order_id: "cli-testin-#{rand}",
+        payment_type: "credit_card",
+        transaction_time: Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+        transaction_status: "capture",
+        fraud_status: "accept",
+        masked_card: "411111-1111",
+        gross_amount: "50000.0"
+      }
+
+      if CONFIG[:order]
+        load_local_config!
+        order_info = get_order_info(CONFIG[:order])
+        order_data = order_info.data.except(:status_message, :signature_key)
+        data = data.except(:fraud_status, :masked_card).merge(order_data)
+      end
+
+      JSON.dump(JSON.pretty_generate(data))
+    end
+
+    def colorize(str, color_code)
+      "\e[#{color_code}m#{str}\e[0m"
+    end
+
+    def red(str)
+      colorize(str, 31)
+    end
+
+    def green(str)
+      colorize(str, 32)
+    end
+
+    def yellow(str)
+      colorize(str, 33)
+    end
+
+    def blue(str)
+      colorize(str, 34)
+    end
+
+    def pink(str)
+      colorize(str, 35)
+    end
+    def cyan(str); colorize(str, 36) end
+
+  end
+end

data/lib/veritrans/client.rb

@@ -1,240 +1,108 @@
-# :nodoc:
-module Veritrans
-
-  # :nodoc:
-  class Client
-    include Config
-
-    # constructor to create instance of Veritrans::Client
-    def initialize(&block)
-      class <<self
-        self
-      end.class_eval do
-        attr_accessor(:commodity, *PostData::PostParam) 
-      end
-      
-      # return-back to merchant-web
-      self.customer_specification_flag = Config::CUSTOMER_SPECIFICATION_FLAG 
-      self.settlement_type             = Config::SETTLEMENT_TYPE_CARD
-
-      # if block_given?
-      #   yield(self) #self.instance_eval(&block)
-      #   return self.get_keys
-      # end
-    end
-
-    #
-    # Example:
-    #
-    #   client = Veritrans::Client.new
-    #   client.order_id     = "dummy#{(0...12).map{65.+(rand(25))}.join}"
-    #   client.session_id   = "session#{(0...12).map{65.+(rand(25))}.join}"
-    #   client.gross_amount = "10"
-    #   client.commodity    = [{
-    #     "COMMODITY_ID"    => "IDxx1", 
-    #     "COMMODITY_UNIT"  => "10",
-    #     "COMMODITY_NUM"   => "1",
-    #     "COMMODITY_NAME1" => "Waterbotle",
-    #     "COMMODITY_NAME2" => "Waterbottle in Indonesian"}]
-    #   client.get_keys
-    #
-    def get_keys
-      init_instance
-      
-      if customer_specification_flag == "0" && shipping_flag == "0"
-        raise "required_shipping_address must be '1'"
-      end
-
-      params = prepare_params(PostData::ServerParam,PostData::PostParam)
-
-      if !params[:promo_bins].blank?
-        params.merge!({ "promo_bins[]" => params[:promo_bins]})
-        params.delete :promo_bins
-      end
-
-      if !params[:point_banks].blank?
-        params.merge!({ "point_banks[]" => params[:point_banks]})
-        params.delete :point_banks
-      end
+# Veritrans HTTP Client
 
-      if !params[:installment_banks].blank?
-        params.merge!({ "installment_banks[]" => params[:installment_banks]})
-        params.delete :installment_banks
-      end
+require "base64"
+require 'uri'
+require 'excon'
 
-      if !params[:installment_terms].blank?
-        params.merge!({ "installment_terms" => params[:installment_terms].to_json })
-        params.delete :installment_terms
-      end
-      
-      if !params[:payment_methods].blank?
-        params.merge!({ "payment_methods[]" => params[:payment_methods]})
-        params.delete :payment_methods
-      end
-      
-      commodity = @commodity.collect do |data|
-        data.keys.map do |key|
-          if key.downcase == "commodity_id"
-            data["item_id[]"] = data[key]            
-          end
-          
-          if key.downcase == "commodity_unit"
-            data["price[]"] = data[key]
-          end
-
-          if key.downcase == "commodity_num"
-            data["quantity[]"] = data[key]
-          end
-
-          if key.downcase == "commodity_name1"
-            data["item_name1[]"] = data[key]
-          end
-
-          if key.downcase == "commodity_name2"
-            data["item_name2[]"] = data[key]
-          end
-
-          data.delete key
-        end        
-
-        # construct commodity
-        orders_uri = Addressable::URI.new
-        orders_uri.query_values = data
-        # return list of commodity as query string format
-        orders_uri.query
-      end
+module Veritrans
+  module Client
+    extend self
 
-      uri = Addressable::URI.new
-      uri.query_values = params
-      query_string = "#{uri.query}&repeat_line=#{commodity.length}&#{commodity.join('&')}"
-    
-      conn = Faraday.new(:url => server_host)
-      @resp = conn.post do |req|
-        req.url(Config::REQUEST_KEY_URL)
-        req.body = query_string
-      end.env
-      
-      delete_keys
-      @resp[:url] = @resp[:url].to_s
-
-      if version.to_i == 1
-        @token = JSON.parse(@resp[:body])
-      else        
-        @token = parse_body(@resp[:body])
+    # Failback for activesupport
+    def _json_encode(params)
+      if defined?(ActiveSupport) && defined?(ActiveSupport::JSON)
+        ActiveSupport::JSON.encode(params)
+      else
+        require 'json' unless defined?(JSON)
+        JSON.generate(params)
       end
     end
 
-    # :nodoc:
-    def server_host
-      return Client.config["server_host"] ? Client.config["server_host"] : Config::SERVER_HOST
-    end
-
-    def redirect_url
-      "#{server_host}/web1/paymentStart.action"
-    end
-
-    # :nodoc:
-    def merchant_id
-      return Client.config["merchant_id"]
+    def _json_decode(params)
+      if defined?(ActiveSupport) && defined?(ActiveSupport::JSON)
+        ActiveSupport::JSON.decode(params)
+      else
+        require 'json' unless defined?(JSON)
+        JSON.parse(params)
+      end
     end
 
-    # :nodoc:
-    def merchant_id= new_merchant_id
-      Client.config["merchant_id"] = new_merchant_id
-    end
+    # This is proxy method for make_request to save request and response to logfile
+    def request_with_logging(method, url, params)
+      short_url = url.sub(config.api_host, '')
+      file_logger.info("Perform #{short_url} \nSending: " + _json_encode(params))
 
-    # :nodoc:
-    def merchant_hash_key
-      return Client.config["merchant_hash_key"]
-    end
+      result = make_request(method, url, params)
 
-    # :nodoc:
-    def merchant_hash_key= new_merchant_hash_key
-      Client.config["merchant_hash_key"] = new_merchant_hash_key
-    end
+      if result.status_code < 300
+        file_logger.info("Success #{short_url} \nGot: " + _json_encode(result.data) + "\n")
+      else
+        file_logger.warn("Failed #{short_url} \nGot: " + _json_encode(result.data) + "\n")
+      end
 
-    # :nodoc:
-    def error_payment_return_url
-      return Client.config["error_payment_return_url"]
+      result
     end
 
-    # :nodoc:
-    def finish_payment_return_url
-      return Client.config["finish_payment_return_url"]
-    end
+    private
 
-    # :nodoc:
-    def unfinish_payment_return_url
-      return Client.config["unfinish_payment_return_url"]
+    def basic_auth_header(server_key = SERVER_KEY)
+      key = Base64.strict_encode64(server_key + ":")
+      "Basic #{key}"
     end
 
-    # :nodoc:
-    def token
-      return @token
+    def get(url, params = {})
+      make_request(:get, url, params)
     end
 
-    # :nodoc:
-    def billing_address_different_with_shipping_address
-      @customer_specification_flag
+    def delete(url, params)
+      make_request(:delete, url, params)
     end
 
-    # :nodoc:
-    def billing_address_different_with_shipping_address=(flag)
-      @customer_specification_flag = customer_specification_flag
+    def post(url, params)
+      make_request(:post, url, params)
     end
 
-    # :nodoc:
-    def required_shipping_address
-      @shipping_flag
-    end
+    def make_request(method, url, params, auth_header = nil)
+      if !config.server_key || config.server_key == ''
+        raise "Please add server_key to config/veritrans.yml"
+      end
 
-    # :nodoc:
-    def required_shipping_address=(flag)
-      @shipping_flag = flag
-    end
+      method = method.to_s.upcase
+      logger.info "Veritrans: #{method} #{url} #{_json_encode(params)}"
+
+      # Add authentication and content type
+      # Docs http://docs.veritrans.co.id/sandbox/introduction.html
+      options = {
+        :body => _json_encode(params),
+        :headers => {
+          :Authorization => auth_header || basic_auth_header(config.server_key),
+          :Accept => "application/json",
+          :"Content-Type" => "application/json",
+          :"User-Agent" => "Veritrans ruby gem #{Veritrans::VERSION}"
+        }
+      }
+
+      if method == "GET"
+        options.delete(:body)
+        options[:query] = URI.encode_www_form(params)
+      end
 
-    def new_api
-      return true
-    end
+      s_time = Time.now
+      request = Excon.new(url, read_timeout: 40, write_timeout: 40, connect_timeout: 40)
 
-    private
-    # Generate merchant hash code
-    def merchanthash
-      if version.to_i == 1    
-        return HashGenerator::generate(merchant_hash_key, merchant_id, order_id);
-      else
-        return Digest::SHA512.hexdigest("#{merchant_hash_key},#{merchant_id},01,#{order_id},#{gross_amount}")
-      end
-    end
+      response = request.send(method.downcase.to_sym, options.merge(path: URI.parse(url).path))
 
-    # deprecated
-    def parse_body(body)
-      arrs = body.split("\r\n")
-      arrs = arrs[-2,2] if arrs.length > 1
-      return Hash[arrs.collect{|x|x.split("=")}]
-    end
-  
-    def init_instance
-      @token = nil
-    end
+      logger.info "Veritrans: got #{(Time.now - s_time).round(3)} sec #{response.status} #{response.body}"
 
-    def prepare_params(*arg)
-      params = {}
-      # extract keys from post data
-      arg.flatten.each do |key|
-        # retrieve value from client configuration
-        value = self.send(key)
-        params[key.downcase] = value if value 
-      end
-      return params
-    end
+      Result.new(response, url, options, Time.now - s_time)
 
-    def delete_keys
-      @resp.delete(:ssl)
-      @resp.delete(:request)
-      @resp.delete(:response)
-      @resp.delete(:request_headers)
-      @resp.delete(:parallel_manager)
+    rescue Excon::Errors::SocketError => error
+      logger.info "PAPI: socket error, can not connect"
+      error_response = Excon::Response.new(
+        body: '{"status_code": "500", "status_message": "Internal server error, no response from backend. Try again later"}',
+        status: '500'
+      )
+      Veritrans::Result.new(error_response, url, options, Time.now - s_time)
     end
 
   end