Merge remote-tracking branch 'origin/master' into 1739-ns-bulk-change-test-and-whois-update

2025-06-04 11:47:30 +02:00 · 2020-12-22 12:52:33 +02:00 · 2020-12-22 12:52:33 +02:00 · c1aa286e90
commit c1aa286e90
parent 12cdc868de f80c597be8
192 changed files with 5154 additions and 1343 deletions
--- a/.codeclimate.yml
+++ b/.codeclimate.yml
@ -20,6 +20,9 @@ plugins:
    channel: eslint-5
  fixme:
    enabled: true
+    checks:
+      TODO:
+        enabled: false
  rubocop:
    enabled: true
    channel: rubocop-0-74
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@ -0,0 +1,117 @@
+name: Github Testing
+on: [push]
+
+
+jobs:
+  test:
+    services:
+      postgres:
+        image: postgres:12
+        ports: ["5432:5432"]
+        env:
+          POSTGRES_PASSWORD: password
+          POSTGRES_USERNAME: postgres
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04]
+        ruby: [2.6, 2.7 ]
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ endsWith(matrix.ruby, 'head') || matrix.ruby == 'debug' }}
+    steps:
+
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: config bundler
+      run:  |
+        bundle config set without 'development staging production'
+        bundle config set deployment '[secure]'
+        bundle env
+        head -n1 $(which bundle)
+
+    - name: Set ENV for codeclimate (pull_request)
+      run: |
+          git fetch --no-tags --prune --depth=1 origin +refs/heads/$GITHUB_HEAD_REF:refs/remotes/origin/$GITHUB_HEAD_REF
+          echo "GIT_BRANCH=$GITHUB_HEAD_REF" >> $GITHUB_ENV
+          echo "GIT_COMMIT_SHA=$(git rev-parse origin/$GITHUB_HEAD_REF)" >> $GITHUB_ENV
+      if: github.event_name == 'pull_request'
+
+    - name: Set ENV for codeclimate (push)
+      run: |
+          echo "GIT_BRANCH=$GITHUB_REF" >> $GITHUB_ENV
+          echo "GIT_COMMIT_SHA=$GITHUB_SHA" >> $GITHUB_ENV
+      if: github.event_name == 'push'
+
+    - name: Prepare CodeClimate
+      env:
+        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      run: |
+        curl -LSs 'https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64' >./cc-test-reporter;
+        chmod +x ./cc-test-reporter
+        ./cc-test-reporter before-build
+
+    - name: Run Tests
+      env:
+        PG_DATABASE: postgres
+        PG_HOST: localhost
+        PG_USER: postgres
+        PG_PASSWORD: password
+        PG_PORT: ${{ job.services.postgres.ports[5432] }}
+        RAILS_ENV: test
+        COVERAGE: true
+        DISABLE_SPRING: 1
+      run: |
+        cp config/application.yml.sample config/application.yml
+        cp config/database_travis.yml config/database.yml
+        echo "openssl_config_path: 'test/fixtures/files/test_ca/openssl.cnf'" >> config/application.yml
+        echo "crl_dir:      'test/fixtures/files/test_ca/crl'" >> config/application.yml
+        echo "crl_path:     'test/fixtures/files/test_ca/crl/crl.pem'" >> config/application.yml
+        echo "ca_cert_path: 'test/fixtures/files/test_ca/certs/ca.crt.pem'" >> config/application.yml
+        echo "ca_key_path:  'test/fixtures/files/test_ca/private/ca.key.pem'" >> config/application.yml
+        echo "ca_key_password: 'password'" >> config/application.yml
+        bundle exec rake db:setup:all
+        bundle exec rails test test/*
+    - name: Save coverage
+      run: ./cc-test-reporter format-coverage --output coverage/codeclimate.${{ matrix.ruby }}.json
+
+    - uses: actions/upload-artifact@v1
+      with:
+        name: coverage-${{ matrix.ruby }}
+        path: coverage/codeclimate.${{ matrix.ruby }}.json
+
+  upload_coverage:
+    runs-on: ubuntu-18.04
+
+    env:
+      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      CC_TEST_REPORTER_URL: https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64
+
+    needs: test
+
+    steps:
+      - name: Download test coverage reporter
+        run: curl -L $CC_TEST_REPORTER_URL > cc-test-reporter
+
+      - name: Give test coverage reporter executable permissions
+        run: chmod +x cc-test-reporter
+
+      - uses: actions/download-artifact@v1
+        with:
+          name: coverage-2.6
+          path: coverage
+
+      - uses: actions/download-artifact@v1
+        with:
+          name: coverage-2.7
+          path: coverage
+
+      - name: Aggregate & upload results to Code Climate
+        run: |
+          ./cc-test-reporter sum-coverage coverage/codeclimate.*.json
+          ./cc-test-reporter upload-coverage
+
--- a/.travis.yml
+++ b/.travis.yml
@ -1,35 +0,0 @@
-language: ruby
-cache: bundler
-env:
-  - DB=postgresql
-before_install:
-  - "wget -N http://chromedriver.storage.googleapis.com/2.43/chromedriver_linux64.zip -P ~/"
-  - "unzip ~/chromedriver_linux64.zip -d ~/"
-  - "rm ~/chromedriver_linux64.zip"
-  - "sudo mv -f ~/chromedriver /usr/local/share/"
-  - "sudo chmod +x /usr/local/share/chromedriver"
-  - "sudo ln -s /usr/local/share/chromedriver /usr/local/bin/chromedriver"
-  - "bundle config set without 'development staging production'"
-  - "bundle config set deployment '[secure]'"
-before_script:
-  - "cp config/application.yml.sample config/application.yml"
-  - "echo \"openssl_config_path: 'test/fixtures/files/test_ca/openssl.cnf'\" >> config/application.yml"
-  - "echo \"crl_dir:      'test/fixtures/files/test_ca/crl'\" >> config/application.yml"
-  - "echo \"crl_path:     'test/fixtures/files/test_ca/crl/crl.pem'\" >> config/application.yml"
-  - "echo \"ca_cert_path: 'test/fixtures/files/test_ca/certs/ca.crt.pem'\" >> config/application.yml"
-  - "echo \"ca_key_path:  'test/fixtures/files/test_ca/private/ca.key.pem'\" >> config/application.yml"
-  - "echo \"ca_key_password: 'password'\" >> config/application.yml"
-  - "cp config/database_travis.yml config/database.yml"
-  - "bundle exec rake db:setup:all"
-  - "curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter"
-  - "chmod +x ./cc-test-reporter"
-  - "./cc-test-reporter before-build"
-after_script:
-  - "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
-script:
-  - "bundle exec rails test test/*"
-services:
-  - postgresql
-addons:
-  postgresql: "9.4"
-  chrome: stable
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,3 +1,54 @@
+23.12.2020
+* fix for REPP logging and registrar portal communication [#1782](https://github.com/internetee/registry/pull/1782)
+
+22.12.2020
+* SSL CA verification fix for Bulk renew [#1778](https://github.com/internetee/registry/pull/1778)
+
+21.12.2020
+* Bulk renew for REPP and registrar [#1763](https://github.com/internetee/registry/issues/1763)
+
+17.12.2020
+* New API for registering bounced emails [#1687](https://github.com/internetee/registry/pull/1687)
+
+16.12.2020
+* Refactored domain delete confirmation for interactors [#1769](https://github.com/internetee/registry/issues/1769)
+
+15.12.2020
+* Improved logic for domain list request in registrant API [#1750](https://github.com/internetee/registry/pull/1750)
+* Refactored Whois update job for interactors [#1771](https://github.com/internetee/registry/issues/1771)
+
+14.12.2020
+* Refactored domain cron jobs for interactors [#1767](https://github.com/internetee/registry/issues/1767)
+
+09.12.2020
+* Refactored domain update confirm for interactors [#1760](https://github.com/internetee/registry/issues/1760)
+
+08.12.2020
+* Replaced Travis-CI with GitHub Actions [#1746](https://github.com/internetee/registry/pull/1746)
+* Refactored domain delete for interactors [#1755](https://github.com/internetee/registry/issues/1755)
+
+01.12.2020
+* Refactored clientHold for interactors [#1751](https://github.com/internetee/registry/issues/1751)
+* Fixed internal error on removing clientHold status when not present [#1766](https://github.com/internetee/registry/issues/1766)
+
+30.11.2020
+* Refactor - interactors moved to domain space [#1762](https://github.com/internetee/registry/pull/1762)
+
+27.11.2020
+* Refactored delete confirmation for interactors [#1753](https://github.com/internetee/registry/issues/1753)
+
+24.11.2020
+* Added subnet support for list of allowed IPs [#983](https://github.com/internetee/registry/issues/983)
+* Added contact endpoint to Restful EPP API [#1580](https://github.com/internetee/registry/issues/1580)
+
+20.11.2020
+* Registrant confirmation over Registrant API [#1742](https://github.com/internetee/registry/pull/1742)
+* Refactored forceDelete cancellation for interactors [#1743](https://github.com/internetee/registry/issues/1743)
+
+19.11.2020
+* Only sponsoring registrar has access to private contact's details [#1745](https://github.com/internetee/registry/issues/1745)
+* Refactor ForceDelete [#1740](https://github.com/internetee/registry/issues/1740)
+
 13.11.2020
 * Fixed per registrar epp session limit [#729](https://github.com/internetee/registry/issues/729)
 * Correct error code is returned on reaching session limit [#587](https://github.com/internetee/registry/issues/587)
--- a/9
+++ b/9
@ -1,6 +1,7 @@
 source 'https://rubygems.org'

 # core
+gem 'active_interaction', '~> 3.8'
 gem 'bootsnap', '>= 1.1.0', require: false
 gem 'iso8601', '0.12.1' # for dates and times
 gem 'rails', '~> 6.0'
@ -35,8 +36,6 @@ gem 'select2-rails',    '3.5.9.3' # for autocomplete
 gem 'cancancan'
 gem 'devise', '~> 4.7'

-gem 'grape'
-
 # registry specfic
 gem 'data_migrate', '~> 6.1'
 gem 'isikukood' # for EE-id validation
@ -74,15 +73,11 @@ gem 'e_invoice', github: 'internetee/e_invoice', branch: :master
 gem 'lhv', github: 'internetee/lhv', branch: 'master'
 gem 'domain_name'
 gem 'haml', '~> 5.0'
+gem 'rexml'
 gem 'wkhtmltopdf-binary', '~> 0.12.5.1'

 gem 'directo', github: 'internetee/directo', branch: 'master'

-group :development do
-  # deploy
-  gem 'listen', '3.2.1'
-  gem 'mina', '0.3.1' # for fast deployment
-end

 group :development, :test do
  gem 'pry', '0.10.1'
--- a/Gemfile.lock
+++ b/Gemfile.lock
@ -112,6 +112,8 @@ GEM
      erubi (~> 1.4)
      rails-dom-testing (~> 2.0)
      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    active_interaction (3.8.3)
+      activemodel (>= 4, < 7)
    activejob (6.0.3.3)
      activesupport (= 6.0.3.3)
      globalid (>= 0.3.6)
@ -196,28 +198,6 @@ GEM
    docile (1.3.2)
    domain_name (0.5.20190701)
      unf (>= 0.0.5, < 1.0.0)
-    dry-configurable (0.11.6)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.7)
-      dry-equalizer (~> 0.2)
-    dry-container (0.7.2)
-      concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.1, >= 0.1.3)
-    dry-core (0.4.9)
-      concurrent-ruby (~> 1.0)
-    dry-equalizer (0.3.0)
-    dry-inflector (0.2.0)
-    dry-logic (1.0.7)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.2)
-      dry-equalizer (~> 0.2)
-    dry-types (1.4.0)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.3)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer (~> 0.3)
-      dry-inflector (~> 0.1, >= 0.1.2)
-      dry-logic (~> 1.0, >= 1.0.2)
    erubi (1.9.0)
    erubis (2.7.0)
    execjs (2.7.0)
@ -226,13 +206,6 @@ GEM
      thor (~> 0.14)
    globalid (0.4.2)
      activesupport (>= 4.2.0)
-    grape (1.4.0)
-      activesupport
-      builder
-      dry-types (>= 1.1)
-      mustermann-grape (~> 1.0.0)
-      rack (>= 1.3.0)
-      rack-accept
    gyoku (1.3.1)
      builder (>= 2.1.2)
    haml (5.1.2)
@ -277,9 +250,6 @@ GEM
      kaminari-core (= 1.2.1)
    kaminari-core (1.2.1)
    libxml-ruby (3.2.0)
-    listen (3.2.1)
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
    logger (1.4.2)
    loofah (2.7.0)
      crass (~> 1.0.2)
@ -293,9 +263,6 @@ GEM
      mime-types-data (~> 3.2015)
    mime-types-data (3.2020.0512)
    mimemagic (0.3.5)
-    mina (0.3.1)
-      open4 (~> 1.3.4)
-      rake
    mini_mime (1.0.2)
    mini_portile2 (2.4.0)
    minitest (5.14.2)
@ -312,8 +279,6 @@ GEM
    multi_json (1.15.0)
    mustermann (1.1.1)
      ruby2_keywords (~> 0.0.1)
-    mustermann-grape (1.0.1)
-      mustermann (>= 1.0.0)
    netrc (0.11.0)
    nio4r (2.5.4)
    nokogiri (1.10.10)
@ -325,7 +290,6 @@ GEM
    omniauth-rails_csrf_protection (0.1.2)
      actionpack (>= 4.2)
      omniauth (>= 1.3.1)
-    open4 (1.3.4)
    openid_connect (1.2.0)
      activemodel
      attr_required (>= 1.0.0)
@ -357,8 +321,6 @@ GEM
      que (~> 0.8)
      sinatra
    rack (2.2.3)
-    rack-accept (0.4.5)
-      rack (>= 0.4)
    rack-oauth2 (1.16.0)
      activesupport
      attr_required
@ -401,9 +363,6 @@ GEM
      activesupport (>= 5.2.1)
      i18n
      polyamorous (= 2.3.2)
-    rb-fsevent (0.10.4)
-    rb-inotify (0.10.1)
-      ffi (~> 1.0)
    rbtree3 (0.6.0)
    regexp_parser (1.8.0)
    request_store (1.5.0)
@ -416,6 +375,7 @@ GEM
      http-cookie (>= 1.0.2, < 2.0)
      mime-types (>= 1.16, < 4.0)
      netrc (~> 0.8)
+    rexml (3.2.4)
    ruby2_keywords (0.0.2)
    rubyzip (2.3.0)
    sass-rails (6.0.0)
@ -521,6 +481,7 @@ PLATFORMS
  ruby

 DEPENDENCIES
+  active_interaction (~> 3.8)
  activerecord-import
  airbrake
  bootsnap (>= 1.1.0)
@ -542,7 +503,6 @@ DEPENDENCIES
  epp!
  epp-xml (= 1.1.0)!
  figaro (= 1.1.1)
-  grape
  haml (~> 5.0)
  isikukood
  iso8601 (= 0.12.1)
@ -550,8 +510,6 @@ DEPENDENCIES
  jquery-ui-rails (= 5.0.5)
  kaminari
  lhv!
-  listen (= 3.2.1)
-  mina (= 0.3.1)
  minitest (~> 5.14)
  money-rails
  nokogiri
@ -568,6 +526,7 @@ DEPENDENCIES
  rails (~> 6.0)
  ransack (~> 2.3)
  rest-client
+  rexml
  sass-rails
  select2-rails (= 3.5.9.3)
  selectize-rails (= 0.12.1)
--- a/app/api/repp/account_v1.rb
+++ b/app/api/repp/account_v1.rb
@ -1,16 +0,0 @@
-module Repp
-  class AccountV1 < Grape::API
-    version 'v1', using: :path
-
-    resource :accounts do
-      desc 'Return current cash account balance'
-
-      get 'balance' do
-        @response = {
-          balance: current_user.registrar.cash_account.balance,
-          currency: current_user.registrar.cash_account.currency
-        }
-      end
-    end
-  end
-end
--- a/app/api/repp/api.rb
+++ b/app/api/repp/api.rb
@ -1,65 +0,0 @@
-module Repp
-  class API < Grape::API
-    format :json
-    prefix :repp
-
-    http_basic do |username, password|
-      @current_user ||= ApiUser.find_by(username: username, plain_text_password: password)
-      if @current_user
-        true
-      else
-        error! I18n.t('api_user_not_found'), 401
-      end
-    end
-
-    before do
-      webclient_request = ENV['webclient_ips'].split(',').map(&:strip).include?(request.ip)
-      unless webclient_request
-        error! I18n.t('api.authorization.ip_not_allowed', ip: request.ip), 401 unless @current_user.registrar.api_ip_white?(request.ip)
-      end
-
-      if @current_user.cannot?(:view, :repp)
-        error! I18n.t('no_permission'), 401 unless @current_user.registrar.api_ip_white?(request.ip)
-      end
-
-      next if Rails.env.test? || Rails.env.development?
-      message = 'Certificate mismatch! Cert common name should be:'
-      request_name = env['HTTP_SSL_CLIENT_S_DN_CN']
-
-      if webclient_request
-        webclient_cert_name = ENV['webclient_cert_common_name'] || 'webclient'
-        error! "Webclient #{message} #{webclient_cert_name}", 401 if webclient_cert_name != request_name
-      else
-        unless @current_user.pki_ok?(request.env['HTTP_SSL_CLIENT_CERT'],
-                                     request.env['HTTP_SSL_CLIENT_S_DN_CN'])
-          error! "#{message} #{@current_user.username}", 401
-        end
-      end
-    end
-
-    helpers do
-      attr_reader :current_user
-    end
-
-    after do
-      ApiLog::ReppLog.create({
-        request_path: request.path,
-        request_method: request.request_method,
-        request_params: request.params.except('route_info').to_json,
-        response: @response.to_json,
-        response_code: status,
-        api_user_name: current_user.try(:username),
-        api_user_registrar: current_user.try(:registrar).try(:to_s),
-        ip: request.ip,
-        uuid: request.try(:uuid)
-      })
-    end
-
-    mount Repp::DomainV1
-    mount Repp::ContactV1
-    mount Repp::AccountV1
-    mount Repp::DomainTransfersV1
-    mount Repp::NameserversV1
-    mount Repp::DomainContactsV1
-  end
-end
--- a/app/api/repp/contact_v1.rb
+++ b/app/api/repp/contact_v1.rb
@ -1,35 +0,0 @@
-module Repp
-  class ContactV1 < Grape::API
-    version 'v1', using: :path
-
-    resource :contacts do
-      desc 'Return list of contact'
-      params do
-        optional :limit, type: Integer, values: (1..200).to_a, desc: 'How many contacts to show'
-        optional :offset, type: Integer, desc: 'Contact number to start at'
-        optional :details, type: String, values: %w(true false), desc: 'Whether to include details'
-      end
-
-      get '/' do
-        limit = params[:limit] || 200
-        offset = params[:offset] || 0
-
-        if params[:details] == 'true'
-          contacts = current_user.registrar.contacts.limit(limit).offset(offset)
-
-          unless Contact.address_processing?
-            attributes = Contact.attribute_names - Contact.address_attribute_names
-            contacts = contacts.select(attributes)
-          end
-        else
-          contacts = current_user.registrar.contacts.limit(limit).offset(offset).pluck(:code)
-        end
-
-        @response = {
-          contacts: contacts,
-          total_number_of_records: current_user.registrar.contacts.count
-        }
-      end
-    end
-  end
-end
--- a/app/api/repp/domain_contacts_v1.rb
+++ b/app/api/repp/domain_contacts_v1.rb
@ -1,47 +0,0 @@
-module Repp
-  class DomainContactsV1 < Grape::API
-    version 'v1', using: :path
-
-    resource :domains do
-      resource :contacts do
-        patch '/' do
-          current_contact = current_user.registrar.contacts
-                                .find_by(code: params[:current_contact_id])
-          new_contact = current_user.registrar.contacts.find_by(code: params[:new_contact_id])
-
-          unless current_contact
-            error!({ error: { type: 'invalid_request_error',
-                              param: 'current_contact_id',
-                              message: "No such contact: #{params[:current_contact_id]}"} },
-                   :bad_request)
-          end
-
-          unless new_contact
-            error!({ error: { type: 'invalid_request_error',
-                              param: 'new_contact_id',
-                              message: "No such contact: #{params[:new_contact_id]}" } },
-                   :bad_request)
-          end
-
-          if new_contact.invalid?
-            error!({ error: { type: 'invalid_request_error',
-                              param: 'new_contact_id',
-                              message: 'New contact must be valid' } },
-                   :bad_request)
-          end
-
-          if current_contact == new_contact
-            error!({ error: { type: 'invalid_request_error',
-                              message: 'New contact ID must be different from current' \
-                                ' contact ID' } },
-                   :bad_request)
-          end
-
-          affected_domains, skipped_domains = TechDomainContact
-                                                  .replace(current_contact, new_contact)
-          @response = { affected_domains: affected_domains, skipped_domains: skipped_domains }
-        end
-      end
-    end
-  end
-end
--- a/app/api/repp/domain_transfers_v1.rb
+++ b/app/api/repp/domain_transfers_v1.rb
@ -1,48 +0,0 @@
-module Repp
-  class DomainTransfersV1 < Grape::API
-    version 'v1', using: :path
-
-    resource :domain_transfers do
-      post '/' do
-        params do
-          requires :data, type: Hash do
-            requires :domainTransfers, type: Array do
-              requires :domainName, type: String, allow_blank: false
-              requires :transferCode, type: String, allow_blank: false
-            end
-          end
-        end
-
-        new_registrar = current_user.registrar
-        domain_transfers = params['data']['domainTransfers']
-        successful_domain_transfers = []
-        errors = []
-
-        domain_transfers.each do |domain_transfer|
-          domain_name = domain_transfer['domainName']
-          transfer_code = domain_transfer['transferCode']
-          domain = Domain.find_by(name: domain_name)
-
-          if domain
-            if domain.transfer_code == transfer_code
-              DomainTransfer.request(domain, new_registrar)
-              successful_domain_transfers << { type: 'domain_transfer', attributes: { domain_name: domain.name } }
-            else
-              errors << { title: "#{domain_name} transfer code is wrong" }
-            end
-          else
-            errors << { title: "#{domain_name} does not exist" }
-          end
-        end
-
-        if errors.none?
-          status 200
-          @response = { data: successful_domain_transfers }
-        else
-          status 400
-          @response = { errors: errors }
-        end
-      end
-    end
-  end
-end
--- a/app/api/repp/domain_v1.rb
+++ b/app/api/repp/domain_v1.rb
@ -1,50 +0,0 @@
-module Repp
-  class DomainV1 < Grape::API
-    version 'v1', using: :path
-
-    resource :domains do
-      desc 'Return list of domains'
-      params do
-        optional :limit, type: Integer, values: (1..200).to_a, desc: 'How many domains to show'
-        optional :offset, type: Integer, desc: 'Domain number to start at'
-        optional :details, type: String, values: %w(true false), desc: 'Whether to include details'
-      end
-
-      get '/' do
-        limit = params[:limit] || 200
-        offset = params[:offset] || 0
-
-        if params[:details] == 'true'
-          domains = current_user.registrar.domains.limit(limit).offset(offset)
-        else
-          domains = current_user.registrar.domains.limit(limit).offset(offset).pluck(:name)
-        end
-
-        @response = {
-          domains: domains,
-          total_number_of_records: current_user.registrar.domains.count
-        }
-      end
-
-      # example: curl -u registrar1:password localhost:3000/repp/v1/domains/1/transfer_info -H "Auth-Code: authinfopw1"
-      get '/:id/transfer_info', requirements: { id: /.*/ } do
-        ident = params[:id]
-        domain = ident.match?(/\A[0-9]+\z/) ? Domain.find_by(id: ident) : Domain.find_by_idn(ident)
-
-        error! I18n.t('errors.messages.epp_domain_not_found'), 404 unless domain
-        error! I18n.t('errors.messages.epp_authorization_error'), 401 unless domain.transfer_code.eql? request.headers['Auth-Code']
-
-        contact_repp_json = proc{|contact|
-          contact.as_json.slice("code", "name", "ident", "ident_type", "ident_country_code", "phone", "email", "street", "city", "zip","country_code", "statuses")
-        }
-
-        @response = {
-          domain: domain.name,
-          registrant: contact_repp_json.call(domain.registrant),
-          admin_contacts: domain.admin_contacts.map{|e| contact_repp_json.call(e)},
-          tech_contacts: domain.tech_contacts.map{|e| contact_repp_json.call(e)}
-        }
-      end
-    end
-  end
-end
--- a/app/api/repp/nameservers_v1.rb
+++ b/app/api/repp/nameservers_v1.rb
@ -1,49 +0,0 @@
-module Repp
-  class NameserversV1 < Grape::API
-    version 'v1', using: :path
-
-    resource 'registrar/nameservers' do
-      put '/' do
-        params do
-          requires :data, type: Hash, allow_blank: false do
-            requires :type, type: String, allow_blank: false
-            requires :id, type: String, allow_blank: false
-            optional :domains, type: Array
-            requires :attributes, type: Hash, allow_blank: false do
-              requires :hostname, type: String, allow_blank: false
-              requires :ipv4, type: Array
-              requires :ipv6, type: Array
-            end
-          end
-        end
-
-        hostname = params[:data][:id]
-
-        unless current_user.registrar.nameservers.exists?(hostname: hostname)
-          error!({ errors: [{ title: "Hostname #{hostname} does not exist" }] }, 404)
-        end
-
-        new_attributes = {
-          hostname: params[:data][:attributes][:hostname],
-          ipv4: params[:data][:attributes][:ipv4],
-          ipv6: params[:data][:attributes][:ipv6],
-        }
-
-        domains = params[:data][:domains].map(&:downcase) || []
-
-        begin
-          affected_domains = current_user.registrar.replace_nameservers(hostname, new_attributes,
-                                                                        domains: domains)
-        rescue ActiveRecord::RecordInvalid => e
-          error!({ errors: e.record.errors.full_messages.map { |error| { title: error } } }, 400)
-        end
-
-        status 200
-        @response = { data: { type: 'nameserver',
-                              id: params[:data][:attributes][:hostname],
-                              attributes: params[:data][:attributes] },
-                      affected_domains: affected_domains }
-      end
-    end
-  end
-end
--- a/app/controllers/admin/bounced_mail_addresses_controller.rb
+++ b/app/controllers/admin/bounced_mail_addresses_controller.rb
@ -0,0 +1,30 @@
+module Admin
+  class BouncedMailAddressesController < BaseController
+    before_action :set_bounced_mail_address, only: %i[show destroy]
+    load_and_authorize_resource
+
+    # GET /bounced_mail_addresses
+    def index
+      @bounced_mail_addresses = BouncedMailAddress.all.order(created_at: :desc)
+    end
+
+    # GET /bounced_mail_addresses/1
+    def show; end
+
+    # DELETE /bounced_mail_addresses/1
+    def destroy
+      @bounced_mail_address.destroy
+      redirect_to(
+        admin_bounced_mail_addresses_url,
+        notice: 'Bounced mail address was successfully destroyed.'
+      )
+    end
+
+    private
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_bounced_mail_address
+      @bounced_mail_address = BouncedMailAddress.find(params[:id])
+    end
+  end
+end
--- a/app/controllers/admin/domains/force_delete_controller.rb
+++ b/app/controllers/admin/domains/force_delete_controller.rb
@ -4,26 +4,15 @@ module Admin
      def create
        authorize! :manage, domain

