tochka_cyclops_api 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2844cc465020d8597bfa869d80e33d850a2a33c26bd4f302adb7a620a9a71321
-  data.tar.gz: 35ed83f97f6d37d24d72fdceff93f11ac2057ea8d3df5b20487e9cafeacb1155
+  metadata.gz: 36957c52f3476c825762fda41ec211a1a55d7eb15337c3eae48e32cb38d61419
+  data.tar.gz: d3d39943258ce772f1a8f949c5bcee9f1abb692d189775b67c0873d2ab98ebd4
 SHA512:
-  metadata.gz: 3bf2d583aa03a2e6758e6f5cd9d04a34f97baf307bb83244e07524256b61b7ab94337ac2e05aff8206a10f3ff83a7ecffce77d156c6392879da02b1bd753d447
-  data.tar.gz: 8a9f1760504c78697fd2e9d9f7691530d7270e0ec9a2cab87bba1611b8dcc88e15eceaff60a297507330b1d09601cfd0f46b819525ab741c48a1edc69f62e103
+  metadata.gz: '096c88b4842314462b00977f267448bb6a3ee4043dc0b3d0efd921806f14be7655d43122b2e476216df9775b93fdf2cc214d119f95177c80cc6dad3ab41a43a1'
+  data.tar.gz: 9ebfe7d51a013072ddfa6b6ba33dcb767262a93eb1f57fd4c59aa1147422cf4377bcbe1f2683625c6e2d7495b48b348f882c844781fabe8a7c9cb495c1e0a1d0

data/README.md

