Merge branch 'master' into registry-790

# Conflicts:
#	test/integration/epp/domain/domain_delete_test.rb
#	test/integration/epp/domain/domain_update_test.rb
#	test/integration/epp/domain/transfer/request_test.rb
#	test/system/admin_area/domains_test.rb

app/controllers/api/v1/registrant/auth_controller.rb

@@ -0,0 +1,54 @@
+require 'rails5_api_controller_backport'
+require 'auth_token/auth_token_creator'
+
+module Api
+  module V1
+    module Registrant
+      class AuthController < ActionController::API
+        before_action :check_ip_whitelist
+
+        rescue_from(ActionController::ParameterMissing) do |parameter_missing_exception|
+          error = {}
+          error[parameter_missing_exception.param] = ['parameter is required']
+          response = { errors: [error] }
+          render json: response, status: :unprocessable_entity
+        end
+
+        def eid
+          user = RegistrantUser.find_or_create_by_api_data(eid_params)
+          token = create_token(user)
+
+          if token
+            render json: token
+          else
+            render json: { errors: [{ base: ['Cannot create generate session token'] }] }
+          end
+        end
+
+        private
+
+        def eid_params
+          required_params = %i[ident first_name last_name]
+          required_params.each_with_object(params) do |key, obj|
+            obj.require(key)
+          end
+
+          params.permit(required_params)
+        end
+
+        def create_token(user)
+          token_creator = AuthTokenCreator.create_with_defaults(user)
+          hash = token_creator.token_in_hash
+          hash
+        end
+
+        def check_ip_whitelist
+          allowed_ips = ENV['registrant_api_auth_allowed_ips'].to_s.split(',').map(&:strip)
+          return if allowed_ips.include?(request.ip) || Rails.env.development?
+
+          render json: { errors: [{ base: ['Not authorized'] }] }, status: :unauthorized
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/registrant/base_controller.rb

@@ -0,0 +1,38 @@
+require 'rails5_api_controller_backport'
+require 'auth_token/auth_token_decryptor'
+
+module Api
+  module V1
+    module Registrant
+      class BaseController < ActionController::API
+        before_action :authenticate
+
+        rescue_from(ActionController::ParameterMissing) do |parameter_missing_exception|
+          error = {}
+          error[parameter_missing_exception.param] = ['parameter is required']
+          response = { errors: [error] }
+          render json: response, status: :unprocessable_entity
+        end
+
+        private
+
+        def bearer_token
+          pattern = /^Bearer /
+          header  = request.headers['Authorization']
+          header.gsub(pattern, '') if header&.match(pattern)
+        end
+
+        def authenticate
+          decryptor = AuthTokenDecryptor.create_with_defaults(bearer_token)
+          decryptor.decrypt_token
+
+          if decryptor.valid?
+            sign_in decryptor.user
+          else
+            render json: { errors: [{base: ['Not authorized']}] }, status: :unauthorized
+          end
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/registrant/domains_controller.rb

@@ -0,0 +1,49 @@
+require 'rails5_api_controller_backport'
+
+module Api
+  module V1
+    module Registrant
+      class DomainsController < BaseController
+        def index
+          limit = params[:limit] || 200
+          offset = params[:offset] || 0
+
+          if limit.to_i > 200 || limit.to_i < 1
+            render(json: { errors: [{ limit: ['parameter is out of range'] }] },
+                   status: :bad_request) && return
+          end
+
+          if offset.to_i.negative?
+            render(json: { errors: [{ offset: ['parameter is out of range'] }] },
+                   status: :bad_request) && return
+          end
+
+          @domains = associated_domains(current_user).limit(limit).offset(offset)
+          render json: @domains
+        end
+
+        def show
+          domain_pool = associated_domains(current_user)
+          @domain = domain_pool.find_by(uuid: params[:uuid])
+
+          if @domain
+            render json: @domain
+          else
+            render json: { errors: [{ base: ['Domain not found'] }] }, status: :not_found
+          end
+        end
+
+        private
+
+        def associated_domains(user)
+          country_code, ident = user.registrant_ident.split('-')
+
+          BusinessRegistryCache.fetch_associated_domains(ident, country_code)
+        rescue Soap::Arireg::NotAvailableError => error
+          Rails.logger.fatal("[EXCEPTION] #{error}")
+          user.domains
+        end
+      end
+    end
+  end
+end