+        notice = t('.scheduled')
+
        domain.transaction do
-          domain.schedule_force_delete(type: force_delete_type)
-          domain.registrar.notifications.create!(text: t('force_delete_set_on_domain',
-                                                         domain_name: domain.name,
-                                                         outzone_date: domain.outzone_date,
-                                                         purge_date: domain.purge_date))
-
-          notify_by_email if notify_by_email?
+          result = domain.schedule_force_delete(type: force_delete_type,
+                                                notify_by_email: notify_by_email?)
+          notice = result.errors.messages[:domain].first unless result.valid?
        end

-        redirect_to edit_admin_domain_url(domain), notice: t('.scheduled')
-      end
-
-      def notify_by_email
-        if force_delete_type == :fast_track
-          send_email
-          domain.update(contact_notification_sent_date: Time.zone.today)
-        else
-          domain.update(template_name: domain.notification_template)
-        end
+        redirect_to edit_admin_domain_url(domain), notice: notice
      end

      def destroy
@ -42,13 +31,6 @@ module Admin
        ActiveRecord::Type::Boolean.new.cast(params[:notify_by_email])
      end

-      def send_email
-        DomainDeleteMailer.forced(domain: domain,
-                                  registrar: domain.registrar,
-                                  registrant: domain.registrant,
-                                  template_name: domain.notification_template).deliver_now
-      end
-
      def force_delete_type
        soft_delete? ? :soft : :fast_track
      end
--- a/app/controllers/api/v1/base_controller.rb
+++ b/app/controllers/api/v1/base_controller.rb
@ -10,6 +10,11 @@ module Api
        head :unauthorized unless ip_allowed
      end

+      def authenticate_shared_key
+        api_key = "Basic #{ENV['api_shared_key']}"
+        head(:unauthorized) unless api_key == request.authorization
+      end
+
      def not_found_error
        uuid = params['uuid']
        json = { error: 'Not Found', uuid: uuid, message: 'Record not found' }
--- a/app/controllers/api/v1/bounces_controller.rb
+++ b/app/controllers/api/v1/bounces_controller.rb
@ -0,0 +1,25 @@
+module Api
+  module V1
+    class BouncesController < BaseController
+      before_action :authenticate_shared_key
+
+      # POST api/v1/bounces/
+      def create
+        return head(:bad_request) unless bounce_params[:bounce][:bouncedRecipients].any?
+
+        BouncedMailAddress.record(bounce_params)
+        head(:created)
+      rescue ActionController::ParameterMissing
+        head(:bad_request)
+      end
+
+      def bounce_params
+        params.require(:data).require(:bounce).require(:bouncedRecipients).each do |r|
+          r.require(:emailAddress)
+        end
+
+        params.require(:data)
+      end
+    end
+  end
+end
--- a/app/controllers/api/v1/registrant/confirms_controller.rb
+++ b/app/controllers/api/v1/registrant/confirms_controller.rb
@ -0,0 +1,119 @@
+require 'serializers/registrant_api/domain'
+
+module Api
+  module V1
+    module Registrant
+      class ConfirmsController < ::Api::V1::Registrant::BaseController
+        skip_before_action :authenticate, :set_paper_trail_whodunnit
+        before_action :set_domain, only: %i[index update]
+        before_action :verify_action, only: %i[index update]
+        before_action :verify_decision, only: %i[update]
+
+        def index
+          res = {
+            domain_name: @domain.name,
+            current_registrant: serialized_registrant(@domain.registrant),
+          }
+
+          unless delete_action?
+            res[:new_registrant] = serialized_registrant(@domain.pending_registrant)
+          end
+
+          render json: res, status: :ok
+        end
+
+        def update
+          verification = RegistrantVerification.new(domain_id: @domain.id,
+                                                    verification_token: verify_params[:token])
+
+          unless delete_action? ? delete_action(verification) : change_action(verification)
+            head :bad_request
+            return
+          end
+
+          render json: { domain_name: @domain.name,
+                         current_registrant: serialized_registrant(current_registrant),
+                         status: params[:decision] }, status: :ok
+        end
+
+        private
+
+        def initiator
+          "email link, #{I18n.t(:user_not_authenticated)}"
+        end
+
+        def current_registrant
+          confirmed? && !delete_action? ? @domain.pending_registrant : @domain.registrant
+        end
+
+        def confirmed?
+          verify_params[:decision] == 'confirmed'
+        end
+
+        def change_action(verification)
+          if confirmed?
+            verification.domain_registrant_change_confirm!(initiator)
+          else
+            verification.domain_registrant_change_reject!(initiator)
+          end
+        end
+
+        def delete_action(verification)
+          if confirmed?
+            verification.domain_registrant_delete_confirm!(initiator)
+          else
+            verification.domain_registrant_delete_reject!(initiator)
+          end
+        end
+
+        def serialized_registrant(registrant)
+          {
+            name: registrant.try(:name),
+            ident: registrant.try(:ident),
+            country: registrant.try(:ident_country_code),
+          }
+        end
+
+        def verify_params
+          params do |p|
+            p.require(:name)
+            p.require(:token)
+            p.permit(:decision)
+          end
+        end
+
+        def delete_action?
+          return true if params[:template] == 'delete'
+
+          false
+        end
+
+        def verify_decision
+          return if %w[confirmed rejected].include?(params[:decision])
+
+          head :not_found
+        end
+
+        def set_domain
+          @domain = Domain.find_by(name: verify_params[:name])
+          @domain ||= Domain.find_by(name_puny: verify_params[:name])
+          return if @domain
+
+          render json: { error: 'Domain not found' }, status: :not_found
+        end
+
+        def verify_action
+          action = if params[:template] == 'change'
+                     @domain.registrant_update_confirmable?(verify_params[:token])
+                   elsif params[:template] == 'delete'
+                     @domain.registrant_delete_confirmable?(verify_params[:token])
+                   end
+
+          return if action
+
+          render json: { error: 'Application expired or not found' }, status: :unauthorized
+        end
+      end
+    end
+  end
+end
--- a/app/controllers/api/v1/registrant/contacts_controller.rb
+++ b/app/controllers/api/v1/registrant/contacts_controller.rb
@ -19,15 +19,16 @@ module Api
          end

          contacts = current_user_contacts.limit(limit).offset(offset)