@@ -8,6 +8,7 @@ A simple way to interact with the ["Tochka" bank's api][api_source_page]
   - [Installation](#installation)
   - [Settings](#settings)
 - [Usage](#usage)
+  - [Rake tasks](#rake)
 
 ## Getting started
 
@@ -16,19 +17,26 @@ A simple way to interact with the ["Tochka" bank's api][api_source_page]
 Add this line to your application's Gemfile:
 
 ```sh
-bundle add tochka_cylops_api
+bundle add tochka_cyclops_api
 ```
 
-and run commands bellow to create the initializer, models and migrations:
+and run commands bellow to create models, migrations and the initializer:
 
 ```sh
 rails generate tochka_cyclops_api:models
 rails generate tochka_cyclops_api:initializer
 ```
 
+to use rake tasks you should also add the following lines to Rakefile of your Rails project:
+
+```ruby
+spec = Gem::Specification.find_by_name 'tochka_cyclops_api'
+load "#{spec.gem_dir}/lib/tasks/methods.rake"
+```
+
 ### Settings
 
-You have to set the settings in the initializer file (_config/initializers/healthcheck.rb_):
+You have to set the settings in the initializer file (_config/initializers/tochka_cyclops_api.rb_):
 
 ```ruby
 # frozen_string_literal: true
@@ -50,11 +58,58 @@ TochkaCyclopsApi.send_request(method, data)
 method - name of the method defined on the bank side point;
 data - hash of the value required to fulfill the request.
 
-For example:
+There are special rake tasks to get information about available methods:
+
+```sh
+bundle exec rake methods:list
+bundle exec rake methods:desc method=method_name
+```
+
+Examples
+```sh
+> bundle exec rake methods:list
+# ** Invoke methods:list (first_time)
+# ** Execute methods:list
+# echo
+# create_beneficiary_ul
+# create_beneficiary_ip
+# ...
+
+> bundle exec rake methods:desc method=create_beneficiary_ul
+# ** Invoke methods:desc (first_time)
+# ** Execute methods:desc
+# inn                  | mandatory | string
+# nominal_account_code | optional  | string
+# nominal_account_bic  | optional  | string
+# beneficiary_data     | mandatory | {
+#                                       name | mandatory | string
+#                                       kpp  | mandatory | string
+#                                       ogrn | optional  | string
+#                                    }
+#
+# ================================================================================
+#
+# EXAMPLE
+#
+# {
+#   inn: '7743745038',
+#   nominal_account_code: '40702810338170022645',
+#   nominal_account_bic: '044525225',
+#   beneficiary_data: {
+#     name: 'ООО «ТК ИнжСтройКомплект»',
+#     kpp: '773401001',
+#     ogrn: '1097746324169'
+#   }
+# }
+```
+
+Example of sending request:
 ```ruby
-TochkaCyclopsApi.send(
-  inicialize_beneficiary_ul,
-  {
+TochkaCyclopsApi.send_request(
+  # Method contains the name of the TochkaCyclopsApi method
+  method: 'create_beneficiary_ul',
+  # Data is value for the "params" field of request body
+  data: {
     inn: "7925930371",
     nominal_account_code: "000000000000000000000",
     nominal_account_bic: "0000000000",
@@ -62,7 +117,9 @@ TochkaCyclopsApi.send(
         name: "ООО \"Рога и Копыта\"",
         kpp: "246301001"
     }
-  }
+  },
+  # Layer have to has one of the following values: :stage, :pre, :prod
+  layer: :stage
 )
 ```
 

data/Rakefile

@@ -8,7 +8,3 @@ require_relative 'lib/tochka_cyclops_api/methods'
 RuboCop::RakeTask.new
 
 task default: :rubocop
-
-task :methods do
-  puts TochkaCyclopsApi::METHODS
-end

data/lib/tasks/methods.rake

@@ -0,0 +1,11 @@
+desc "Displays a list of available methods."
+
+namespace :methods do
+  task :list do
+    puts TochkaCyclopsApi::Methods::METHODS
+  end
+
+  task :desc do
+    puts TochkaCyclopsApi::Methods.get_method(ENV['method'])
+  end
+end

data/lib/tochka_cyclops_api/data_processor.rb

@@ -6,56 +6,81 @@ require 'securerandom'
 require 'json'
 
 require_relative 'request'
+require_relative 'result'
 require_relative 'schemas/requests/echo'
 
 module TochkaCyclopsApi
   # Module for input data validation and subsequent request invocation
-  module DataProcessor
-    def send_request(method, data)
+  class DataProcessor
+    def self.send_request(method:, data:, layer: )
       @method = method
       @data = data
-      @id = SecureRandom.uuid
+      @layer = layer
+      @errors = {}
+      @url = url_for
+      @request_id = SecureRandom.uuid
+      schemas
+      validation = @request_schema&.call(@data.deep_symbolize_keys)
+      @validation_errors = validation&.errors.to_h
 
-      return @errors.map { |k, v| [k, v].join(' ') }.join(', ') unless valid_params?
-
-      send_data
+      call
     end
 
     private
 
-    def valid_params?
-      if shape
-        result = shape.call(@data.deep_symbolize_keys)
-        @errors = result.errors.to_h
+    def self.call
+      @errors[:url] = "Layer you called for is not exist" if @url.nil?
+      @errors[:request_schema] = "Request schema for method #{@method} is not found" if @request_schema.nil?
+      @errors[:response_schema] = "Response schema for method #{@method} is not found" if @response_schema.nil?
+
+      @errors[:validation] = @validation_errors if @request_schemas.present?
+
+      if @errors.keys.any?
+        Result.failure(@errors)
+      else
+        TochkaCyclopsApi::Request.send_request(method: @method, body: body, url: @url)
       end
+    end
 
-      @errors.empty?
+    def self.url_for
+      {
+        stage: 'https://stage.tochka.com/api/v1/cyclops',
+        pre: 'https://pre.tochka.com/api/v1/cyclops',
+        prod: 'https://api.tochka.com/api/v1/cyclops'
+      }.fetch(@layer, nil)
     end
 
-    def send_data
-      TochkaCyclopsApi::Request.send(body, @method)
+    def self.schemas
+      @request_schema = request_schema
+      @response_schema = response_schema
     end
 
-    def shape
+    def self.request_schema
       require_relative "schemas/requests/#{@method}"
       schema = ['TochkaCyclopsApi', 'Schemas', 'Requests', camel_case_method].join('::').constantize
 
       schema.new
     rescue => e
-      @errors = { error: e.message }
-      false
+      nil
+    end
+
+    def self.response_schema
+      require_relative "schemas/responses/#{@method}"
+      schema = ['TochkaCyclopsApi', 'Schemas', 'Responses', camel_case_method].join('::').constantize
+    rescue => e
+      nil
     end
 
-    def camel_case_method
+    def self.camel_case_method
       @method.split('_').map(&:capitalize).join
     end
 
-    def body
+    def self.body
       {
         "jsonrpc": '2.0',
         "method": @method,
         "params": @data,
-        "id": @id
+        "id": @request_id
       }.to_json
     end
   end

data/lib/tochka_cyclops_api/generators/templates/tochka_cyclops_request_model_template.rb

@@ -3,5 +3,5 @@
 # RequestModel generator
 class TochkaCyclopsRequest < ActiveRecord::Base
   belongs_to :result, polymorphic: true
-  enum :status, %w[initialized failed finished]
+  enum :status, %w[initialized failure success]
 end

data/lib/tochka_cyclops_api/generators/templates/tochka_cyclops_responses_migration_template.rb

@@ -3,7 +3,7 @@
 # ResponsesMigration generator
 class CreateTochkaCyclopsResponses < ActiveRecord::Migration[6.0]
   def change
-    create_table :tochka_cyclops_response do |t|
+    create_table :tochka_cyclops_responses do |t|
       t.jsonb :body
       t.jsonb :result
       t.timestamps

data/lib/tochka_cyclops_api/methods.rb

@@ -1,9 +1,202 @@
 # frozen_string_literal: true
 
+require 'dry/schema'
+
+Undefined = Dry::Schema::Undefined
+
+module Types
+  include Dry.Types()
+end
+
+class DocCompiler
+  def visit(node)
+    meth, rest = node
+    public_send(:"visit_#{meth}", rest)
+  end
+
+  def visit_set(nodes)
+    nodes.map { |node| visit(node) }.flatten(1)
+  end
+
+  def visit_and(node)
+    left, right = node
+    [visit(left), visit(right)].compact
+  end
+
+  def visit_key(node)
+    name, rest = node
+
+    predicates = visit(rest).flatten
+
+    if predicates[0].is_a? Symbol
+      validations = predicate_description(predicates[0], predicates[1])
+
+      { key: name, validations: validations }
+    else
+      { key: name, validations: predicates }
+    end
+  end
+
+  def visit_implication(node)
+    _, right = node.map(&method(:visit))
+    right.merge(optional: true)
+  end
+
+  def visit_predicate(node)
+    name, args = node
+
+    return if name.equal?(:key?)
+
+    { name => args.map(&:last).reject { |v| v.equal?(Dry::Schema::Undefined) } }
+  end
+
+  def predicate_description(name, args)
+    case name
+    when :str? then "string"
+    when :bool? then "true/false"
+    when :filled? then "filled"
+    when :int? then "integer"
+    when :gt? then "greater than #{args[0]}"
+    else
+      raise NotImplementedError, "#{name} not supported yet"
+    end
+  end
+end
+
 module TochkaCyclopsApi
-  METHODS = %w[
-    echo
-    create_beneficiary_ul
-    create_beneficiary_ip
-  ]
+  class Methods
+    METHODS = %w[
+      echo
+      create_beneficiary_ul
+      create_beneficiary_ip
+      create_beneficiary_fl
+      update_beneficiary_ul
+      update_beneficiary_ip
+      update_beneficiary_fl
+      get_beneficiary
+      list_beneficiary
+      activate_beneficiary
+      deactivate_beneficiary
+    ]
+
+    DIVIDER = ["\n", "="*80, "\n"]
+
+    def self.get_method(method)
+      return unless method_exists? method
+
+      require_relative "schemas/requests/#{method}"
+
+      @method = method
+
+      define_schema_class
+      define_schema_ast
+      parse_schema_ast
+      @formatted_schema_ast = format_schema_ast
+      show_schema
+
+      puts @method.split('_').map(&:capitalize).join
+      puts @formatted_schema_ast
+      puts DIVIDER
+      puts ['EXAMPLE', "\n"]
+      puts @schema_class.const_get('EXAMPLE')
+    end
+
+    private
+
+    def self.method_exists?(method)
+      return true if method.in? METHODS
+
+      puts "Method #{method} is not found"
+      false
+    end
+
+    def self.define_schema_class
+      @schema_class = [
+        "TochkaCyclopsApi",
+        "Schemas",
+        "Requests",
+        camel_case(@method)].join('::').constantize
+    end
+
+    def self.define_schema_ast
+      @schema_ast = @schema_class.new.schema.ast
+    end
+
+    def self.parse_schema_ast
+      compiler = DocCompiler.new
+
+      @schema_ast = compiler.visit(@schema_ast).map do |row|
+        key = row[:key]
+        validations = row[:validations]
+        optional = row[:optional] ? 'optional' : 'mandatory'
+
+        if validations.is_a? Array
+          validations = validations.map do |validation|
+            v_key = validation[:key]
+            v_validations = validation[:validations]
+            v_optional = validation[:optional] ? 'optional' : 'mandatory'
+
+            [v_key, v_optional, v_validations]
+          end
+        end
+        [key, optional, validations]
+      end
+    end
+
+    def self.column_sizes(array)
+      sizes = []
+      3.times do |index|
+        size = array.map do |row|
+          next if row[index].is_a? Array
+
+          row[index].to_s.length
+        end
+        sizes << size.compact.max
+      end
+      sizes
+    end
+
+    def self.format_schema_ast(array = @schema_ast)
+      sizes = column_sizes(array)
+      array.map do |sub_array|
+        sub_array.each_with_index.map { |row, index| format_row(row, sizes[index]) }
+      end
+    end
+
+    def self.format_row(row, indent)
+      if row.is_a? Array
+        format_schema_ast(row)
+      else
+        row.to_s.ljust(indent)
+      end
+    end
+
+    def self.show_schema
+      @formatted_schema_ast.map! do |row|
+        array = row.select { |element| element.is_a? Array }.last
+        if array.present?
+          max_first_element_size = array.map { |row| row[0].strip.to_s.length }.max
+
+          # 9 is size of 2 dividers (" | ") and 1 brace
+          row_indent = row[0].size + row[1].size + 7
+
+          # 2 is 2 spaces indent
+          array.map! do |row|
+            row[0] = row[0].rjust(row_indent + max_first_element_size + 2)
+            row.join(' | ')
+          end
+
+          array = ["{"] + array + ["}".rjust(row_indent)]
+
+          row[-1] = array.join("\n")
+        end
+        row.join(' | ')
+      end
+    end
+
+
+    def self.camel_case(string)
+      string.split('_').map(&:capitalize).join
+    end
+  end
 end

data/lib/tochka_cyclops_api/request.rb

@@ -6,53 +6,88 @@ require_relative 'response'
 
 module TochkaCyclopsApi
   # Module for sending requests to the bank's api
-  module Request
-    def self.send(body, method)
+  class Request
+    def self.send_request(body:, method:, url: )
       @method = method
-      initialize_request(body)
+      @body = body
+      @uri = URI(url)
+      @request_object = initialize_request_object
+      @post_request = initialize_post_request
+      @adapter = initialize_adapter
 
-      uri = URI('https://pre.tochka.com/api/v1/cyclops/v2/jsonrpc')
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
+      call
+    end
 
-      request = Net::HTTP::Post.new(uri, {
-        'sign-data' => signature(body),
-        'sign-thumbprint' => TochkaCyclopsApi.configuration.sign_thumbprint,
-        'sign-system' => TochkaCyclopsApi.configuration.sign_system,
-        'Content-Type' => 'application/pdf'
-      })
-      request.body = body
+    private
 
-      response = http.request(request)
+    def self.call
+      get_response
+      response = handle_response
 
-      case response.code.to_i
-      when (200..299)
-        @request.update(status: 'finished')
-        TochkaCyclopsApi::Response.create(@request, response, method)
-      when (400..499)
-        -> { 'Our server error' }[]
+      case response[:status]
+      when :error
+        Result.failure(response[:data])
       else
-        @request.update(status: 'failed')
-        -> { 'Their server error' }[]
+        Response.new(request: @request_object, response: response[:data], method: @method)
       end
     end
 
-    def self.signature(body)
-      digest = OpenSSL::Digest.new('sha256')
-      private_key = OpenSSL::PKey::RSA.new(TochkaCyclopsApi.configuration.private_key)
-      signature_key = private_key.sign(digest, body)
-      base64_signature = Base64.strict_encode64(signature_key)
-      base64_signature.gsub("\n", '')
+    def self.initialize_adapter
+      adapter = Net::HTTP.new(@uri.host, @uri.port)
+      adapter.use_ssl = true
+      adapter
     end
 
-    def self.initialize_request(body)
-      @request = TochkaCyclopsRequest.create(
+    def self.initialize_request_object
+      TochkaCyclopsRequest.create(
         method: @method,
-        body: body,
+        body: @body,
         request_identifier: @id,
         # idempotency_key:
         status: 'initialized'
       )
     end
+
+    def self.initialize_post_request
+      post_request = Net::HTTP::Post.new(@uri, {
+        'sign-data' => signature,
+        'sign-thumbprint' => TochkaCyclopsApi.configuration.sign_thumbprint,
+        'sign-system' => TochkaCyclopsApi.configuration.sign_system,
+        'Content-Type' => 'application/json'
+      })
+      post_request.body = @body
+      post_request
+    end
+
+    def self.get_response
+      @response = @adapter.request(@post_request)
+    rescue => e
+      @error = { request_error: e }
+    end
+
+    def self.handle_response
+      return { status: :error, data: @error } if @error
+
+      status =  case @response.code.to_i
+                when (200..299)
+                  {
+                    status: :ok,
+                    data: @response
+                  }
+                else
+                  {
+                    status: :error,
+                    data: { request_error: @response }
+                  }
+                end
+    end
+
+    def self.signature
+      digest = OpenSSL::Digest.new('sha256')
+      private_key = OpenSSL::PKey::RSA.new(TochkaCyclopsApi.configuration.private_key)
+      signature_key = private_key.sign(digest, @body)
+      base64_signature = Base64.strict_encode64(signature_key)
+      base64_signature.gsub("\n", '')
+    end
   end
 end

data/lib/tochka_cyclops_api/response.rb

@@ -1,63 +1,56 @@
 # frozen_string_literal: true
 
-require_relative 'schemas/responses/echo'
+require_relative 'schemas/responses/error'
 
 module TochkaCyclopsApi
   # Class for processing the response received from the api bank
   class Response
-    def self.create(request, response, method)
-      @method = method
+    def self.create(request: ,response: ,method:)
       @request = request
-      @response = response
-      parse
+      @method = method
+      @body = JSON.parse(response.body)
+      @response_schema = "TochkaCyclopsApi::Schemas::Responses::#{camel_case_method}".constantize
+      @error_schema = 'TochkaCyclopsApi::Schemas::Responses::Error'.constantize
 
-      {
-        response_struct: @response_struct,
-        result: @result
-      }
+      call
     end
 
-    def self.parse
-      @body = JSON.parse(@response.body)
-      if @body.key? 'result'
-        parse_result
-      elsif @body.key? 'error'
+    private
+
+    def self.call
+      @result = @body['result']
+      @error = @body['error']
+
+      if @error.present?
         parse_error
+      else
+        parse_result
       end
     end
 
     def self.parse_result
-      @result = @body['result']
-      response_schema = schema || -> { "Schema for #{@method} is not found" }[]
+      return nil if @result.nil?
 
-      @response = TochkaCyclopsResponse.create(body: @body, result: @result)
-      @request.update(result: @response)
+      response = TochkaCyclopsResponse.create(body: @body, result: @result)
+      @request.update(result: response, status: 'success')
       @result.deep_symbolize_keys if @result.is_a? Hash
-      @response_struct = response_schema.new(@result)
+      response_struct = @response_schema.new(@result)
+
+      Result.success(response_struct)
     end
 
     def self.parse_error
-      @error = @body['error']
-      require_relative 'schemas/responses/error'
-      response_schema = 'TochkaCyclopsApi::Schemas::Responses::Error'.constantize
+      return nil if @error.nil?
 
-      @response = TochkaCyclopsError.create(
+      response = TochkaCyclopsError.create(
         body: @body,
         code: @error['code'],
         message: @error['message']
       )
+      @request.update(result: response, status: 'failure')
+      response_struct = @error_schema.new(@error.deep_symbolize_keys)
 
-      @request.update(result: @response)
-
-      @response_struct = response_schema.new(@error.deep_symbolize_keys)
-    end
-
-    def self.schema
-      require_relative "schemas/responses/#{@method}"
-      "TochkaCyclopsApi::Schemas::Responses::#{camel_case_method}".constantize
-    rescue StandardError => e
-      @errors = { error: e.message }
-      false
+      Result.success(response_struct)
     end
 
     def self.camel_case_method