oklog-api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ade0502599e017e35719e5ab72d43a7d496c1cbe831f4de48dba5096d103ea7
+  data.tar.gz: d2c926c063c82f889ecaaebe78cbd1e165d77d655d048e0e4362402a2f98d0ef
+SHA512:
+  metadata.gz: 01535c9bc906254cbea3ad0664bdaeb306ca6db8c999dc0f275b9b12cd6539e9552519206d411000db5f6188fd20340a8990666f984f76a80f1e95283fce3b2f
+  data.tar.gz: 4832f39fb0f6e4bae1141ff181b3e15df4d0657f5e17b03e95e3c885ba1169acdb429280c15c56a12f92e2623c70737cfbc478a2e64a39067e7813e8baba8101

data/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/generators/oklog_api/install/USAGE

@@ -0,0 +1,2 @@
+Description:
+  oklog_api:install

data/lib/generators/oklog_api/install/install_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module OklogApi
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    def generate_install
+      copy_file 'oklog_api.yml', 'config/oklog_api.yml'
+      copy_file 'oklog_api.rb', 'config/initializers/oklog_api.rb'
+    end
+  end
+end
+

data/lib/generators/oklog_api/install/templates/oklog_api.rb

@@ -0,0 +1,24 @@
+require 'oklog-api'
+
+OklogApi.setup do |config|
+  if File.exist?('config/oklog_api.yml')
+    processed = YAML.load('config/oklog_api.yml', aliases: true)[Rails.env]
+
+    processed.each do |k, v|
+      config::register k.underscore.to_sym, v
+    end
+
+    #config::Request.api_key ||= ENV['API_KEY']
+
+    config::Request.api_user_email ||= ENV['API_USER_EMAIL']
+    config::Request.api_user_password ||= ENV['API_USER_PASSWORD']
+
+    config::Request.timeout = 60
+    config::Request.open_timeout = 60
+    config::Request.symbolize_keys = true
+    config::Request.debug = false
+    config::Request.debug_options = { headers: true, bodies: false, errors: false, log_level: :info } # https://lostisland.github.io/faraday/middleware/logger
+
+    config::Request.language = defined?(I18n) ? I18n.locale : :ru
+  end
+end

data/lib/generators/oklog_api/install/templates/oklog_api.yml

@@ -0,0 +1,24 @@
+defaults: &defaults
+  API_ENDPOINT: "https://rail-scan.com"
+  UNION_ENDPOINT: "http://192.168.88.38:8000"
+  NOTIFY_ENDPOINT: "http://192.168.1.153:3003"
+  
+  API_AUTH_METHOD: "api_key"
+  API_KEY: "***"
+
+  API_USER_EMAIL: ""
+  API_USER_PASSWORD: ""
+
+  KEYCLOAK_TOKEN_URL: "https://iam.ctm.ru/auth/realms/ctm/protocol/openid-connect/token"
+  KEYCLOAK_GRANT_TYPE: "password"
+  KEYCLOAK_CLIENT_ID: "client_id"
+  KEYCLOAK_CLIENT_SECRET: "client_secret"
+  KEYCLOAK_REDIRECT_URI: "http://yousite.ru/callback"
+production:
+  <<: *defaults
+  UNION_ENDPOINT: "http://192.168.1.88:3500"
+  NOTIFY_ENDPOINT: "http://192.168.1.153:3003"
+development:
+  <<: *defaults
+test:
+  <<: *defaults

data/lib/oklog-api/api_request.rb