-          serialized_contacts = contacts.collect { |contact| serialize_contact(contact) }
+          serialized_contacts = contacts.collect { |contact| serialize_contact(contact, false) }
          render json: serialized_contacts
        end

        def show
          contact = current_user_contacts.find_by(uuid: params[:uuid])
+          links = params[:links] == 'true'

          if contact
-            render json: serialize_contact(contact)
+            render json: serialize_contact(contact, links)
          else
            render json: { errors: [{ base: ['Contact not found'] }] }, status: :not_found
          end
@ -85,7 +86,7 @@ module Api
            contact.registrar.notify(action)
          end

-          render json: serialize_contact(contact)
+          render json: serialize_contact(contact, false)
        end

        private
@ -96,8 +97,8 @@ module Api
          current_registrant_user.direct_contacts
        end

-        def serialize_contact(contact)
-          Serializers::RegistrantApi::Contact.new(contact).to_json
+        def serialize_contact(contact, links)
+          Serializers::RegistrantApi::Contact.new(contact, links).to_json
        end
      end
    end
--- a/app/controllers/api/v1/registrant/domains_controller.rb
+++ b/app/controllers/api/v1/registrant/domains_controller.rb
@ -7,6 +7,7 @@ module Api
        def index
          limit = params[:limit] || 200
          offset = params[:offset] || 0
+          simple = params[:simple] == 'true' || false

          if limit.to_i > 200 || limit.to_i < 1
            render(json: { errors: [{ limit: ['parameter is out of range'] }] },
@ -18,21 +19,20 @@ module Api
                   status: :bad_request) && return
          end

-          @domains = current_user_domains.limit(limit).offset(offset)
-
-          serialized_domains = @domains.map do |item|
-            serializer = Serializers::RegistrantApi::Domain.new(item)
+          domains = current_user_domains
+          serialized_domains = domains.limit(limit).offset(offset).map do |item|
+            serializer = Serializers::RegistrantApi::Domain.new(item, simplify: simple)
            serializer.to_json
          end

-          render json: serialized_domains
+          render json: { count: domains.count, domains: serialized_domains }
        end

        def show
          @domain = current_user_domains.find_by(uuid: params[:uuid])

          if @domain
-            serializer = Serializers::RegistrantApi::Domain.new(@domain)
+            serializer = Serializers::RegistrantApi::Domain.new(@domain, simplify: false)
            render json: serializer.to_json
          else
            render json: { errors: [{ base: ['Domain not found'] }] }, status: :not_found
--- a/app/controllers/epp/contacts_controller.rb
+++ b/app/controllers/epp/contacts_controller.rb
@ -1,10 +1,9 @@
 require 'deserializers/xml/contact_update'
-
+require 'deserializers/xml/contact_create'
 module Epp
  class ContactsController < BaseController
    before_action :find_contact, only: [:info, :update, :delete]
    before_action :find_password, only: [:info, :update, :delete]
-    helper_method :address_processing?

    def info
      authorize! :info, @contact, @password
@ -21,25 +20,13 @@ module Epp

    def create
      authorize! :create, Epp::Contact
-      frame = params[:parsed_frame]
-      @contact = Epp::Contact.new(frame, current_user.registrar)

-      @contact.add_legal_file_to_new(frame)
-      @contact.generate_code
+      @contact = Epp::Contact.new(params[:parsed_frame], current_user.registrar)
+      collected_data = ::Deserializers::Xml::ContactCreate.new(params[:parsed_frame])
+      action = Actions::ContactCreate.new(@contact, collected_data.legal_document,
+                                          collected_data.ident)

-      if @contact.save
-        if !address_processing? && address_given?
-          @response_code = 1100
-          @response_description = t('epp.contacts.completed_without_address')
-        else
-          @response_code = 1000
-          @response_description = t('epp.contacts.completed')
-        end
-
-        render_epp_response '/epp/contacts/save'
-      else
-        handle_errors(@contact)
-      end
+      action_call_response(action: action)
    end

    def update
@ -52,29 +39,18 @@ module Epp
                                          collected_data.ident,
                                          current_user)

-      if action.call
-        if !address_processing? && address_given?
-          @response_code = 1100
-          @response_description = t('epp.contacts.completed_without_address')
-        else
-          @response_code = 1000
-          @response_description = t('epp.contacts.completed')
-        end
-
-        render_epp_response 'epp/contacts/save'
-      else
-        handle_errors(@contact)
-      end
+      action_call_response(action: action)
    end

    def delete
      authorize! :delete, @contact, @password
-
-      if @contact.destroy_and_clean(params[:parsed_frame])
-        render_epp_response '/epp/contacts/delete'
-      else
+      action = Actions::ContactDelete.new(@contact, params[:legal_document])
+      unless action.call
        handle_errors(@contact)
+        return
      end
+
+      render_epp_response '/epp/contacts/delete'
    end

    def renew
@ -91,6 +67,26 @@ module Epp

    private

+    def opt_addr?
+      !Contact.address_processing? && address_given?
+    end
+
+    def action_call_response(action:)
+      # rubocop:disable Style/AndOr
+      (handle_errors(@contact) and return) unless action.call
+      # rubocop:enable Style/AndOr
+
+      if opt_addr?
+        @response_code = 1100
+        @response_description = t('epp.contacts.completed_without_address')
+      else
+        @response_code = 1000
+        @response_description = t('epp.contacts.completed')
+      end
+
+      render_epp_response('epp/contacts/save')
+    end
+
    def find_password
      @password = params[:parsed_frame].css('authInfo pw').text
    end
@ -129,8 +125,7 @@ module Epp
        'postalInfo > addr > cc',
      ]

-      required_attributes.concat(address_attributes) if address_processing?
-
+      required_attributes.concat(address_attributes) if Contact.address_processing?
      requires(*required_attributes)
      ident = params[:parsed_frame].css('ident')

@ -206,9 +201,5 @@ module Epp
    def address_given?
      params[:parsed_frame].css('postalInfo addr').size != 0
    end
-
-    def address_processing?
-      Contact.address_processing?
-    end
  end
 end
--- a/app/controllers/registrar/bulk_change_controller.rb
+++ b/app/controllers/registrar/bulk_change_controller.rb
@ -4,11 +4,38 @@ class Registrar

    def new
      authorize! :manage, :repp
+      @expire_date = Time.zone.now.to_date
      render file: 'registrar/bulk_change/new', locals: { active_tab: default_tab }
    end

+    def bulk_renew
+      authorize! :manage, :repp
+      set_form_data
+
+      if ready_to_renew?
+        res = ReppApi.bulk_renew(domain_ids_for_bulk_renew, params[:period],
+                                 current_registrar_user)
+
+        flash_message(JSON.parse(res))
+      else
+        flash[:notice] = nil
+      end
+
+      render file: 'registrar/bulk_change/new', locals: { active_tab: :bulk_renew }
+    end
+
    private

+    def ready_to_renew?
+      domain_ids_for_bulk_renew.present? && params[:renew].present?
+    end
+
+    def set_form_data
+      @expire_date = params[:expire_date].to_date
+      @domains = domains_by_date(@expire_date)
+      @period = params[:period]
+    end
+
    def available_contacts
      current_registrar_user.registrar.contacts.order(:name).pluck(:name, :code)
    end
@ -16,5 +43,27 @@ class Registrar
    def default_tab
      :technical_contact
    end
+
+    def domains_scope
+      current_registrar_user.registrar.domains
+    end
+
+    def domains_by_date(date)
+      domains_scope.where('valid_to <= ?', date)
+    end
+
+    def domain_ids_for_bulk_renew
+      params.dig('domain_ids')&.reject { |id| id.blank? }
+    end
+
+    def renew_task(domains)
+      Domains::BulkRenew::Start.run(domains: domains,
+                                    period_element: @period,
+                                    registrar: current_registrar_user.registrar)
+    end
+
+    def flash_message(res)
+      flash[:notice] = res['code'] == 1000 ? t(:bulk_renew_completed) : res['message']
+    end
  end
 end
--- a/app/controllers/registrar/domain_transfers_controller.rb
+++ b/app/controllers/registrar/domain_transfers_controller.rb
@ -15,12 +15,12 @@ class Registrar
        csv.each do |row|
          domain_name = row['Domain']
          transfer_code = row['Transfer code']
-          domain_transfers << { 'domainName' => domain_name, 'transferCode' => transfer_code }
+          domain_transfers << { 'domain_name' => domain_name, 'transfer_code' => transfer_code }
        end

-        uri = URI.parse("#{ENV['repp_url']}domain_transfers")
+        uri = URI.parse("#{ENV['repp_url']}domains/transfer")
        request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
-        request.body = { data: { domainTransfers: domain_transfers } }.to_json
+        request.body = { data: { domain_transfers: domain_transfers } }.to_json
        request.basic_auth(current_registrar_user.username,
                           current_registrar_user.plain_text_password)

@ -55,10 +55,12 @@ class Registrar
        parsed_response = JSON.parse(response.body, symbolize_names: true)

        if response.code == '200'
-          flash[:notice] = t '.transferred', count: parsed_response[:data].size
+          failed = parsed_response[:data][:failed].each(&:domain_name).join(', ')
+          flash[:notice] = t('.transferred', count: parsed_response[:data][:success].size,
+                                             failed: failed)
          redirect_to registrar_domains_url
        else
-          @api_errors = parsed_response[:errors]
+          @api_errors = parsed_response[:message]
          render file: 'registrar/bulk_change/new', locals: { active_tab: :bulk_transfer }
        end
      else
--- a/app/controllers/registrar/nameservers_controller.rb
+++ b/app/controllers/registrar/nameservers_controller.rb
@ -49,12 +49,13 @@ class Registrar

      if response.code == '200'
        notices = [t('.replaced')]
-        notices << "#{t('.affected_domains')}: #{parsed_response[:affected_domains].join(', ')}"
+        notices << "#{t('.affected_domains')}: " \
+                   "#{parsed_response[:data][:affected_domains].join(', ')}"

-        flash[:notice] = notices
+        flash[:notice] = notices.join(', ')
        redirect_to registrar_domains_url
      else
-        @api_errors = parsed_response[:errors]
+        @api_errors = parsed_response[:message]
        render file: 'registrar/bulk_change/new', locals: { active_tab: :nameserver }
      end
    end
--- a/app/controllers/registrar/sessions_controller.rb
+++ b/app/controllers/registrar/sessions_controller.rb
@ -62,6 +62,7 @@ class Registrar

    def find_user_by_idc_and_allowed(idc)
      return User.new unless idc
+
      possible_users = ApiUser.where(identity_code: idc) || User.new
      possible_users.each do |selected_user|
        if selected_user.registrar.white_ips.registrar_area.include_ip?(request.ip)
--- a/app/controllers/registrar/tech_contacts_controller.rb
+++ b/app/controllers/registrar/tech_contacts_controller.rb
@ -43,16 +43,18 @@ class Registrar
      if response.code == '200'
        notices = [t('.replaced')]

-        notices << "#{t('.affected_domains')}: #{parsed_response[:affected_domains].join(', ')}"
+        notices << "#{t('.affected_domains')}: " \
+                   "#{parsed_response[:data][:affected_domains].join(', ')}"

-        if parsed_response[:skipped_domains]
-          notices << "#{t('.skipped_domains')}: #{parsed_response[:skipped_domains].join(', ')}"
+        if parsed_response[:data][:skipped_domains]
+          notices << "#{t('.skipped_domains')}: " \
+                     "#{parsed_response[:data][:skipped_domains].join(', ')}"
        end

-        flash[:notice] = notices
+        flash[:notice] = notices.join(', ')
        redirect_to registrar_domains_url
      else
-        @error = parsed_response[:error]
+        @error = response.code == '404' ? 'Contact(s) not found' : parsed_response[:message]
        render file: 'registrar/bulk_change/new', locals: { active_tab: :technical_contact }
      end
    end
--- a/app/controllers/repp/v1/accounts_controller.rb
+++ b/app/controllers/repp/v1/accounts_controller.rb
@ -0,0 +1,11 @@
+module Repp
+  module V1
+    class AccountsController < BaseController
+      def balance
+        resp = { balance: current_user.registrar.cash_account.balance,
+                 currency: current_user.registrar.cash_account.currency }
+        render_success(data: resp)
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/auctions_controller.rb
+++ b/app/controllers/repp/v1/auctions_controller.rb
@ -3,9 +3,9 @@ module Repp
    class AuctionsController < ActionController::API
      def index
        auctions = Auction.started
+        @response = { count: auctions.count, auctions: auctions_to_json(auctions) }

-        render json: { count: auctions.count,
-                       auctions: auctions_to_json(auctions) }
+        render json: @response
      end

      private