app/models/concerns/domain_version_observer.rb

@@ -1,3 +0,0 @@
-module DomainVersionObserver
-  extend ActiveSupport::Concern
-end

app/models/registrant_user.rb

@@ -30,34 +30,56 @@ class RegistrantUser < User
       return false if issuer_organization != ACCEPTED_ISSUER
 
       idc_data.force_encoding('UTF-8')
+      user_data = {}
 
       # handling here new and old mode
       if idc_data.starts_with?("/")
-        identity_code = idc_data.scan(/serialNumber=(\d+)/).flatten.first
-        country       = idc_data.scan(/^\/C=(.{2})/).flatten.first
-        first_name    = idc_data.scan(%r{/GN=(.+)/serialNumber}).flatten.first
-        last_name     = idc_data.scan(%r{/SN=(.+)/GN}).flatten.first
+        user_data[:ident] = idc_data.scan(/serialNumber=(\d+)/).flatten.first
+        user_data[:country_code] = idc_data.scan(/^\/C=(.{2})/).flatten.first
+        user_data[:first_name] = idc_data.scan(%r{/GN=(.+)/serialNumber}).flatten.first
+        user_data[:last_name] = idc_data.scan(%r{/SN=(.+)/GN}).flatten.first
       else
         parse_str = "," + idc_data
-        identity_code = parse_str.scan(/,serialNumber=(\d+)/).flatten.first
-        country       = parse_str.scan(/,C=(.{2})/).flatten.first
-        first_name    = parse_str.scan(/,GN=([^,]+)/).flatten.first
-        last_name     = parse_str.scan(/,SN=([^,]+)/).flatten.first
+        user_data[:ident] = parse_str.scan(/,serialNumber=(\d+)/).flatten.first
+        user_data[:country_code] = parse_str.scan(/,C=(.{2})/).flatten.first
+        user_data[:first_name] = parse_str.scan(/,GN=([^,]+)/).flatten.first
+        user_data[:last_name] = parse_str.scan(/,SN=([^,]+)/).flatten.first
       end
 
-      u = where(registrant_ident: "#{country}-#{identity_code}").first_or_create
-      u.username = "#{first_name} #{last_name}"
-      u.save
+      find_or_create_by_user_data(user_data)
+    end
 
-      u
+    def find_or_create_by_api_data(user_data = {})
+      return false unless user_data[:ident]
+      return false unless user_data[:first_name]
+      return false unless user_data[:last_name]
+
+      user_data.each_value { |v| v.upcase! if v.is_a?(String) }
+      user_data[:country_code] ||= 'EE'
+
+      find_or_create_by_user_data(user_data)
     end
 
     def find_or_create_by_mid_data(response)
-      u = where(registrant_ident: "#{response.user_country}-#{response.user_id_code}").first_or_create
-      u.username = "#{response.user_givenname} #{response.user_surname}"
-      u.save
+      user_data = { first_name: response.user_givenname, last_name: response.user_surname,
+                    ident: response.user_id_code, country_code: response.user_country }
 
-      u
+      find_or_create_by_user_data(user_data)
+    end
+
+    private
+
+    def find_or_create_by_user_data(user_data = {})
+      return unless user_data[:first_name]
+      return unless user_data[:last_name]
+      return unless user_data[:ident]
+      return unless user_data[:country_code]
+
+      user = find_or_create_by(registrant_ident: "#{user_data[:country_code]}-#{user_data[:ident]}")
+      user.username = "#{user_data[:first_name]} #{user_data[:last_name]}"
+      user.save
+
+      user
     end
   end
 end

app/views/registrant/registrars/index.haml

@@ -1,21 +0,0 @@
-- content_for :actions do
-  = render 'shared/title', name: t(:registrars)
-
-.row
-  .col-md-12
-    .table-responsive
-      %table.table.table-hover.table-bordered.table-condensed
-        %thead
-          %tr
-            %th{class: 'col-xs-6'}
-              = sort_link(@q, 'name')
-            %th{class: 'col-xs-6'}
-              = sort_link(@q, 'reg_no', Registrar.human_attribute_name(:reg_no))
-        %tbody
-          - @registrars.each do |x|
-            %tr
-              %td= link_to(x, [:registrar, x])
-              %td= x.reg_no
-.row
-  .col-md-12
-    = paginate @registrars