@@ -0,0 +1,427 @@
+module OklogApi
+  class APIRequest
+
+    def initialize(builder: nil)
+      @request_builder = builder
+    end
+
+    def post(params: nil, headers: nil, format: nil, body: {})
+      validate_api_key
+      begin
+        headers ||= {}
+        if is_multipart?(body)
+          if self.api_auth_method == :base64
+            headers['Authorization'] =  "Basic " + Base64::encode64("#{self.api_user_email}:#{self.api_user_password}")
+          end
+          if [:keycloak].include?(self.api_auth_method)
+            unless OklogApi::Request.token_alive?(OklogApi::Request.access_token)
+              if OklogApi::Request.token_alive?(OklogApi::Request.refresh_token)
+                response = OklogApi.refresh_access_token
+                OklogApi::Request.access_token = response.try(:dig, "access_token")
+                OklogApi::Request.refresh_token = response.try(:dig, "refresh_token")
+              else
+                error_params = { title: "UNAUTHORIZED", status_code: 401 }
+                error = OklogApiError.new("Token is unavailable", error_params)
+                raise error
+              end
+            end
+            headers['Authorization'] = "Bearer #{OklogApi::Request.access_token}"
+          end
+          if [:api_key].include?(self.api_auth_method)
+            request.headers['X-Api-Key'] = "#{OklogApi::Request.api_key}"
+            if self.api_user_id.present?
+              request.headers['X-User-Id'] = self.api_user_id.to_s
+            end
+          end
+          headers['User-Agent'] = "OklogApi/#{OklogApi::VERSION} Ruby gem"
+          headers['Accept-Language'] = OklogApi::Request.language.to_s
+          if @request_builder.without_ratelimit
+            headers['X-Is-Request-Without-RateLimit'] = "true"
+          end
+          if @request_builder.is_allow_access_to_coordinates
+            headers['X-Is-Allow-Access-To-Coordinates'] = "true"
+          end
+          url = URI("#{self.api_url}#{format.present? ? ".#{format}": ""}")
+          http = Net::HTTP.new(url.host, url.port);
+          request = Net::HTTP::Post.new(url, headers)
+          request.set_form body.to_params, 'multipart/form-data'
+          if @request_builder.debug
+            p request
+          end
+          http.request(request)
+        else
+          response = self.rest_client(format).post do |request|
+            configure_request(request: request, params: params, headers: headers, body: body)
+          end
+          if [nil, 'json'].include?(format)
+            parse_response(response)
+          else
+            response
+          end
+        end
+      rescue => e
+        handle_error(e)
+      end
+    end
+
+    def get(params: nil, headers: nil, format: nil, body: {})
+      validate_api_key
+
+      begin
+        response = self.rest_client(format).get do |request|
+          configure_request(request: request, params: params, headers: headers, body: body)
+        end
+        if [nil, 'json'].include?(format)
+          parse_response(response)
+        else
+          response
+        end
+      rescue => e
+        handle_error(e)
+      end
+    end
+
+    def delete(params: nil, headers: nil, format: nil, body: {})
+      validate_api_key
+      begin
+        response = self.rest_client(format).delete do |request|
+          configure_request(request: request, params: params, headers: headers, body: body)
+        end
+        if [nil, 'json'].include?(format)
+          parse_response(response)
+        else
+          response
+        end
+      rescue => e
+        handle_error(e)
+      end
+    end
+
+    def patch(params: nil, headers: nil, format: nil, body: {})
+      validate_api_key
+      begin
+        response = self.rest_client(format).patch do |request|
+          configure_request(request: request, params: params, headers: headers, body: body)
+        end
+        if [nil, 'json'].include?(format)
+          parse_response(response)
+        else
+          response
+        end
+      rescue => e
+        handle_error(e)
+      end
+    end
+
+    def put(params: nil, headers: nil, format: nil, body: {})
+      validate_api_key
+      begin
+        response = self.rest_client(format).put do |request|
+          configure_request(request: request, params: params, headers: headers, body: body)
+        end
+        if [nil, 'json'].include?(format)
+          parse_response(response)
+        else
+          response
+        end
+      rescue => e
+        handle_error(e)
+      end
+    end
+
+    protected
+
+    # Convenience accessors
+
+    def access_token
+      @request_builder.access_token
+    end
+
+    def refresh_token
+      @request_builder.refresh_token
+    end
+
+    def api_user_id
+      @request_builder.api_user_id
+    end
+
+    def api_key
+      @request_builder.api_key
+    end
+
+    def api_user_email
+      @request_builder.api_user_email
+    end
+
+    def api_user_password
+      @request_builder.api_user_password
+    end
+
+    def api_auth_method
+      @request_builder.api_auth_method
+    end
+
+    def api_endpoint
+      @request_builder.api_endpoint
+    end
+
+    def union_endpoint
+      @request_builder.union_endpoint
+    end
+
+    def notify_endpoint
+      @request_builder.notify_endpoint
+    end
+
+    def timeout
+      @request_builder.timeout
+    end
+
+    def open_timeout
+      @request_builder.open_timeout
+    end
+
+    def proxy
+      @request_builder.proxy
+    end
+
+    def ssl_options
+      @request_builder.ssl_options
+    end
+
+    def adapter
+      @request_builder.faraday_adapter
+    end
+
+    def symbolize_keys
+      @request_builder.symbolize_keys
+    end
+
+    # Helpers
+
+    def handle_error(error)
+      error_params = {}
+
+      begin
+        if error.is_a?(Faraday::ClientError) && error.response
+          error_params[:status_code] = error.response[:status]
+          error_params[:raw_body] = error.response[:body]
+
+          parsed_response = MultiJson.load(error.response[:body], symbolize_keys: symbolize_keys)
+
+          if parsed_response
+            error_params[:body] = parsed_response
+
+            title_key = symbolize_keys ? :title : "title"
+            detail_key = symbolize_keys ? :detail : "detail"
+
+            error_params[:title] = parsed_response[title_key] if parsed_response[title_key]
+            error_params[:detail] = parsed_response[detail_key] if parsed_response[detail_key]
+          end
+
+        end
+      rescue MultiJson::ParseError
+      end
+
+      error_to_raise = OklogApiError.new(error.message, error_params)
+
+      raise error_to_raise
+    end
+
+    def configure_request(request: nil, params: nil, headers: nil, body: nil)
+      if request
+        request.params.merge!(params) if params
+        request.headers ||= {}
+        request.headers['Content-Type'] = 'application/json'
+        if self.api_auth_method == :base64
+          request.headers['Authorization'] =  "Basic " + Base64::encode64("#{self.api_user_email}:#{self.api_user_password}")
+        end
+        if [:keycloak].include?(self.api_auth_method)
+          unless OklogApi::Request.token_alive?(OklogApi::Request.access_token)
+            if OklogApi::Request.token_alive?(OklogApi::Request.refresh_token)
+              response = OklogApi.refresh_access_token
+              OklogApi::Request.access_token = response.try(:dig, "access_token")
+              OklogApi::Request.refresh_token = response.try(:dig, "refresh_token")
+            else
+              error_params = { title: "UNAUTHORIZED", status_code: 401 }
+              error = OklogApiError.new("Token is unavailable", error_params)
+              raise error
+            end
+          end
+          request.headers['Authorization'] = "Bearer #{OklogApi::Request.access_token}"
+        end
+        if [:api_key].include?(self.api_auth_method)
+          request.headers['X-Api-Key'] = "#{OklogApi::Request.api_key}"
+          if self.api_user_id.present?
+            request.headers['X-User-Id'] = self.api_user_id.to_s
+          end
+        end
+        request.headers['User-Agent'] = "OklogApi/#{OklogApi::VERSION} Ruby gem"
+        request.headers['Accept-Language'] = OklogApi::Request.language.to_s
+        if @request_builder.without_ratelimit
+          request.headers['X-Is-Request-Without-RateLimit'] = "true"
+        end
+        if @request_builder.is_allow_access_to_coordinates
+          request.headers['X-Is-Allow-Access-To-Coordinates'] = "true"
+        end
+        request.headers.merge!(headers) if headers
+
+        request.body = MultiJson.dump(body) if body && request.headers['Content-Type'] == 'application/json'
+
+        request.options.timeout = self.timeout
+        request.options.open_timeout = self.open_timeout
+      end
+    end
+
+    def is_multipart?(body, result=false)
+      return false if body == {}
+      if body.is_a?(Hash)
+        body.inject({}) do |acc, kv|
+          result = is_multipart?(kv.last, result)
+        end
+      elsif body.is_a?(Array)
+        body.map do |item|
+          result = is_multipart?(item, result)
+        end
+        result
+      elsif [ActionDispatch::Http::UploadedFile, StringIO, Tempfile, File].include?(body.class)
+        return true
+      else
+        result || false
+      end
+    end
+
+    def rest_client(format=nil)
+      client = Faraday.new("#{self.api_url}#{format.present? ? ".#{format}": ""}", proxy: self.proxy,
+                           ssl: self.ssl_options) do |faraday|
+        faraday.request :gzip
+        faraday.response :raise_error
+        faraday.adapter adapter
+        if @request_builder.debug
+          faraday.response :logger, @request_builder.logger, @request_builder.debug_options
+        end
+      end
+      client
+    end
+
+    def parse_response(response)
+      parsed_response = nil
+
+      if response.body && !response.body.empty?
+        begin
+          headers = response.headers
+          body = MultiJson.load(response.body, symbolize_keys: symbolize_keys)
+          parsed_response = Response.new(headers: headers, body: body, status_code: response.env.status)
+        rescue MultiJson::ParseError
+          error_params = { title: "UNPARSEABLE_RESPONSE", status_code: 500 }
+          error = OklogApiError.new("Unparseable response: #{response.body}", error_params)
+          raise error
+        end
+      end
+
+      parsed_response
+    end
+
+    def validate_api_key
+      case self.api_auth_method
+      when :api_key
+        unless self.api_key# && self.api_endpoint
+          raise OklogApi::OklogApiError, "You must set an api_key prior to making a call #{self.api_key} #{self.api_endpoint}"
+        end
+      when :base64
+        unless self.api_user_email && self.api_user_password
+          raise OklogApi::OklogApiError, "You must set an api_user_email and an api_user_password prior to making a call #{self.api_user_email} #{self.api_user_password} #{self.api_endpoint}"
+        end
+      when :keycloak
+        unless self.access_token || self.refresh_token
+          raise OklogApi::OklogApiError, "You must set an access_token or a refresh_token prior to making a call #{self.access_token} #{self.refresh_token} #{self.api_endpoint}"
+        end
+      else
+        raise OklogApi::OklogApiError, "You must set an api_auth_method prior to making a call #{self.api_auth_method} #{self.api_endpoint}"
+      end
+    end
+
+    def api_url
+      first_path = @request_builder.path_parts.first
+      url = case @request_builder.path_parts.first
+            when "lk"
+              lk_api_url
+            when "notify"
+              notify_api_url
+            when "app"
+              app_api_url
+            when "union"
+              union_api_url
+            else
+              base_api_url
+            end
+      @request_builder.path_parts.shift if %w[union notify].include?(first_path)
+      url + @request_builder.path
+    end
+
+    def base_api_url
+      "#{OklogApi.api_endpoint}/api/v2.0/"
+    end
+
+    def lk_api_url
+      "https://rail-scan.com/"
+    end
+
+    def app_api_url
+      "https://rail-scan.com/"
+    end
+
+    def union_api_url
+      "#{OklogApi.union_endpoint}/api/v1.0/"
+    end
+
+    def notify_api_url
+      "#{OklogApi.notify_endpoint}/"
+    end
+  end
+end
+
+class Hash
+  def to_params(namespace = nil)
+    query = []
+    each do |key, value|
+      if value.present?
+        if value.is_a?(Hash) || value.is_a?(Array)
+          query += value.to_params(namespace ? "#{namespace}[#{key}]" : key)
+        else
+          query << value.to_params(namespace ? "#{namespace}[#{key}]" : key)
+        end
+      end
+    end
+    query
+  end
+end
+
+class Object
+  def to_params(key)
+    if self.is_a? ActionDispatch::Http::UploadedFile
+      [key.to_param, File.open(self.path),
+         {
+          :filename => self.original_filename,
+          :content_type => self.content_type
+         }
+      ]
+    elsif %w[File Tempfile StringIO].include?(self.class.name)
+      self
+    else
+      [key.to_param, to_param.to_s]
+    end
+  end
+end
+
+class Array
+  def to_params(key)
+    prefix = "#{key}[]"
+
+    if empty?
+      nil.to_params(prefix)
+    else
+      collect { |value| value.to_params(prefix) }
+    end
+  end
+end

data/lib/oklog-api/rail_locator_api_error.rb

@@ -0,0 +1,29 @@
+module OklogApi
+  class OklogApiError < StandardError
+    attr_reader :title, :detail, :body, :raw_body, :status_code
+
+    def initialize(message = "", params = {})
+      @title       = params[:title]
+      @detail      = params[:detail]
+      @body        = params[:body]
+      @raw_body    = params[:raw_body]
+      @status_code = params[:status_code]
+
+      super(message)
+    end
+
+    def to_s
+      super + " " + instance_variables_to_s
+    end
+
+    private
+
+    def instance_variables_to_s
+      [:title, :detail, :body, :raw_body, :status_code].map do |attr|
+        attr_value = send(attr)
+
+        "@#{attr}=#{attr_value.inspect}"
+      end.join(", ")
+    end
+  end
+end

data/lib/oklog-api/request.rb

@@ -0,0 +1,161 @@
+module OklogApi
+  class Request
+    attr_accessor :access_token, :refresh_token, :api_user_id, :api_key, :api_user_email, :api_user_password,
+                  :api_auth_method, :api_endpoint, :union_endpoint, :notify_endpoint,
+                  :timeout, :open_timeout, :proxy, :ssl_options, :faraday_adapter, :symbolize_keys, :debug, :debug_options,
+                  :without_ratelimit, :is_allow_access_to_coordinates, :logger, :test, :language
+
+    AUTH_METHODS = [:keycloak, :api_key, :base64]
+    DEFAULT_AUTH_METHOD = :api_key
+    DEFAULT_TIMEOUT = 60
+    DEFAULT_OPEN_TIMEOUT = 60
+    DEFAULT_LANGUAGE = :ru
+
+    def initialize(access_token: nil, refresh_token: nil, api_user_id: nil, api_key: nil, api_user_email: nil, api_user_password: nil,
+                   api_endpoint: nil, union_endpoint: nil, api_auth_method: nil, timeout: nil, open_timeout: nil, proxy: nil, ssl_options: nil,
+                   faraday_adapter: nil, symbolize_keys: false, debug: false,
+                   debug_options: { headers: true, bodies: false, errors: false, log_level: :info },
+                   without_ratelimit: false, is_allow_access_to_coordinates: false,
+                   logger: nil, test: false, language: DEFAULT_LANGUAGE)
+
+      @path_parts = []
+      @api_key = api_key || self.class.api_key || ENV['RAIL_LOCATOR_API_KEY']
+      @api_key = @api_key.strip if @api_key
+
+      @api_user_id = api_user_id
+
+      if @api_key == :keycloak
+        @access_token = access_token || self.class.access_token || OklogApi.generate_access_token.try(:dig, "access_token")
+        @access_token = @access_token.strip if @access_token
+        @refresh_token = refresh_token  || self.class.refresh_token
+        @refresh_token = @refresh_token.strip if @refresh_token
+      else
+        @access_token = ""
+        @refresh_token = ""
+      end
+
+      @api_user_email = api_user_email || ENV['API_USER_EMAIL'] || ""
+      @api_user_password = api_user_password || ENV['API_USER_PASSWORD'] || ""
+
+      @api_endpoint = api_endpoint || self.class.api_endpoint
+      @api_endpoint = OklogApi::api_endpoint if @api_endpoint.nil?
+      @union_endpoint = union_endpoint || self.class.union_endpoint
+      @union_endpoint = OklogApi::union_endpoint if @union_endpoint.nil?
+
+      @api_auth_method = api_auth_method || OklogApi::api_auth_method || DEFAULT_AUTH_METHOD
+      @timeout = timeout || self.class.timeout || DEFAULT_TIMEOUT
+      @open_timeout = open_timeout || self.class.open_timeout || DEFAULT_OPEN_TIMEOUT
+      @proxy = proxy || self.class.proxy || ENV['RAIL_LOCATOR_API_PROXY']
+      @ssl_options = ssl_options || self.class.ssl_options || { version: "TLSv1_2" }
+      @faraday_adapter = faraday_adapter || self.class.faraday_adapter || Faraday.default_adapter
+      @symbolize_keys = symbolize_keys || self.class.symbolize_keys || false
+      @debug = debug || self.class.debug || false
+      @debug_options = debug_options || self.class.debug_options || { headers: true, bodies: false, errors: false, log_level: :info }
+      @without_ratelimit = without_ratelimit || self.class.without_ratelimit
+      @is_allow_access_to_coordinates = is_allow_access_to_coordinates || self.class.is_allow_access_to_coordinates
+      @test = test || self.class.test || false
+      @language = language || DEFAULT_LANGUAGE
+      @logger = logger || self.class.logger || ::Logger.new(STDOUT)
+    end
+
+    def method_missing(method, *args)
+      @path_parts << method.to_s.downcase
+      @path_parts << args if args.length > 0
+      @path_parts.flatten!
+      self
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      true
+    end
+
+    def send(*args)
+      if args.length == 0
+        method_missing(:send, args)
+      else
+        __send__(*args)
+      end
+    end
+
+    def path_parts
+      @path_parts
+    end
+
+    def path
+      @path_parts.join('/')
+    end
+
+    def create(params: nil, headers: nil, body: {}, format: nil)
+      APIRequest.new(builder: self).post(params: params, headers: headers, body: body, format: format)
+    ensure
+      reset
+    end
+
+    def update(params: nil, headers: nil, body: {}, format: nil)
+      APIRequest.new(builder: self).patch(params: params, headers: headers, body: body, format: format)
+    ensure
+      reset
+    end
+
+    def insert(params: nil, headers: nil, body: {}, format: nil)
+      APIRequest.new(builder: self).put(params: params, headers: headers, body: body, format: format)
+    ensure
+      reset
+    end
+
+    def retrieve(params: nil, headers: nil, body: {}, format: nil)
+      APIRequest.new(builder: self).get(params: params, headers: headers, body: body, format: format)
+    ensure
+      reset
+    end
+
+    def delete(params: nil, headers: nil, body: {})
+      APIRequest.new(builder: self).delete(params: params, headers: headers, body: body)
+    ensure
+      reset
+    end
+
+    def token_alive?(token, jwt_secret_code=OklogApi.keycloak_client_secret)
+      begin
+        return false if token.nil?
+        exp = JWT.decode(token, jwt_secret_code, false).try(:first).try(:dig, "exp")
+        return false if exp.nil?
+        Time.at(exp) > Time.now + 30.second
+      rescue => e
+        #Sentry.capture_exception(e)
+        false
+      end
+    end
+
+    protected
+
+    def reset
+      @path_parts = []
+    end
+
+    class << self
+      attr_accessor :access_token, :refresh_token, :api_user_id, :api_key, :api_user_email, :api_user_password, :api_auth_method,
+                    :timeout, :open_timeout, :api_endpoint, :union_endpoint, :notify_endpoint,
+                    :proxy, :ssl_options, :faraday_adapter, :symbolize_keys,
+                    :debug, :debug_options, :without_ratelimit, :is_allow_access_to_coordinates, :logger, :test, :language
+
+      def method_missing(sym, *args, &block)
+        new(access_token: self.access_token, refresh_token: self.refresh_token,
+            api_user_id: self.api_user_id,
+            api_key: self.api_key,
+            api_user_email: self.api_user_email, api_user_password: self.api_user_password,
+            api_auth_method: self.api_auth_method, api_endpoint: self.api_endpoint, union_endpoint: self.union_endpoint,
+            timeout: self.timeout, open_timeout: self.open_timeout, faraday_adapter: self.faraday_adapter,
+            symbolize_keys: self.symbolize_keys, debug: self.debug, debug_options: self.debug_options,
+            without_ratelimit: self.without_ratelimit,
+            is_allow_access_to_coordinates: self.is_allow_access_to_coordinates,
+            proxy: self.proxy, ssl_options: self.ssl_options, logger: self.logger,
+            test: self.test, language: self.language).send(sym, *args, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/oklog-api/response.rb

@@ -0,0 +1,11 @@
+module OklogApi
+  class Response
+    attr_accessor :body, :headers, :status_code
+    
+    def initialize(body: {}, headers: {}, status_code: nil)
+      @body = body
+      @headers = headers
+      @status_code = status_code
+    end 
+  end
+end

data/lib/oklog-api/version.rb

@@ -0,0 +1,3 @@
+module OklogApi
+  VERSION = "1.0.0"
+end

data/lib/oklog-api.rb

@@ -0,0 +1,91 @@
+require 'faraday'
+require 'faraday/gzip'
+require 'net/http/post/multipart'
+require 'multi_json'
+require 'oklog-api/version'
+require 'oklog-api/oklog_api_error'
+require 'oklog-api/request'
+require 'oklog-api/api_request'
+require 'oklog-api/response'
+
+module OklogApi
+  class << self
+    def generate_access_token(code=nil)
+      if OklogApi.keycloak_grant_type == "password"
+        payload = "grant_type=#{OklogApi.keycloak_grant_type}&client_id=#{OklogApi.keycloak_client_id}&username=#{OklogApi.api_user_email}&password=#{OklogApi.api_user_password}"
+      else
+        payload = "grant_type=#{OklogApi.keycloak_grant_type}&client_id=#{OklogApi.keycloak_client_id}&client_secret=#{OklogApi.keycloak_client_secret}&code=#{code ||OklogApi::Request.access_token}&redirect_uri=#{OklogApi.keycloak_redirect_uri}"
+      end
+      connection = Faraday.new(OklogApi.keycloak_token_url, proxy: nil,
+                               ssl: OklogApi::Request.ssl_options || { version: "TLSv1_2" }) do |faraday|
+        faraday.adapter Faraday.default_adapter
+        faraday.response :logger, ::Logger.new(STDOUT), bodies: true
+      end
+
+      response = connection.post OklogApi.keycloak_token_url, payload do |request|
+        request.headers['accept'] = 'application/json'
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def refresh_access_token
+      payload = "grant_type=refresh_token&client_id=#{OklogApi.keycloak_client_id}&client_secret=#{OklogApi.keycloak_client_secret}&refresh_token=#{OklogApi::Request.refresh_token}&redirect_uri=#{OklogApi.keycloak_redirect_uri}"
+      connection = Faraday.new(OklogApi.keycloak_token_url, proxy: nil,
+                               ssl: OklogApi::Request.ssl_options || { version: "TLSv1_2" }) do |faraday|
+        faraday.adapter Faraday.default_adapter
+        faraday.response :logger, ::Logger.new(STDOUT), bodies: true
+      end
+
+      response = connection.post OklogApi.keycloak_token_url, payload do |request|
+        request.headers['accept'] = 'application/json'
+      end
+
+      JSON.parse(response.body)
+    end
+
+    def setup
+      yield self
+    end
+
+    def register(name, value, type = nil)
+      cattr_accessor "#{name}_setting".to_sym
+
+      add_reader(name)
+      add_writer(name, type)
+      send "#{name}=", value
+    end
+
+    def add_reader(name)
+      define_singleton_method(name) do |*args|
+        send("#{name}_setting").value(*args)
+      end
+    end
+
+    def add_writer(name, type)
+      define_singleton_method("#{name}=") do |value|
+        send("#{name}_setting=", DynamicSetting.build(value, type))
+      end
+    end
+  end
+
+  class DynamicSetting
+    def self.build(setting, type)
+      (type ? klass(type) : self).new(setting)
+    end
+
+    def self.klass(type)
+      klass = "#{type.to_s.camelcase}Setting"
+      raise ArgumentError, "Unknown type: #{type}" unless OklogApi.const_defined?(klass)
+      OklogApi.const_get(klass)
+    end
+
+    def initialize(setting)
+      @setting = setting
+    end
+
+    def value(*_args)
+      @setting
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: oklog-api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Pavel Osetrov
+bindir: bin
+cert_chain: []
+date: 2025-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: faraday-gzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: ''
+email: p.osetrov@daobit.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.markdown
+- lib/generators/oklog_api/install/USAGE
+- lib/generators/oklog_api/install/install_generator.rb
+- lib/generators/oklog_api/install/templates/oklog_api.rb
+- lib/generators/oklog_api/install/templates/oklog_api.yml
+- lib/oklog-api.rb
+- lib/oklog-api/api_request.rb
+- lib/oklog-api/rail_locator_api_error.rb
+- lib/oklog-api/request.rb
+- lib/oklog-api/response.rb
+- lib/oklog-api/version.rb
+homepage: https://oklog.ru
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.3
+specification_version: 4
+summary: OkLog API
+test_files: []