--- a/app/controllers/repp/v1/base_controller.rb
+++ b/app/controllers/repp/v1/base_controller.rb
@ -0,0 +1,130 @@
+module Repp
+  module V1
+    class BaseController < ActionController::API
+      rescue_from ActiveRecord::RecordNotFound, with: :not_found_error
+      before_action :authenticate_user
+      before_action :validate_webclient_ca
+      before_action :check_ip_restriction
+      attr_reader :current_user
+
+      before_action :set_paper_trail_whodunnit
+
+      rescue_from ActionController::ParameterMissing do |exception|
+        render json: { code: 2003, message: exception }, status: :bad_request
+      end
+
+      after_action do
+        ApiLog::ReppLog.create(
+          request_path: request.path, request_method: request.request_method,
+          request_params: request.params.except('route_info').to_json, uuid: request.try(:uuid),
+          response: @response.to_json, response_code: status, ip: request.ip,
+          api_user_name: current_user.try(:username),
+          api_user_registrar: current_user.try(:registrar).try(:to_s)
+        )
+      end
+
+      private
+
+      def set_paper_trail_whodunnit
+        ::PaperTrail.request.whodunnit = current_user
+      end
+
+      def render_success(code: nil, message: nil, data: nil)
+        @response = { code: code || 1000, message: message || 'Command completed successfully',
+                      data: data || {} }
+
+        render(json: @response, status: :ok)
+      end
+
+      def epp_errors
+        @epp_errors ||= []
+      end
+
+      def handle_errors(obj = nil, update: false)
+        @epp_errors ||= []
+
+        obj&.construct_epp_errors
+        @epp_errors += obj.errors[:epp_errors] if obj
+
+        format_epp_errors if update
+        @epp_errors.uniq!
+
+        render_epp_error
+      end
+
+      def format_epp_errors
+        @epp_errors.each_with_index do |error, index|
+          blocked_by_delete_prohibited?(error, index)
+        end
+      end
+
+      def blocked_by_delete_prohibited?(error, index)
+        if error[:code] == 2304 && error[:value][:val] == DomainStatus::SERVER_DELETE_PROHIBITED &&
+           error[:value][:obj] == 'status'
+
+          @epp_errors[index][:value][:val] = DomainStatus::PENDING_UPDATE
+        end
+      end
+
+      def render_epp_error(status = :bad_request, data = {})
+        @epp_errors ||= []
+        @epp_errors << { code: 2304, msg: 'Command failed' } if data != {}
+
+        @response = { code: @epp_errors[0][:code].to_i, message: @epp_errors[0][:msg], data: data }
+        render(json: @response, status: status)
+      end
+
+      def basic_token
+        pattern = /^Basic /
+        header  = request.headers['Authorization']
+        header = header.gsub(pattern, '') if header&.match(pattern)
+        header.strip
+      end
+
+      def authenticate_user
+        username, password = Base64.urlsafe_decode64(basic_token).split(':')
+        @current_user ||= ApiUser.find_by(username: username, plain_text_password: password)
+
+        return if @current_user
+
+        raise(ArgumentError)
+      rescue NoMethodError, ArgumentError
+        @response = { code: 2202, message: 'Invalid authorization information' }
+        render(json: @response, status: :unauthorized)
+      end
+
+      def check_ip_restriction
+        return if webclient_request?
+        return if @current_user.registrar.api_ip_white?(request.ip)
+
+        @response = { code: 2202,
+                      message: I18n.t('registrar.authorization.ip_not_allowed', ip: request.ip) }
+        render(json: @response, status: :unauthorized)
+      end
+
+      def webclient_request?
+        return if Rails.env.test?
+
+        ENV['webclient_ips'].split(',').map(&:strip).include?(request.ip)
+      end
+
+      def validate_webclient_ca
+        return unless webclient_request?
+
+        request_name = request.env['HTTP_SSL_CLIENT_S_DN_CN']
+        webclient_cn = ENV['webclient_cert_common_name'] || 'webclient'
+        return if request_name == webclient_cn
+
+        @response = { code: 2202,
+                      message: I18n.t('registrar.authorization.ip_not_allowed', ip: request.ip) }
+
+        render(json: @response, status: :unauthorized)
+      end
+
+      def not_found_error
+        @response = { code: 2303, message: 'Object does not exist' }
+        render(json: @response, status: :not_found)
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/contacts_controller.rb
+++ b/app/controllers/repp/v1/contacts_controller.rb
@ -0,0 +1,137 @@
+require 'serializers/repp/contact'
+module Repp
+  module V1
+    class ContactsController < BaseController
+      before_action :find_contact, only: %i[show update destroy]
+
+      ## GET /repp/v1/contacts
+      def index
+        record_count = current_user.registrar.contacts.count
+        contacts = showable_contacts(params[:details], params[:limit] || 200,
+                                     params[:offset] || 0)
+        @response = { contacts: contacts, total_number_of_records: record_count }
+        render(json: @response, status: :ok)
+      end
+
+      ## GET /repp/v1/contacts/1
+      def show
+        serializer = ::Serializers::Repp::Contact.new(@contact,
+                                                      show_address: Contact.address_processing?)
+        render_success(data: serializer.to_json)
+      end
+
+      ## GET /repp/v1/contacts/check/1
+      def check
+        contact = Epp::Contact.find_by(code: params[:id])
+        data = { contact: { id: params[:id], available: contact.nil? } }
+
+        render_success(data: data)
+      end
+
+      ## POST /repp/v1/contacts
+      def create
+        @contact = Epp::Contact.new(contact_params_with_address, current_user.registrar, epp: false)
+        action = Actions::ContactCreate.new(@contact, params[:legal_document],
+                                            contact_ident_params)
+
+        unless action.call
+          handle_errors(@contact)
+          return
+        end
+
+        render_success(create_update_success_body)
+      end
+
+      ## PUT /repp/v1/contacts/1
+      def update
+        action = Actions::ContactUpdate.new(@contact, contact_params_with_address(required: false),
+                                            params[:legal_document],
+                                            contact_ident_params(required: false), current_user)
+
+        unless action.call
+          handle_errors(@contact)
+          return
+        end
+
+        render_success(create_update_success_body)
+      end
+
+      def destroy
+        action = Actions::ContactDelete.new(@contact, params[:legal_document])
+        unless action.call
+          handle_errors(@contact)
+          return
+        end
+
+        render_success
+      end
+
+      def contact_addr_present?
+        return false unless contact_addr_params.key?(:addr)
+
+        contact_addr_params[:addr].keys.any?
+      end
+
+      def create_update_success_body
+        { code: opt_addr? ? 1100 : nil, data: { contact: { id: @contact.code } },
+          message: opt_addr? ? I18n.t('epp.contacts.completed_without_address') : nil }
+      end
+
+      def showable_contacts(details, limit, offset)
+        contacts = current_user.registrar.contacts.limit(limit).offset(offset)
+
+        return contacts.pluck(:code) unless details
+
+        contacts = contacts.map do |contact|
+          serializer = ::Serializers::Repp::Contact.new(contact,
+                                                        show_address: Contact.address_processing?)
+          serializer.to_json
+        end
+
+        contacts
+      end
+
+      def opt_addr?
+        !Contact.address_processing? && contact_addr_present?
+      end
+
+      def find_contact
+        code = params[:id]
+        @contact = Epp::Contact.find_by!(code: code, registrar: current_user.registrar)
+      end
+
+      def contact_params_with_address(required: true)
+        return contact_create_params(required: required) unless contact_addr_params.key?(:addr)
+
+        addr = {}
+        contact_addr_params[:addr].each_key { |k| addr[k] = contact_addr_params[:addr][k] }
+        contact_create_params(required: required).merge(addr)
+      end
+
+      def contact_create_params(required: true)
+        params.require(:contact).require(%i[name email phone]) if required
+        params.require(:contact).permit(:name, :email, :phone, :id)
+      end
+
+      def contact_ident_params(required: true)
+        if required
+          params.require(:contact).require(:ident).require(%i[ident ident_type ident_country_code])
+          params.require(:contact).require(:ident).permit(:ident, :ident_type, :ident_country_code)
+        else
+          params.permit(contact: { ident: %i[ident ident_type ident_country_code] })
+        end
+
+        params[:contact][:ident]
+      end
+
+      def contact_addr_params
+        if Contact.address_processing?
+          params.require(:contact).require(:addr).require(%i[country_code city street zip])
+          params.require(:contact).require(:addr).permit(:country_code, :city, :street, :zip)
+        else
+          params.require(:contact).permit(addr: %i[country_code city street zip])
+        end
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/domains/contacts_controller.rb
+++ b/app/controllers/repp/v1/domains/contacts_controller.rb
@ -0,0 +1,42 @@
+module Repp
+  module V1
+    module Domains
+      class ContactsController < BaseController
+        before_action :set_current_contact, only: [:update]
+        before_action :set_new_contact, only: [:update]
+
+        def set_current_contact
+          @current_contact = current_user.registrar.contacts.find_by!(
+            code: contact_params[:current_contact_id]
+          )
+        end
+
+        def set_new_contact
+          @new_contact = current_user.registrar.contacts.find_by!(code: params[:new_contact_id])
+        end
+
+        def update
+          @epp_errors ||= []
+          @epp_errors << { code: 2304, msg: 'New contact must be valid' } if @new_contact.invalid?
+
+          if @new_contact == @current_contact
+            @epp_errors << { code: 2304, msg: 'New contact must be different from current' }
+          end
+
+          return handle_errors if @epp_errors.any?
+
+          affected, skipped = TechDomainContact.replace(@current_contact, @new_contact)
+          @response = { affected_domains: affected, skipped_domains: skipped }
+          render_success(data: @response)
+        end
+
+        private
+
+        def contact_params
+          params.require(%i[current_contact_id new_contact_id])
+          params.permit(:current_contact_id, :new_contact_id)
+        end
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/domains/renews_controller.rb
+++ b/app/controllers/repp/v1/domains/renews_controller.rb
@ -0,0 +1,65 @@
+module Repp
+  module V1
+    module Domains
+      class RenewsController < BaseController
+        before_action :validate_renew_period, only: [:bulk_renew]
+        before_action :select_renewable_domains, only: [:bulk_renew]
+
+        def bulk_renew
+          renew = run_bulk_renew_task(@domains, bulk_renew_params[:renew_period])
+          return render_success(data: { updated_domains: @domains.map(&:name) }) if renew.valid?
+
+          @epp_errors << { code: 2002,
+                           msg: renew.errors.keys.map { |k, _v| renew.errors[k] }.join(', ') }
+          handle_errors
+        end
+
+        private
+
+        def validate_renew_period
+          @epp_errors ||= []
+          periods = Depp::Domain::PERIODS.map { |p| p[1] }
+          return if periods.include? bulk_renew_params[:renew_period]
+
+          @epp_errors << { code: 2005, msg: 'Invalid renew period' }
+        end
+
+        def select_renewable_domains
+          @epp_errors ||= []
+
+          if bulk_renew_params[:domains].instance_of?(Array)
+            @domains = bulk_renew_domains
+          else
+            @epp_errors << { code: 2005, msg: 'Domains attribute must be an array' }
+          end
+
+          return handle_errors if @epp_errors.any?
+        end
+
+        def run_bulk_renew_task(domains, period)
+          ::Domains::BulkRenew::Start.run(domains: domains, period_element: period,
+                                          registrar: current_user.registrar)
+        end
+
+        def bulk_renew_params
+          params do
+            params.require(%i[domains renew_period])
+            params.permit(:domains, :renew_period)
+          end
+        end
+
+        def bulk_renew_domains
+          @epp_errors ||= []
+          domains = []
+          bulk_renew_params[:domains].each do |idn|
+            domain = Epp::Domain.find_by(name: idn)
+            domains << domain if domain
+            @epp_errors << { code: 2304, msg: "Object does not exist: #{idn}" } unless domain
+          end
+
+          domains
+        end
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/domains_controller.rb
+++ b/app/controllers/repp/v1/domains_controller.rb
@ -0,0 +1,94 @@
+module Repp
+  module V1
+    class DomainsController < BaseController
+      before_action :set_authorized_domain, only: [:transfer_info]
+
+      def index
+        records = current_user.registrar.domains
+        domains = records.limit(limit).offset(offset)
+        domains = domains.pluck(:name) unless index_params[:details] == 'true'
+
+        render_success(data: { domains: domains, total_number_of_records: records.count })
+      end
+
+      def transfer_info
+        contact_fields = %i[code name ident ident_type ident_country_code phone email street city
+                            zip country_code statuses]
+
+        data = {
+          domain: @domain.name,
+          registrant: @domain.registrant.as_json(only: contact_fields),
+          admin_contacts: @domain.admin_contacts.map { |c| c.as_json(only: contact_fields) },
+          tech_contacts: @domain.tech_contacts.map { |c| c.as_json(only: contact_fields) },
+        }
+
+        render_success(data: data)
+      end
+
+      def transfer
+        @errors ||= []
+        @successful = []
+
+        transfer_params[:domain_transfers].each do |transfer|
+          initiate_transfer(transfer)
+        end
+
+        render_success(data: { success: @successful, failed: @errors })
+      end
+
+      def initiate_transfer(transfer)
+        domain = Epp::Domain.find_or_initialize_by(name: transfer[:domain_name])
+        action = Actions::DomainTransfer.new(domain, transfer[:transfer_code],
+                                             current_user.registrar)
+
+        if action.call
+          @successful << { type: 'domain_transfer', domain_name: domain.name }
+        else
+          @errors << { type: 'domain_transfer', domain_name: domain.name,
+                       errors: domain.errors[:epp_errors] }
+        end
+      end
+
+      private
+
+      def transfer_params
+        params.require(:data).require(:domain_transfers).each do |t|
+          t.require(:domain_name)
+          t.permit(:domain_name)
+          t.require(:transfer_code)
+          t.permit(:transfer_code)
+        end
+        params.require(:data).permit(domain_transfers: %i[domain_name transfer_code])
+      end
+
+      def transfer_info_params
+        params.require(:id)
+        params.permit(:id)
+      end
+
+      def set_authorized_domain
+        @epp_errors ||= []
+        h = {}
+        h[transfer_info_params[:id].match?(/\A[0-9]+\z/) ? :id : :name] = transfer_info_params[:id]
+        @domain = Domain.find_by!(h)
+
+        return if @domain.transfer_code.eql?(request.headers['Auth-Code'])
+
+        @epp_errors << { code: 2202, msg: I18n.t('errors.messages.epp_authorization_error') }
+        handle_errors
+      end
+
+      def limit
+        index_params[:limit] || 200
+      end
+
+      def offset
+        index_params[:offset] || 0
+      end
+
+      def index_params
+        params.permit(:limit, :offset, :details)
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/registrar/nameservers_controller.rb
+++ b/app/controllers/repp/v1/registrar/nameservers_controller.rb
@ -0,0 +1,56 @@
+module Repp
+  module V1
+    module Registrar
+      class NameserversController < BaseController
+        before_action :verify_nameserver_existance, only: %i[update]
+
+        def update
+          affected = current_user.registrar
+                                 .replace_nameservers(hostname,
+                                                      hostname_params[:data][:attributes],
+                                                      domains: domains_from_params)
+
+          render_success(data: data_format_for_success(affected))
+        rescue ActiveRecord::RecordInvalid => e
+          handle_errors(e.record)
+        end
+
+        private
+
+        def domains_from_params
+          return [] unless params[:data][:domains]
+
+          params[:data][:domains].map(&:downcase)
+        end
+
+        def data_format_for_success(affected_domains)
+          {
+            type: 'nameserver',
+            id: params[:data][:attributes][:hostname],
+            attributes: params[:data][:attributes],
+            affected_domains: affected_domains,
+          }
+        end
+
+        def hostname_params
+          params.require(:data).require(%i[type id])
+          params.require(:data).require(:attributes).require([:hostname])
+
+          params.permit(data: [
+                          :type, :id,
+                          { domains: [],
+                            attributes: [:hostname, { ipv4: [], ipv6: [] }] }
+                        ])
+        end
+
+        def hostname
+          hostname_params[:data][:id]
+        end
+
+        def verify_nameserver_existance
+          current_user.registrar.nameservers.find_by!(hostname: hostname)
+        end
+      end
+    end
+  end
+end
--- a/app/controllers/repp/v1/retained_domains_controller.rb
+++ b/app/controllers/repp/v1/retained_domains_controller.rb
@ -3,8 +3,9 @@ module Repp
    class RetainedDomainsController < ActionController::API
      def index
        domains = RetainedDomains.new(query_params)
+        @response = { count: domains.count, domains: domains.to_jsonable }

-        render json: { count: domains.count, domains: domains.to_jsonable }
+        render json: @response
      end

      def query_params
--- a/app/helpers/object_versions_helper.rb
+++ b/app/helpers/object_versions_helper.rb
@ -3,7 +3,7 @@ module ObjectVersionsHelper
    version.object_changes.to_h.each do |key, value|
      method_name = "#{key}=".to_sym
      if new_object.respond_to?(method_name)
-        new_object.public_send(method_name, value.last)
+        new_object.public_send(method_name, event_value(version, value))
      end
    end
  end
@ -12,4 +12,10 @@ module ObjectVersionsHelper
    field_names = model.column_names
    version.object.to_h.select { |key, _value| field_names.include?(key) }
  end
+
+  private
+
+  def event_value(version, val)
+    version.event == 'destroy' ? val.first : val.last
+  end
 end
--- a/app/interactions/domains/bulk_renew/single_domain_renew.rb
+++ b/app/interactions/domains/bulk_renew/single_domain_renew.rb
@ -0,0 +1,62 @@
+module Domains
+  module BulkRenew
+    class SingleDomainRenew < ActiveInteraction::Base
+      object :domain,
+             class: Epp::Domain
+      integer :period
+      string :unit
+      object :registrar
+
+      def execute
+        in_transaction_with_retries do
+          success = domain.renew(domain.valid_to, period, unit)
+          if success
+            check_balance
+            reduce_balance
+          else
+            add_error
+          end
+        end
+      end
+
+      def check_balance
+        compose(Domains::CheckBalance::SingleDomain,
+                domain: domain,
+                operation: 'renew',
+                period: period,
+                unit: unit)
+      end
+
+      def reduce_balance
+        domain_pricelist = domain.pricelist('renew', period, unit)
+        registrar.debit!(sum: domain_pricelist.price.amount,
+                         description: "#{I18n.t('renew')} #{domain.name}",
+                         activity_type: AccountActivity::RENEW,
+                         price: domain_pricelist)
+      end
+
+      def in_transaction_with_retries
+        if Rails.env.test?
+          yield
+        else
+          transaction_wrapper { yield }
+        end
+      rescue ActiveRecord::StatementInvalid
+        sleep rand / 100
+        retry
+      end
+
+      def transaction_wrapper
+        ActiveRecord::Base.transaction(isolation: :serializable) do
+          yield if block_given?
+        end
+      end
+
+      private
+
+      def add_error
+        errors.add(:domain, I18n.t('domain_renew_error_for_domain', domain: domain.name))
+      end
+    end
+  end
+end
--- a/app/interactions/domains/bulk_renew/start.rb
+++ b/app/interactions/domains/bulk_renew/start.rb
@ -0,0 +1,56 @@
+module Domains
+  module BulkRenew
+    class Start < ActiveInteraction::Base
+      array :domains do
+        object class: Epp::Domain
+      end
+      string :period_element
+      object :registrar
+
+      def execute
+        if renewable?
+          domains.each do |domain|
+            task = run_task(domain)
+            manage_errors(task)
+          end
+        else
+          manage_errors(mass_check_balance)
+        end
+      end
+
+      private
+
+      def renewable?
+        mass_check_balance.valid? && mass_check_balance.result
+      end
+
+      def period
+        period_element.to_i.zero? ? 1 : period_element.to_i
+      end
+
+      def unit
+        period_element[-1] || 'y'
+      end
+
+      def mass_check_balance
+        Domains::CheckBalance::Mass.run(domains: domains,
+                                        operation: 'renew',
+                                        period: period,
+                                        unit: unit,
+                                        balance: registrar.balance)
+      end
+
+      def manage_errors(task)
+        task.errors.each { |k, v| errors.add(k, v) } unless task.valid?
+        errors.add(:domain, I18n.t('not_enough_funds')) unless task.result
+      end
+
+      def run_task(domain)
+        Domains::BulkRenew::SingleDomainRenew.run(domain: domain,
+                                                  period: period,
+                                                  unit: unit,
+                                                  registrar: registrar)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/base.rb
+++ b/app/interactions/domains/cancel_force_delete/base.rb
@ -0,0 +1,9 @@
+module Domains
+  module CancelForceDelete
+    class Base < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to cancel ForceDelete on'
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/cancel_force_delete.rb
+++ b/app/interactions/domains/cancel_force_delete/cancel_force_delete.rb
@ -0,0 +1,12 @@
+module Domains
+  module CancelForceDelete
+    class CancelForceDelete < Base
+      def execute
+        compose(RemoveForceDeleteStatuses, inputs)
+        compose(RestoreStatusesBeforeForceDelete, inputs)
+        compose(ClearForceDeleteData, inputs)
+        compose(NotifyRegistrar, inputs)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/clear_force_delete_data.rb
+++ b/app/interactions/domains/cancel_force_delete/clear_force_delete_data.rb
@ -0,0 +1,12 @@
+module Domains
+  module CancelForceDelete
+    class ClearForceDeleteData < Base
+      def execute
+        domain.force_delete_data = nil
+        domain.force_delete_date = nil
+        domain.force_delete_start = nil
+        domain.save(validate: false)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/notify_registrar.rb
+++ b/app/interactions/domains/cancel_force_delete/notify_registrar.rb
@ -0,0 +1,10 @@
+module Domains
+  module CancelForceDelete
+    class NotifyRegistrar < Base
+      def execute
+        domain.registrar.notifications.create!(text: I18n.t('force_delete_cancelled',
+                                                            domain_name: domain.name))
+      end
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/remove_force_delete_statuses.rb
+++ b/app/interactions/domains/cancel_force_delete/remove_force_delete_statuses.rb
@ -0,0 +1,13 @@
+module Domains
+  module CancelForceDelete
+    class RemoveForceDeleteStatuses < Base
+      def execute
+        domain.statuses.delete(DomainStatus::FORCE_DELETE)
+        domain.statuses.delete(DomainStatus::SERVER_RENEW_PROHIBITED)
+        domain.statuses.delete(DomainStatus::SERVER_TRANSFER_PROHIBITED)
+        domain.statuses.delete(DomainStatus::CLIENT_HOLD)
+        domain.save(validate: false)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/cancel_force_delete/restore_statuses_before_force_delete.rb
+++ b/app/interactions/domains/cancel_force_delete/restore_statuses_before_force_delete.rb
@ -0,0 +1,11 @@
+module Domains
+  module CancelForceDelete
+    class RestoreStatusesBeforeForceDelete < Base
+      def execute
+        domain.statuses = domain.statuses_before_force_delete
+        domain.statuses_before_force_delete = nil
+        domain.save(validate: false)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/check_balance/mass.rb
+++ b/app/interactions/domains/check_balance/mass.rb
@ -0,0 +1,33 @@
+module Domains
+  module CheckBalance
+    class Mass < ActiveInteraction::Base
+      array :domains do
+        object class: Epp::Domain
+      end
+      string :operation
+      integer :period
+      string :unit
+      float :balance
+
+      attr_accessor :total_price
+
+      def execute
+        calculate_total_price
+
+        balance >= @total_price
+      end
+
+      def calculate_total_price
+        @total_price = 0
+        domains.each do |domain|
+          task = Domains::CheckBalance::SingleDomain.run(domain: domain,
+                                                         operation: 'renew',
+                                                         period: period,
+                                                         unit: unit)
+
+          task.valid? ? @total_price += task.result : errors.merge!(task.errors)
+        end
+      end
+    end
+  end
+end
--- a/app/interactions/domains/check_balance/single_domain.rb
+++ b/app/interactions/domains/check_balance/single_domain.rb
@ -0,0 +1,26 @@
+module Domains
+  module CheckBalance
+    class SingleDomain < ActiveInteraction::Base
+      object :domain,
+             class: Epp::Domain
+
+      string :operation
+      integer :period
+      string :unit
+
+      def execute
+        return domain_pricelist.price.amount if domain_pricelist.try(:price)
+
+        errors.add(:domain, I18n.t(:active_price_missing_for_operation_with_domain,
+                                   domain: domain.name))
+        false
+      end
+
+      private
+
+      def domain_pricelist
+        domain.pricelist(operation, period.try(:to_i), unit)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/client_hold/base.rb
+++ b/app/interactions/domains/client_hold/base.rb
@ -0,0 +1,10 @@
+module Domains
+  module ClientHold
+    class Base < ActiveInteraction::Base
+      def to_stdout(message)
+        time = Time.zone.now.utc
+        STDOUT << "#{time} - #{message}\n" unless Rails.env.test?
+      end
+    end
+  end
+end
--- a/app/interactions/domains/client_hold/process_client_hold.rb
+++ b/app/interactions/domains/client_hold/process_client_hold.rb
@ -0,0 +1,69 @@
+module Domains
+  module ClientHold
+    class ProcessClientHold < Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to set ClientHold on'
+
+      # rubocop:disable Metrics/AbcSize
+      def execute
+        notify_on_grace_period if should_notify_on_soft_force_delete?
+
+        return unless client_holdable?
+
+        domain.statuses << DomainStatus::CLIENT_HOLD
+        to_stdout("DomainCron.start_client_hold: #{domain.id} (#{domain.name}) #{domain.changes}\n")
+
+        domain.save(validate: false)
+        notify_client_hold
+
+        to_stdout("Successfully set client_hold on (#{domain.name})")
+      end
+
+      def notify_on_grace_period
+        domain.registrar.notifications.create!(text: I18n.t('grace_period_started_domain',
+                                                            domain_name: domain.name,
+                                                            date: domain.force_delete_start))
+        send_mail if domain.template_name.present?
+        domain.update(contact_notification_sent_date: Time.zone.today)
+      end
+
+      def notify_client_hold
+        domain.registrar.notifications.create!(text: I18n.t('force_delete_set_on_domain',
+                                                            domain_name: domain.name,
+                                                            outzone_date: domain.outzone_date,
+                                                            purge_date: domain.purge_date))
+      end
+
+      def send_mail
+        DomainDeleteMailer.forced(domain: domain,
+                                  registrar: domain.registrar,
+                                  registrant: domain.registrant,
+                                  template_name: domain.template_name).deliver_now
+      end
+
+      def should_notify_on_soft_force_delete?
+        domain.force_delete_scheduled? && domain.contact_notification_sent_date.blank? &&
+          domain.force_delete_start.to_date <= Time.zone.now.to_date &&
+          domain.force_delete_type.to_sym == :soft &&
+          !domain.statuses.include?(DomainStatus::CLIENT_HOLD)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def client_holdable?
+        domain.force_delete_scheduled? &&
+          !domain.statuses.include?(DomainStatus::CLIENT_HOLD) &&
+          domain.force_delete_start.present? &&
+          force_delete_lte_today && force_delete_lte_valid_date
+      end
+
+      def force_delete_lte_today
+        domain.force_delete_start + Setting.expire_warning_period.days <= Time.zone.now
+      end
+
+      def force_delete_lte_valid_date
+        domain.force_delete_start + Setting.expire_warning_period.days <= domain.valid_to
+      end
+    end
+  end
+end
--- a/app/interactions/domains/client_hold/set_client_hold.rb
+++ b/app/interactions/domains/client_hold/set_client_hold.rb
@ -0,0 +1,17 @@
+module Domains
+  module ClientHold
+    class SetClientHold < Base
+      def execute
+        to_stdout('Setting client_hold to domains\n')
+
+        ::PaperTrail.request.whodunnit = "cron - #{self.class.name}"
+
+        ::Domain.force_delete_scheduled.each do |domain|
+          Domains::ClientHold::ProcessClientHold.run(domain: domain)
+        end
+
+        to_stdout('All client_hold setting are done\n')
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete/base.rb
+++ b/app/interactions/domains/delete/base.rb
@ -0,0 +1,9 @@
+module Domains
+  module Delete
+    class Base < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to delete'
+    end
+  end
+end
--- a/app/interactions/domains/delete/do_delete.rb
+++ b/app/interactions/domains/delete/do_delete.rb
@ -0,0 +1,13 @@
+module Domains
+  module Delete
+    class DoDelete < Base
+      def execute
+        ::PaperTrail.request.whodunnit = "interaction - #{self.class.name}"
+        WhoisRecord.where(domain_id: domain.id).destroy_all
+
+        domain.destroy
+        compose(Domains::Delete::NotifyRegistrar, inputs)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete/notify_registrar.rb
+++ b/app/interactions/domains/delete/notify_registrar.rb
@ -0,0 +1,14 @@
+module Domains
+  module Delete
+    class NotifyRegistrar < Base
+      def execute
+        bye_bye = domain.versions.last
+        domain.registrar.notifications.create!(
+          text: "#{I18n.t(:domain_deleted)}: #{domain.name}",
+          attached_obj_id: bye_bye.id,
+          attached_obj_type: bye_bye.class.to_s
+        )
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete_confirm/base.rb
+++ b/app/interactions/domains/delete_confirm/base.rb
@ -0,0 +1,53 @@
+module Domains
+  module DeleteConfirm
+    class Base < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to confirm release'
+      string :action
+      string :initiator,
+             default: nil
+
+      validates :domain, :action, presence: true
+      validates :action, inclusion: { in: [RegistrantVerification::CONFIRMED,
+                                           RegistrantVerification::REJECTED] }
+
+      def raise_errors!(domain)
+        return unless domain.errors.any?
+
+        message = "domain #{domain.name} failed with errors #{domain.errors.full_messages}"
+        throw message
+      end
+
+      def notify_registrar(message_key)
+        domain.registrar.notifications.create!(
+          text: "#{I18n.t(message_key)}: #{domain.name}",
+          attached_obj_id: domain.id,
+          attached_obj_type: domain.class.to_s
+        )
+      end
+
+      def preclean_pendings
+        domain.registrant_verification_token = nil
+        domain.registrant_verification_asked_at = nil
+      end
+
+      def clean_pendings!
+        domain.is_admin = true
+        domain.registrant_verification_token = nil
+        domain.registrant_verification_asked_at = nil
+        domain.pending_json = {}
+        clear_statuses
+        domain.save
+      end
+
+      def clear_statuses
+        domain.statuses.delete(DomainStatus::PENDING_DELETE_CONFIRMATION)
+        domain.statuses.delete(DomainStatus::PENDING_UPDATE)
+        domain.statuses.delete(DomainStatus::PENDING_DELETE)
+        domain.status_notes[DomainStatus::PENDING_UPDATE] = ''
+        domain.status_notes[DomainStatus::PENDING_DELETE] = ''
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete_confirm/process_action.rb
+++ b/app/interactions/domains/delete_confirm/process_action.rb
@ -0,0 +1,17 @@
+module Domains
+  module DeleteConfirm
+    class ProcessAction < Base
+      def execute
+        ::PaperTrail.request.whodunnit = "interaction - #{self.class.name} - #{action} by"\
+          " #{initiator}"
+
+        case action
+        when RegistrantVerification::CONFIRMED
+          compose(ProcessDeleteConfirmed, inputs)
+        when RegistrantVerification::REJECTED
+          compose(ProcessDeleteRejected, inputs)
+        end
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete_confirm/process_delete_confirmed.rb
+++ b/app/interactions/domains/delete_confirm/process_delete_confirmed.rb
@ -0,0 +1,50 @@
+module Domains
+  module DeleteConfirm
+    class ProcessDeleteConfirmed < Base
+      def execute
+        notify_registrar(:poll_pending_delete_confirmed_by_registrant)
+        domain.apply_pending_delete!
+        raise_errors!(domain)
+      end
+
+      def apply_pending_delete!
+        preclean_pendings
+        clean_pendings!
+        DomainDeleteMailer.accepted(domain).deliver_now
+        domain.set_pending_delete!
+      end
+
+      def set_pending_delete!
+        unless domain.pending_deletable?
+          add_epp_error
+          return
+        end
+
+        domain.delete_date = delete_date
+        domain.statuses << DomainStatus::PENDING_DELETE
+        set_server_hold if server_holdable?
+        domain.save(validate: false)
+      end
+
+      def set_server_hold
+        domain.statuses << DomainStatus::SERVER_HOLD
+        domain.outzone_at = Time.current
+      end
+
+      def server_holdable?
+        return false if domain.statuses.include?(DomainStatus::SERVER_HOLD)
+        return false if domain.statuses.include?(DomainStatus::SERVER_MANUAL_INZONE)
+
+        true
+      end
+
+      def delete_date
+        Time.zone.today + Setting.redemption_grace_period.days + 1.day
+      end
+
+      def add_epp_error
+        domain.add_epp_error('2304', nil, nil, I18n.t(:object_status_prohibits_operation))
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete_confirm/process_delete_rejected.rb
+++ b/app/interactions/domains/delete_confirm/process_delete_rejected.rb
@ -0,0 +1,32 @@
+module Domains
+  module DeleteConfirm
+    class ProcessDeleteRejected < Base
+      def execute
+        domain.cancel_pending_delete
+        notify_registrar(:poll_pending_delete_rejected_by_registrant)
+        domain.save(validate: false)
+        raise_errors!(domain)
+
+        send_domain_delete_rejected_email
+      end
+
+      def send_domain_delete_rejected_email
+        if domain.registrant_verification_token.blank?
+          warn "EMAIL NOT DELIVERED: registrant_verification_token is missing for #{domain.name}"
+        elsif domain.registrant_verification_asked_at.blank?
+          warn "EMAIL NOT DELIVERED: registrant_verification_asked_at is missing for #{domain.name}"
+        else
+          send_email
+        end
+      end
+
+      def warn(message)
+        Rails.logger.warn(message)
+      end
+
+      def send_email
+        DomainDeleteMailer.rejected(domain).deliver_now
+      end
+    end
+  end
+end
--- a/app/interactions/domains/delete_confirm_email/send_request.rb
+++ b/app/interactions/domains/delete_confirm_email/send_request.rb
@ -0,0 +1,24 @@
+module Domains
+  module DeleteConfirmEmail
+    class SendRequest < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to send delete confirmation'
+
+      def execute
+        log
+        DomainDeleteMailer.confirmation_request(domain: domain,
+                                                registrar: domain.registrar,
+                                                registrant: domain.registrant).deliver_later
+      end
+
+      private
+
+      def log
+        message = "Send DomainDeleteMailer#confirm email for domain #{domain.name} (##{domain.id})"\
+      " to #{domain.registrant.email}"
+        Rails.logger.info(message)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expire_period/base.rb
+++ b/app/interactions/domains/expire_period/base.rb
@ -0,0 +1,10 @@
+module Domains
+  module ExpirePeriod
+    class Base < ActiveInteraction::Base
+      def to_stdout(message)
+        time = Time.zone.now.utc
+        STDOUT << "#{time} - #{message}\n" unless Rails.env.test?
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expire_period/process_expired.rb
+++ b/app/interactions/domains/expire_period/process_expired.rb
@ -0,0 +1,28 @@
+module Domains
+  module ExpirePeriod
+    class ProcessExpired < Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to set expiration'
+
+      def execute
+        set_graceful_expired
+        to_stdout("start_expire_period: ##{domain.id} (#{domain.name}) #{domain.changes}")
+
+        saved = domain.save(validate: false)
+
+        DomainExpireEmailJob.enqueue(domain.id, run_at: send_time) if saved
+      end
+
+      def set_graceful_expired
+        domain.outzone_at = domain.expire_time + Domain.expire_warning_period
+        domain.delete_date = domain.outzone_at + Domain.redemption_grace_period
+        domain.statuses |= [DomainStatus::EXPIRED]
+      end
+
+      def send_time
+        domain.valid_to + Setting.expiration_reminder_mail.to_i.days
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expire_period/start.rb
+++ b/app/interactions/domains/expire_period/start.rb
@ -0,0 +1,19 @@
+module Domains
+  module ExpirePeriod
+    class Start < Base
+      def execute
+        ::PaperTrail.request.whodunnit = "cron - #{self.class.name}"
+        count = 0
+
+        Domain.expired.each do |domain|
+          next unless domain.expirable?
+
+          count += 1
+          Domains::ExpirePeriod::ProcessExpired.run(domain: domain)
+        end
+
+        to_stdout("Successfully expired #{count}")
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expired_pendings/base.rb
+++ b/app/interactions/domains/expired_pendings/base.rb
@ -0,0 +1,10 @@
+module Domains
+  module ExpiredPendings
+    class Base < ActiveInteraction::Base
+      def to_stdout(message)
+        time = Time.zone.now.utc
+        STDOUT << "#{time} - #{message}\n" unless Rails.env.test?
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expired_pendings/clean_all.rb
+++ b/app/interactions/domains/expired_pendings/clean_all.rb
@ -0,0 +1,35 @@
+module Domains
+  module ExpiredPendings
+    class CleanAll < Base
+      def execute
+        to_stdout('Clean expired domain pendings')
+
+        ::PaperTrail.request.whodunnit = "cron - #{self.class.name}"
+
+        count = 0
+        expired_pending_domains.each do |domain|
+          log_error(domain) && next unless need_to_be_cleared?(domain)
+          count += 1
+          Domains::ExpiredPendings::ProcessClean.run(domain: domain)
+        end
+        to_stdout("Successfully cancelled #{count} domain pendings")
+      end
+
+      private
+
+      def need_to_be_cleared?(domain)
+        domain.pending_update? || domain.pending_delete? || domain.pending_delete_confirmation?
+      end
+
+      def log_error(domain)
+        to_stdout("ISSUE: DOMAIN #{domain.id}: #{domain.name} IS IN EXPIRED PENDING LIST, "\
+                'but no pendingDelete/pendingUpdate state present!')
+      end
+
+      def expired_pending_domains
+        expire_at = Setting.expire_pending_confirmation.hours.ago
+        Domain.where('registrant_verification_asked_at <= ?', expire_at)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/expired_pendings/process_clean.rb
+++ b/app/interactions/domains/expired_pendings/process_clean.rb
@ -0,0 +1,60 @@
+module Domains
+  module ExpiredPendings
+    class ProcessClean < Base
+      object :domain,
+             class: Domain
+
+      def execute
+        check_notify
+        clean_pendings
+
+        to_stdout("DomainCron.clean_expired_pendings: ##{domain.id} (#{domain.name})")
+        UpdateWhoisRecordJob.enqueue domain.name, 'domain'
+      end
+
+      private
+
+      def notify_pending_update
+        RegistrantChangeMailer.expired(domain: domain,
+                                       registrar: domain.registrar,
+                                       registrant: domain.registrant).deliver_later
+      end
+
+      def notify_pending_delete
+        DomainDeleteMailer.expired(domain).deliver_later
+      end
+
+      def clean_pendings
+        clean_verification_data
+        domain.pending_json = {}
+        clean_statuses
+        domain.save
+      end
+
+      def statuses_to_clean
+        [DomainStatus::PENDING_DELETE_CONFIRMATION,
+         DomainStatus::PENDING_UPDATE,
+         DomainStatus::PENDING_DELETE]
+      end
+
+      def clean_statuses
+        domain.statuses = domain.statuses - statuses_to_clean
+        domain.status_notes[DomainStatus::PENDING_UPDATE] = ''
+        domain.status_notes[DomainStatus::PENDING_DELETE] = ''
+      end
+
+      def clean_verification_data
+        domain.registrant_verification_token = nil
+        domain.registrant_verification_asked_at = nil
+      end
+
+      def check_notify
+        notify_pending_update if domain.pending_update?
+
+        return unless domain.pending_delete? || domain.pending_delete_confirmation?
+
+        notify_pending_delete
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/base.rb
+++ b/app/interactions/domains/force_delete/base.rb
@ -0,0 +1,17 @@
+module Domains
+  module ForceDelete
+    class Base < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to set ForceDelete on'
+      symbol :type,
+             default: :fast_track,
+             description: 'Force delete type, might be :fast_track or :soft'
+      boolean :notify_by_email,
+              default: false,
+              description: 'Do we need to send email notification'
+
+      validates :type, inclusion: { in: %i[fast_track soft] }
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/check_discarded.rb
+++ b/app/interactions/domains/force_delete/check_discarded.rb
@ -0,0 +1,12 @@
+module Domains
+  module ForceDelete
+    class CheckDiscarded < Base
+      def execute
+        return true unless domain.discarded?
+
+        message = 'Force delete procedure cannot be scheduled while a domain is discarded'
+        errors.add(:domain, message)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/notify_by_email.rb
+++ b/app/interactions/domains/force_delete/notify_by_email.rb
@ -0,0 +1,23 @@
+module Domains
+  module ForceDelete
+    class NotifyByEmail < Base
+      def execute
+        return unless notify_by_email
+
+        if type == :fast_track
+          send_email
+          domain.update(contact_notification_sent_date: Time.zone.today)
+        else
+          domain.update(template_name: domain.notification_template)
+        end
+      end
+
+      def send_email
+        DomainDeleteMailer.forced(domain: domain,
+                                  registrar: domain.registrar,
+                                  registrant: domain.registrant,
+                                  template_name: domain.notification_template).deliver_now
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/notify_registrar.rb
+++ b/app/interactions/domains/force_delete/notify_registrar.rb
@ -0,0 +1,12 @@
+module Domains
+  module ForceDelete
+    class NotifyRegistrar < Base
+      def execute
+        domain.registrar.notifications.create!(text: I18n.t('force_delete_set_on_domain',
+                                                            domain_name: domain.name,
+                                                            outzone_date: domain.outzone_date,
+                                                            purge_date: domain.purge_date))
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/post_set_process.rb
+++ b/app/interactions/domains/force_delete/post_set_process.rb
@ -0,0 +1,19 @@
+module Domains
+  module ForceDelete
+    class PostSetProcess < Base
+      def execute
+        statuses = domain.statuses
+        # Stop all pending actions
+        statuses.delete(DomainStatus::PENDING_UPDATE)
+        statuses.delete(DomainStatus::PENDING_TRANSFER)
+        statuses.delete(DomainStatus::PENDING_RENEW)
+        statuses.delete(DomainStatus::PENDING_CREATE)
+
+        # Allow deletion
+        statuses.delete(DomainStatus::CLIENT_DELETE_PROHIBITED)
+        statuses.delete(DomainStatus::SERVER_DELETE_PROHIBITED)
+        domain.save(validate: false)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/prepare_domain.rb
+++ b/app/interactions/domains/force_delete/prepare_domain.rb
@ -0,0 +1,15 @@
+module Domains
+  module ForceDelete
+    class PrepareDomain < Base
+      STATUSES_TO_SET = [DomainStatus::FORCE_DELETE,
+                         DomainStatus::SERVER_RENEW_PROHIBITED,
+                         DomainStatus::SERVER_TRANSFER_PROHIBITED].freeze
+
+      def execute
+        domain.statuses_before_force_delete = domain.statuses
+        domain.statuses |= STATUSES_TO_SET
+        domain.save(validate: false)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/set_force_delete.rb
+++ b/app/interactions/domains/force_delete/set_force_delete.rb
@ -0,0 +1,14 @@
+module Domains
+  module ForceDelete
+    class SetForceDelete < Base
+      def execute
+        compose(CheckDiscarded, inputs)
+        compose(PrepareDomain, inputs)
+        compose(SetStatus, inputs)
+        compose(PostSetProcess, inputs)
+        compose(NotifyRegistrar, inputs)
+        compose(NotifyByEmail, inputs)
+      end
+    end
+  end
+end
--- a/app/interactions/domains/force_delete/set_status.rb
+++ b/app/interactions/domains/force_delete/set_status.rb
@ -0,0 +1,40 @@
+module Domains
+  module ForceDelete
+    class SetStatus < Base
+      def execute
+        domain.force_delete_type = type
+        type == :fast_track ? force_delete_fast_track : force_delete_soft
+        domain.save(validate: false)
+      end
+
+      def force_delete_fast_track
+        domain.force_delete_date = Time.zone.today +
+                                   expire_warning_period_days +
+                                   redemption_grace_period_days
+        domain.force_delete_start = Time.zone.today + 1.day
+      end
+
+      def force_delete_soft
+        years = (domain.valid_to.to_date - Time.zone.today).to_i / 365
+        soft_forcedelete_dates(years) if years.positive?
+      end
+
+      private
+
+      def soft_forcedelete_dates(years)
+        domain.force_delete_start = domain.valid_to - years.years
+        domain.force_delete_date = domain.force_delete_start +
+                                   Setting.expire_warning_period.days +
+                                   Setting.redemption_grace_period.days
+      end
+
+      def redemption_grace_period_days
+        Setting.redemption_grace_period.days + 1.day
+      end
+
+      def expire_warning_period_days
+        Setting.expire_warning_period.days
+      end
+    end
+  end
+end
--- a/app/interactions/domains/redemption_grace_period/base.rb
+++ b/app/interactions/domains/redemption_grace_period/base.rb
@ -0,0 +1,10 @@
+module Domains
+  module RedemptionGracePeriod
+    class Base < ActiveInteraction::Base
+      def to_stdout(message)
+        time = Time.zone.now.utc
+        STDOUT << "#{time} - #{message}\n" unless Rails.env.test?
+      end
+    end
+  end
+end
--- a/app/interactions/domains/redemption_grace_period/process_grace_period.rb
+++ b/app/interactions/domains/redemption_grace_period/process_grace_period.rb
@ -0,0 +1,20 @@
+module Domains
+  module RedemptionGracePeriod
+    class ProcessGracePeriod < Base
+      object :domain,
+             class: Domain
+
+      def execute
+        domain.statuses << DomainStatus::SERVER_HOLD
+        to_stdout(process_msg)
+        domain.save(validate: false)
+      end
+
+      private
+
+      def process_msg
+        "start_redemption_grace_period: #{domain.id} (#{domain.name}) #{domain.changes}"
+      end
+    end
+  end
+end
--- a/app/interactions/domains/redemption_grace_period/start.rb
+++ b/app/interactions/domains/redemption_grace_period/start.rb
@ -0,0 +1,20 @@
+module Domains
+  module RedemptionGracePeriod
+    class Start < Base
+      def execute
+        to_stdout('Setting server_hold to domains')
+
+        ::PaperTrail.request.whodunnit = "cron - #{self.class.name}"
+        count = 0
+
+        Domain.outzone_candidates.each do |domain|
+          next unless domain.server_holdable?
+
+          count += 1
+          Domains::RedemptionGracePeriod::ProcessGracePeriod.run(domain: domain)
+        end
+        to_stdout("Successfully set server_hold to #{count} of domains")
+      end
+    end
+  end
+end
--- a/app/interactions/domains/update_confirm/base.rb
+++ b/app/interactions/domains/update_confirm/base.rb
@ -0,0 +1,53 @@
+module Domains
+  module UpdateConfirm
+    class Base < ActiveInteraction::Base
+      object :domain,
+             class: Domain,
+             description: 'Domain to confirm update'
+      string :action
+      string :initiator,
+             default: nil
+
+      validates :domain, :action, presence: true
+      validates :action, inclusion: { in: [RegistrantVerification::CONFIRMED,
+                                           RegistrantVerification::REJECTED] }
+
+      def raise_errors!(domain)
+        return unless domain.errors.any?
+
+        message = "domain #{domain.name} failed with errors #{domain.errors.full_messages}"
+        throw message
+      end
+
+      def notify_registrar(message_key)
+        domain.registrar.notifications.create!(
+          text: "#{I18n.t(message_key)}: #{domain.name}",
+          attached_obj_id: domain.id,
+          attached_obj_type: domain.class.to_s
+        )
+      end
+
+      def preclean_pendings
+        domain.registrant_verification_token = nil
+        domain.registrant_verification_asked_at = nil
+      end
+
+      def clean_pendings!
+        domain.is_admin = true
+        domain.registrant_verification_token = nil
+        domain.registrant_verification_asked_at = nil
+        domain.pending_json = {}
+        clear_statuses
+        domain.save
+      end
+
+      def clear_statuses
+        domain.statuses.delete(DomainStatus::PENDING_DELETE_CONFIRMATION)
+        domain.statuses.delete(DomainStatus::PENDING_UPDATE)
+        domain.statuses.delete(DomainStatus::PENDING_DELETE)
+        domain.status_notes[DomainStatus::PENDING_UPDATE] = ''
+        domain.status_notes[DomainStatus::PENDING_DELETE] = ''
+      end
+    end
+  end
+end
--- a/app/interactions/domains/update_confirm/process_action.rb
+++ b/app/interactions/domains/update_confirm/process_action.rb
@ -0,0 +1,17 @@
+module Domains
+  module UpdateConfirm
+    class ProcessAction < Base
+      def execute
+        ::PaperTrail.request.whodunnit = "interaction - #{self.class.name} - #{action} by"\
+          " #{initiator}"
+
+        case action
+        when RegistrantVerification::CONFIRMED
+          compose(ProcessUpdateConfirmed, inputs)
+        when RegistrantVerification::REJECTED
+          compose(ProcessUpdateRejected, inputs)
+        end
+      end
+    end
+  end
+end
--- a/app/interactions/domains/update_confirm/process_update_confirmed.rb
+++ b/app/interactions/domains/update_confirm/process_update_confirmed.rb
@ -0,0 +1,34 @@
+module Domains
+  module UpdateConfirm
+    class ProcessUpdateConfirmed < Base
+      def execute
+        ActiveRecord::Base.transaction do
+          old_registrant = domain.registrant
+          notify_registrar(:poll_pending_update_confirmed_by_registrant)
+
+          apply_pending_update!
+          raise_errors!(domain)
+          RegistrantChange.new(domain: domain, old_registrant: old_registrant).confirm
+        end
+      end
+
+      def apply_pending_update!
+        preclean_pendings
+        update_domain
+        clean_pendings!
+
+        WhoisRecord.find_by(domain_id: domain.id).save # need to reload model
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def update_domain
+        user = ApiUser.find(domain.pending_json['current_user_id'])
+        frame = Nokogiri::XML(domain.pending_json['frame'])
+        domain.upid = user.registrar.id if user.registrar
+        domain.up_date = Time.zone.now
+        domain.update(frame, user, false)
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end
--- a/app/interactions/domains/update_confirm/process_update_rejected.rb
+++ b/app/interactions/domains/update_confirm/process_update_rejected.rb
@ -0,0 +1,18 @@
+module Domains
+  module UpdateConfirm
+    class ProcessUpdateRejected < Base
+      def execute
+        ActiveRecord::Base.transaction do
+          RegistrantChangeMailer.rejected(domain: domain,
+                                          registrar: domain.registrar,
+                                          registrant: domain.registrant).deliver_now
+
+          notify_registrar(:poll_pending_update_rejected_by_registrant)
+
+          preclean_pendings
+          clean_pendings!
+        end
+      end
+    end
+  end
+end
--- a/app/interactions/whois/delete_record.rb
+++ b/app/interactions/whois/delete_record.rb
@ -0,0 +1,48 @@
+module Whois
+  class DeleteRecord < ActiveInteraction::Base
+    string :name
+    string :type
+
+    validates :type, inclusion: { in: %w[reserved blocked domain disputed zone] }
+
+    def execute
+      send "delete_#{type}", name
+    end
+
+    # 1. deleting own
+    # 2. trying to regenerate reserved in order domain is still in the list
+    def delete_domain(name)
+      WhoisRecord.where(name: name).destroy_all
+
+      BlockedDomain.find_by(name: name).try(:generate_data)
+      ReservedDomain.find_by(name: name).try(:generate_data)
+      Dispute.active.find_by(domain_name: name).try(:generate_data)
+    end
+
+    def delete_reserved(name)
+      remove_status_from_whois(domain_name: name, domain_status: 'Reserved')
+    end
+
+    def delete_blocked(name)
+      delete_reserved(name)
+    end
+
+    def delete_disputed(name)
+      return if Dispute.active.find_by(domain_name: name).present?
+
+      remove_status_from_whois(domain_name: name, domain_status: 'disputed')
+    end
+
+    def delete_zone(name)
+      WhoisRecord.where(name: name).destroy_all
+      Whois::Record.where(name: name).destroy_all
+    end
+
+    def remove_status_from_whois(domain_name:, domain_status:)
+      Whois::Record.where(name: domain_name).each do |r|
+        r.json['status'] = r.json['status'].delete_if { |status| status == domain_status }
+        r.json['status'].blank? ? r.destroy : r.save
+      end
+    end
+  end
+end
--- a/app/interactions/whois/update.rb
+++ b/app/interactions/whois/update.rb
@ -0,0 +1,39 @@
+module Whois
+  class Update < ActiveInteraction::Base
+    array :names
+    string :type
+
+    validates :type, inclusion: { in: %w[reserved blocked domain disputed zone] }
+
+    def execute
+      ::PaperTrail.request.whodunnit = "job - #{self.class.name} - #{type}"
+
+      klass = determine_class
+
+      Array(names).each do |name|
+        record = find_record(klass, name)
+        if record
+          Whois::UpdateRecord.run(record: record, type: type)
+        else
+          Whois::DeleteRecord.run(name: name, type: type)
+        end
+      end
+    end
+
+    private
+
+    def determine_class
+      case type
+      when 'reserved' then ReservedDomain
+      when 'blocked'  then BlockedDomain
+      when 'domain'   then Domain
+      when 'disputed' then Dispute.active
+      else                 DNS::Zone
+      end
+    end
+
+    def find_record(klass, name)
+      klass == DNS::Zone ? klass.find_by(origin: name) : klass.find_by(name: name)
+    end
+  end
+end
--- a/app/interactions/whois/update_record.rb
+++ b/app/interactions/whois/update_record.rb
@ -0,0 +1,32 @@
+module Whois
+  class UpdateRecord < ActiveInteraction::Base
+    interface :record
+    string :type
+
+    validates :type, inclusion: { in: %w[reserved blocked domain disputed zone] }
+
+    def execute
+      send "update_#{type}", record
+    end
+
+    def update_domain(domain)
+      domain.whois_record ? domain.whois_record.save : domain.create_whois_record
+    end
+
+    def update_reserved(record)
+      record.generate_data
+    end
+
+    def update_blocked(record)
+      update_reserved(record)
+    end
+
+    def update_disputed(record)
+      update_reserved(record)
+    end
+
+    def update_zone(record)
+      update_reserved(record)
+    end
+  end
+end
--- a/app/jobs/application_job.rb
+++ b/app/jobs/application_job.rb
@ -0,0 +1,2 @@
+class ApplicationJob < ActiveJob::Base
+end
--- a/app/jobs/domain_delete_confirm_email_job.rb
+++ b/app/jobs/domain_delete_confirm_email_job.rb
@ -1,22 +0,0 @@
-class DomainDeleteConfirmEmailJob < Que::Job
-  def run(domain_id)
-    domain = Domain.find(domain_id)
-
-    log(domain)
-    DomainDeleteMailer.confirmation_request(domain: domain,
-                                            registrar: domain.registrar,
-                                            registrant: domain.registrant).deliver_now
-  end
-
-  private
-
-  def log(domain)
-    message = "Send DomainDeleteMailer#confirm email for domain #{domain.name} (##{domain.id})" \
-    " to #{domain.registrant.email}"
-    logger.info(message)
-  end
-
-  def logger
-    Rails.logger
-  end
-end
--- a/app/jobs/domain_delete_confirm_job.rb
+++ b/app/jobs/domain_delete_confirm_job.rb
@ -1,39 +1,11 @@
-class DomainDeleteConfirmJob < Que::Job
-  def run(domain_id, action, initiator = nil)
-    ::PaperTrail.request.whodunnit = "job - #{self.class.name} - #{action} by #{initiator}"
-    # it's recommended to keep transaction against job table as short as possible.
-    ActiveRecord::Base.transaction do
-      domain = Epp::Domain.find(domain_id)
+class DomainDeleteConfirmJob < ApplicationJob
+  queue_as :default

-      case action
-      when RegistrantVerification::CONFIRMED
-        domain.notify_registrar(:poll_pending_delete_confirmed_by_registrant)
-        domain.apply_pending_delete!
-        raise_errors!(domain)
+  def perform(domain_id, action, initiator = nil)
+    domain = Epp::Domain.find(domain_id)

-      when RegistrantVerification::REJECTED
-        domain.statuses.delete(DomainStatus::PENDING_DELETE_CONFIRMATION)
-        domain.notify_registrar(:poll_pending_delete_rejected_by_registrant)
-
-        domain.cancel_pending_delete
-        domain.save(validate: false)
-        raise_errors!(domain)
-
-        if domain.registrant_verification_token.blank?
-          Rails.logger.warn "EMAIL NOT DELIVERED: registrant_verification_token is missing for #{domain.name}"
-        elsif domain.registrant_verification_asked_at.blank?
-          Rails.logger.warn "EMAIL NOT DELIVERED: registrant_verification_asked_at is missing for #{domain.name}"
-        else
-          DomainDeleteMailer.rejected(domain).deliver_now
-        end
-      end
-
-      destroy # it's best to destroy the job in the same transaction
-    end
-  end
-
-
-  def raise_errors!(domain)
-    throw "domain #{domain.name} failed with errors #{domain.errors.full_messages}" if domain.errors.any?
+    Domains::DeleteConfirm::ProcessAction.run(domain: domain,
+                                              action: action,
+                                              initiator: initiator)
  end
 end
--- a/app/jobs/domain_delete_job.rb
+++ b/app/jobs/domain_delete_job.rb
@ -3,15 +3,6 @@ class DomainDeleteJob < Que::Job
  def run(domain_id)
    domain = Domain.find(domain_id)

-    ::PaperTrail.request.whodunnit = "job - #{self.class.name}"
-    WhoisRecord.where(domain_id: domain.id).destroy_all
-
-    domain.destroy
-    bye_bye = domain.versions.last
-    domain.registrar.notifications.create!(
-        text: "#{I18n.t(:domain_deleted)}: #{domain.name}",
-        attached_obj_id: bye_bye.id,
-        attached_obj_type: bye_bye.class.to_s
-    )
+    Domains::Delete::DoDelete.run(domain: domain)
  end
 end
--- a/app/jobs/domain_update_confirm_job.rb
+++ b/app/jobs/domain_update_confirm_job.rb
@ -1,37 +1,10 @@
-class DomainUpdateConfirmJob < Que::Job
-  def run(domain_id, action, initiator = nil)
-    ::PaperTrail.request.whodunnit = "job - #{self.class.name} - #{action} by #{initiator}"
-    # it's recommended to keep transaction against job table as short as possible.
-    ActiveRecord::Base.transaction do
-      domain = Epp::Domain.find(domain_id)
-      domain.is_admin = true
-      case action
-      when RegistrantVerification::CONFIRMED
-        old_registrant = domain.registrant
-        domain.notify_registrar(:poll_pending_update_confirmed_by_registrant)
-        raise_errors!(domain)
+class DomainUpdateConfirmJob < ApplicationJob
+  queue_as :default

-        domain.apply_pending_update!
-        raise_errors!(domain)
-
-        domain.clean_pendings!
-        raise_errors!(domain)
-        RegistrantChange.new(domain: domain, old_registrant: old_registrant).confirm
-      when RegistrantVerification::REJECTED
-        RegistrantChangeMailer.rejected(domain: domain,
-                                        registrar: domain.registrar,
-                                        registrant: domain.registrant).deliver_now
-
-        domain.notify_registrar(:poll_pending_update_rejected_by_registrant)
-
-        domain.preclean_pendings
-        domain.clean_pendings!
-      end
-      destroy # it's best to destroy the job in the same transaction
-    end
-  end
-
-  def raise_errors!(domain)
-    throw "domain #{domain.name} failed with errors #{domain.errors.full_messages}" if domain.errors.any?
+  def perform(domain_id, action, initiator = nil)
+    domain = Epp::Domain.find(domain_id)
+    Domains::UpdateConfirm::ProcessAction.run(domain: domain,
+                                              action: action,
+                                              initiator: initiator)
  end
 end
--- a/app/jobs/update_whois_record_job.rb
+++ b/app/jobs/update_whois_record_job.rb
@ -1,87 +1,5 @@
 class UpdateWhoisRecordJob < Que::Job
-
  def run(names, type)
-    ::PaperTrail.request.whodunnit = "job - #{self.class.name} - #{type}"
-
-    klass = determine_class(type)
-
-    Array(names).each do |name|
-      record = find_record(klass, name)
-      if record
-        send "update_#{type}", record
-      else
-        send "delete_#{type}", name
-      end
-    end
-  end
-
-  def find_record(klass, name)
-    klass == DNS::Zone ? klass.find_by(origin: name) : klass.find_by(name: name)
-  end
-
-  def determine_class(type)
-    case type
-    when 'reserved' then ReservedDomain
-    when 'blocked'  then BlockedDomain
-    when 'domain'   then Domain
-    when 'disputed' then Dispute.active
-    when 'zone'     then DNS::Zone
-    end
-  end
-
-  def update_domain(domain)
-    domain.whois_record ? domain.whois_record.save : domain.create_whois_record
-  end
-
-  def update_reserved(record)
-    record.generate_data
-  end
-
-  def update_blocked(record)
-    update_reserved(record)
-  end
-
-  def update_disputed(record)
-    update_reserved(record)
-  end
-
-  def update_zone(record)
-    update_reserved(record)
-  end
-
-  # 1. deleting own
-  # 2. trying to regenerate reserved in order domain is still in the list
-  def delete_domain(name)
-    WhoisRecord.where(name: name).destroy_all
-
-    BlockedDomain.find_by(name: name).try(:generate_data)
-    ReservedDomain.find_by(name: name).try(:generate_data)
-    Dispute.active.find_by(domain_name: name).try(:generate_data)
-  end
-
-  def delete_reserved(name)
-    remove_status_from_whois(domain_name: name, domain_status: 'Reserved')
-  end
-
-  def delete_blocked(name)
-    delete_reserved(name)
-  end
-
-  def delete_disputed(name)
-    return if Dispute.active.find_by(domain_name: name).present?
-
-    remove_status_from_whois(domain_name: name, domain_status: 'disputed')
-  end
-
-  def delete_zone(name)
-    WhoisRecord.where(name: name).destroy_all
-    Whois::Record.where(name: name).destroy_all
-  end
-
-  def remove_status_from_whois(domain_name:, domain_status:)
-    Whois::Record.where(name: domain_name).each do |r|
-      r.json['status'] = r.json['status'].delete_if { |status| status == domain_status }
-      r.json['status'].blank? ? r.destroy : r.save
-    end
+    Whois::Update.run(names: [names].flatten, type: type)
  end
 end
--- a/app/mailers/application_mailer.rb
+++ b/app/mailers/application_mailer.rb
@ -1,4 +1,15 @@
 class ApplicationMailer < ActionMailer::Base
  append_view_path Rails.root.join('app', 'views', 'mailers')
  layout 'mailer'
-end
+
+  def registrant_confirm_url(domain:, method:)
+    token = domain.registrant_verification_token
+    base_url = ENV['registrant_portal_verifications_base_url']
+
+    url = registrant_domain_delete_confirm_url(domain, token: token) if method == 'delete'
+    url ||= registrant_domain_update_confirm_url(domain, token: token)
+    return url if base_url.blank?
+
+    "#{base_url}/confirmation/#{domain.name_puny}/#{method}/#{token}"
+  end
+end
--- a/app/mailers/domain_delete_mailer.rb
+++ b/app/mailers/domain_delete_mailer.rb
@ -2,7 +2,7 @@ class DomainDeleteMailer < ApplicationMailer
  def confirmation_request(domain:, registrar:, registrant:)
    @domain = DomainPresenter.new(domain: domain, view: view_context)
    @registrar = RegistrarPresenter.new(registrar: registrar, view: view_context)
-    @confirmation_url = confirmation_url(domain)
+    @confirmation_url = registrant_confirm_url(domain: domain, method: 'delete')

    subject = default_i18n_subject(domain_name: domain.name)
    mail(to: registrant.email, subject: subject)
@ -48,10 +48,6 @@ class DomainDeleteMailer < ApplicationMailer

  private

-  def confirmation_url(domain)
-    registrant_domain_delete_confirm_url(domain, token: domain.registrant_verification_token)
-  end
-
  def forced_email_from
    ENV['action_mailer_force_delete_from'] || self.class.default[:from]
  end
--- a/app/mailers/registrant_change_mailer.rb
+++ b/app/mailers/registrant_change_mailer.rb
@ -5,7 +5,7 @@ class RegistrantChangeMailer < ApplicationMailer
    @domain = DomainPresenter.new(domain: domain, view: view_context)
    @registrar = RegistrarPresenter.new(registrar: registrar, view: view_context)
    @new_registrant = RegistrantPresenter.new(registrant: new_registrant, view: view_context)
-    @confirmation_url = confirmation_url(domain)
+    @confirmation_url = registrant_confirm_url(domain: domain, method: 'change')

    subject = default_i18n_subject(domain_name: domain.name)
    mail(to: current_registrant.email, subject: subject)
@ -49,10 +49,6 @@ class RegistrantChangeMailer < ApplicationMailer

  private

-  def confirmation_url(domain)
-    registrant_domain_update_confirm_url(domain, token: domain.registrant_verification_token)
-  end
-
  def address_processing
    Contact.address_processing?
  end
--- a/app/models/ability.rb
+++ b/app/models/ability.rb
@ -109,6 +109,7 @@ class Ability
    can :destroy, :pending
    can :create, :zonefile
    can :access, :settings_menu
+    can :manage, BouncedMailAddress
  end

  def static_registrant
--- a/app/models/actions/contact_create.rb
+++ b/app/models/actions/contact_create.rb
@ -0,0 +1,81 @@
+module Actions
+  class ContactCreate
+    attr_reader :contact, :legal_document, :ident
+
+    def initialize(contact, legal_document, ident)
+      @contact = contact
+      @legal_document = legal_document
+      @ident = ident
+    end
+
+    def call
+      maybe_remove_address
+      maybe_attach_legal_doc
+      validate_ident
+      commit
+    end
+
+    def maybe_remove_address
+      return if Contact.address_processing?
+
+      contact.city = nil
+      contact.zip = nil
+      contact.street = nil
+      contact.state = nil
+      contact.country_code = nil
+    end
+
+    def validate_ident
+      validate_ident_integrity
+      validate_ident_birthday
+
+      identifier = ::Contact::Ident.new(code: ident[:ident], type: ident[:ident_type],
+                                        country_code: ident[:ident_country_code])
+
+      identifier.validate
+      contact.identifier = identifier
+    end
+
+    def validate_ident_integrity
+      return if ident.blank?
+
+      if ident[:ident_type].blank?
+        contact.add_epp_error('2003', nil, 'ident_type',
+                              I18n.t('errors.messages.required_ident_attribute_missing'))
+        @error = true
+      elsif !%w[priv org birthday].include?(ident[:ident_type])
+        contact.add_epp_error('2003', nil, 'ident_type', 'Invalid ident type')
+        @error = true
+      end
+    end
+
+    def validate_ident_birthday
+      return if ident.blank?
+      return unless ident[:ident_type] != 'birthday' && ident[:ident_country_code].blank?
+
+      contact.add_epp_error('2003', nil, 'ident_country_code',
+                            I18n.t('errors.messages.required_ident_attribute_missing'))
+      @error = true
+    end
+
+    def maybe_attach_legal_doc
+      return unless legal_document
+
+      doc = LegalDocument.create(
+        documentable_type: Contact,
+        document_type: legal_document[:type], body: legal_document[:body]
+      )
+
+      contact.legal_documents = [doc]
+      contact.legal_document_id = doc.id
+    end
+
+    def commit
+      contact.id = nil # new record
+      return false if @error
+
+      contact.generate_code
+      contact.save
+    end
+  end
+end
--- a/app/models/actions/contact_delete.rb
+++ b/app/models/actions/contact_delete.rb
@ -0,0 +1,41 @@
+module Actions
+  class ContactDelete
+    attr_reader :contact
+    attr_reader :new_attributes
+    attr_reader :legal_document
+    attr_reader :ident
+    attr_reader :user
+
+    def initialize(contact, legal_document = nil)
+      @legal_document = legal_document
+      @contact = contact
+    end
+
+    def call
+      maybe_attach_legal_doc
+
+      if contact.linked?
+        contact.errors.add(:domains, :exist)
+        return
+      end
+
+      commit
+    end
+
+    def maybe_attach_legal_doc
+      return unless legal_document
+
+      document = contact.legal_documents.create(
+        document_type: legal_document[:type],
+        body: legal_document[:body]
+      )
+
+      contact.legal_document_id = document.id
+      contact.save
+    end
+
+    def commit
+      contact.destroy
+    end
+  end
+end
--- a/app/models/actions/contact_update.rb
+++ b/app/models/actions/contact_update.rb
@ -17,7 +17,7 @@ module Actions
    def call
      maybe_remove_address
      maybe_update_statuses
-      maybe_update_ident
+      maybe_update_ident if ident.present?
      maybe_attach_legal_doc
      commit
    end
@ -53,7 +53,11 @@ module Actions
    end

    def maybe_update_ident
-      return unless ident[:ident]
+      unless ident.is_a?(Hash)
+        contact.add_epp_error('2308', nil, nil, I18n.t('epp.contacts.errors.valid_ident'))
+        @error = true
+        return
+      end

      if contact.identifier.valid?
        submitted_ident = ::Contact::Ident.new(code: ident[:ident],
--- a/app/models/actions/domain_transfer.rb
+++ b/app/models/actions/domain_transfer.rb
@ -0,0 +1,74 @@
+module Actions
+  class DomainTransfer
+    attr_reader :domain
+    attr_reader :transfer_code
+    attr_reader :legal_document
+    attr_reader :ident
+    attr_reader :user
+
+    def initialize(domain, transfer_code, user)
+      @domain = domain
+      @transfer_code = transfer_code
+      @user = user
+    end
+
+    def call
+      return unless domain_exists?
+      return unless valid_transfer_code?
+
+      run_validations
+
+      # return domain.pending_transfer if domain.pending_transfer
+      # attach_legal_document(::Deserializers::Xml::LegalDocument.new(frame).call)
+
+      return if domain.errors[:epp_errors].any?
+
+      commit
+    end
+
+    def domain_exists?
+      return true if domain.persisted?
+
+      domain.add_epp_error('2303', nil, nil, 'Object does not exist')
+
+      false
+    end
+
+    def run_validations
+      validate_registrar
+      validate_eligilibty
+      validate_not_discarded
+    end
+
+    def valid_transfer_code?
+      return true if transfer_code == domain.transfer_code
+
+      domain.add_epp_error('2202', nil, nil, 'Invalid authorization information')
+      false
+    end
+
+    def validate_registrar
+      return unless user == domain.registrar
+
+      domain.add_epp_error('2002', nil, nil,
+                           I18n.t(:domain_already_belongs_to_the_querying_registrar))
+    end
+
+    def validate_eligilibty
+      return unless domain.non_transferable?
+
+      domain.add_epp_error('2304', nil, nil, 'Object status prohibits operation')
+    end
+
+    def validate_not_discarded
+      return unless domain.discarded?
+
+      domain.add_epp_error('2106', nil, nil, 'Object is not eligible for transfer')
+    end
+
+    def commit
+      bare_domain = Domain.find(domain.id)
+      ::DomainTransfer.request(bare_domain, user)
+    end
+  end
+end
--- a/app/models/bounced_mail_address.rb
+++ b/app/models/bounced_mail_address.rb
@ -0,0 +1,28 @@
+class BouncedMailAddress < ApplicationRecord
+  validates :email, :message_id, :bounce_type, :bounce_subtype, :action, :status, presence: true
+
+  def bounce_reason
+    "#{action} (#{status} #{diagnostic})"
+  end
+
+  def self.record(json)
+    bounced_records = json['bounce']['bouncedRecipients']
+    bounced_records.each do |record|
+      bounce_record = BouncedMailAddress.new(params_from_json(json, record))
+
+      bounce_record.save
+    end
+  end
+
+  def self.params_from_json(json, bounced_record)
+    {
+      email: bounced_record['emailAddress'],
+      message_id: json['mail']['messageId'],
+      bounce_type: json['bounce']['bounceType'],
+      bounce_subtype: json['bounce']['bounceSubType'],
+      action: bounced_record['action'],
+      status: bounced_record['status'],
+      diagnostic: bounced_record['diagnosticCode'],
+    }
+  end
+end
--- a/app/models/concerns/domain/deletable.rb
+++ b/app/models/concerns/domain/deletable.rb
@ -20,6 +20,6 @@ module Concerns::Domain::Deletable
  end

  def deletion_deadline
-    delete_date + 24.hours
+    (delete_date || Time.zone.now) + 24.hours
  end
-end
+end
--- a/app/models/concerns/domain/force_delete.rb
+++ b/app/models/concerns/domain/force_delete.rb
@ -33,70 +33,14 @@ module Concerns::Domain::ForceDelete # rubocop:disable Metrics/ModuleLength
    statuses.include?(DomainStatus::FORCE_DELETE)
  end

-  def should_notify_on_soft_force_delete?
-    force_delete_scheduled? && contact_notification_sent_date.blank? &&
-      force_delete_start.to_date <= Time.zone.now.to_date && force_delete_type.to_sym == :soft &&
-      !statuses.include?(DomainStatus::CLIENT_HOLD)
-  end
-
-  def client_holdable?
-    force_delete_scheduled? && !statuses.include?(DomainStatus::CLIENT_HOLD) &&
-      force_delete_start.present? && force_delete_lte_today && force_delete_lte_valid_date
-  end
-
-  def force_delete_lte_today
-    force_delete_start + Setting.expire_warning_period.days <= Time.zone.now
-  end
-
-  def force_delete_lte_valid_date
-    force_delete_start + Setting.expire_warning_period.days <= valid_to
-  end
-
-  def schedule_force_delete(type: :fast_track)
-    if discarded?
-      raise StandardError, 'Force delete procedure cannot be scheduled while a domain is discarded'
-    end
-
-    type == :fast_track ? force_delete_fast_track : force_delete_soft
-  end
-
-  def add_force_delete_type(force_delete_type)
-    self.force_delete_type = force_delete_type
-  end
-
-  def force_delete_fast_track
-    preserve_current_statuses_for_force_delete
-    add_force_delete_statuses
-    add_force_delete_type(:fast)
-    self.force_delete_date = force_delete_fast_track_start_date + 1.day
-    self.force_delete_start = Time.zone.today + 1.day
-    stop_all_pending_actions
-    allow_deletion
-    save(validate: false)
-  end
-
-  def force_delete_soft
-    preserve_current_statuses_for_force_delete
-    add_force_delete_statuses
-    add_force_delete_type(:soft)
-    calculate_soft_delete_date
-    stop_all_pending_actions
-    allow_deletion
-    save(validate: false)
-  end
-
-  def clear_force_delete_data
-    self.force_delete_data = nil
+  def schedule_force_delete(type: :fast_track, notify_by_email: false)
+    Domains::ForceDelete::SetForceDelete.run(domain: self,
+                                             type: type,
+                                             notify_by_email: notify_by_email)
  end

  def cancel_force_delete
-    remove_force_delete_statuses
-    restore_statuses_before_force_delete
-    clear_force_delete_data
-    self.force_delete_date = nil
-    self.force_delete_start = nil
-    save(validate: false)
-    registrar.notifications.create!(text: I18n.t('force_delete_cancelled', domain_name: name))
+    Domains::CancelForceDelete::CancelForceDelete.run(domain: self)
  end

  def outzone_date
@ -107,55 +51,4 @@ module Concerns::Domain::ForceDelete # rubocop:disable Metrics/ModuleLength
    (force_delete_date&.beginning_of_day || valid_to + Setting.expire_warning_period.days +
      Setting.redemption_grace_period.days)
  end
-
-  private
-
-  def calculate_soft_delete_date
-    years = (valid_to.to_date - Time.zone.today).to_i / 365
-    soft_delete_dates(years) if years.positive?
-  end
-
-  def soft_delete_dates(years)
-    self.force_delete_start = valid_to - years.years
-    self.force_delete_date = force_delete_start + Setting.expire_warning_period.days +
-                             Setting.redemption_grace_period.days
-  end
-
-  def stop_all_pending_actions
-    statuses.delete(DomainStatus::PENDING_UPDATE)
-    statuses.delete(DomainStatus::PENDING_TRANSFER)
-    statuses.delete(DomainStatus::PENDING_RENEW)
-    statuses.delete(DomainStatus::PENDING_CREATE)
-  end
-
-  def preserve_current_statuses_for_force_delete
-    update(statuses_before_force_delete: statuses)
-  end
-
-  def restore_statuses_before_force_delete
-    self.statuses = statuses_before_force_delete
-    self.statuses_before_force_delete = nil
-  end
-
-  def add_force_delete_statuses
-    self.statuses |= [DomainStatus::FORCE_DELETE,
-                      DomainStatus::SERVER_RENEW_PROHIBITED,
-                      DomainStatus::SERVER_TRANSFER_PROHIBITED]
-  end
-
-  def remove_force_delete_statuses
-    statuses.delete(DomainStatus::FORCE_DELETE)
-    statuses.delete(DomainStatus::SERVER_RENEW_PROHIBITED)
-    statuses.delete(DomainStatus::SERVER_TRANSFER_PROHIBITED)
-    statuses.delete(DomainStatus::CLIENT_HOLD)
-  end
-
-  def allow_deletion
-    statuses.delete(DomainStatus::CLIENT_DELETE_PROHIBITED)
-    statuses.delete(DomainStatus::SERVER_DELETE_PROHIBITED)
-  end
-
-  def force_delete_fast_track_start_date
-    Time.zone.today + Setting.expire_warning_period.days + Setting.redemption_grace_period.days
-  end
 end
--- a/app/models/concerns/job/force_delete.rb
+++ b/app/models/concerns/job/force_delete.rb
@ -1,34 +0,0 @@
-module Concerns
-  module Job
-    module ForceDelete
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def start_client_hold
-          log_prepare_client_hold
-
-          ::PaperTrail.request.whodunnit = "cron - #{__method__}"
-
-          ::Domain.force_delete_scheduled.each do |domain|
-            proceed_client_hold(domain: domain)
-          end
-
-          log_end_end_force_delete_job
-        end
-
-        def proceed_client_hold(domain:)
-          notify_on_grace_period(domain) if domain.should_notify_on_soft_force_delete?
-          return unless domain.client_holdable?
-
-          domain.statuses << DomainStatus::CLIENT_HOLD
-          log_start_client_hold(domain)
-
-          domain.save(validate: false)
-          notify_client_hold(domain)
-
-          log_end_end_client_hold(domain)
-        end
-      end
-    end
-  end
-end
--- a/app/models/concerns/job/force_delete_logging.rb
+++ b/app/models/concerns/job/force_delete_logging.rb
@ -1,34 +0,0 @@
-module Concerns
-  module Job
-    module ForceDeleteLogging
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def log_prepare_client_hold
-          return if Rails.env.test?
-
-          STDOUT << "#{Time.zone.now.utc} - Setting client_hold to domains\n"
-        end
-
-        def log_start_client_hold(domain)
-          return if Rails.env.test?
-
-          STDOUT << "#{Time.zone.now.utc} DomainCron.start_client_hold: ##{domain.id} "\
-                    "(#{domain.name}) #{domain.changes}\n"
-        end
-
-        def log_end_end_client_hold(domain)
-          return if Rails.env.test?
-
-          STDOUT << "#{Time.zone.now.utc} - Successfully set client_hold on (#{domain.name})"
-        end
-
-        def log_end_end_force_delete_job
-          return if Rails.env.test?
-
-          STDOUT << "#{Time.zone.now.utc} - All client_hold setting are done\n"
-        end
-      end
-    end
-  end
-end
--- a/Show more
+++ b/Show more