uffizzi_core 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fa1762e392d1748e189b83b1b546d4b6005034de25e15a00189f683d65764fa
-  data.tar.gz: 7f361a77ac67122c8bdebf1112c4b5f7a4f541e3c55ac5f75568ffbaa0e48c20
+  metadata.gz: 49bbe08dfa41ecd2c4c9b6d2f488334db9ba40ec952b2a249d55e3be08b819aa
+  data.tar.gz: 37a606bcb357ef8b4b072b8be528c08a47569d8da3e3cf0fed00ec1aff110648
 SHA512:
-  metadata.gz: 49a8755ddc0743460d1b0f52d787f4c6fe17a68291eabcd20efdd1661007750fdfdf4a336665b97c86500fc5c5f03c44eda25ed9ec9166d6c608be9298c30465
-  data.tar.gz: 9132eb4e35621f7a45e0a41833448c329a320d10651a000e285edda8c96c06c3f5366f6658a83f527e941af3398c652b0ce66ebc1ef058df2b6d90f03b370dca
+  metadata.gz: 0fcd5124498ab741cb1d03cada959eb0b821f15f8aede73f225ac0ac3a983b8deafecbe7a5905e8256c5b6f6c370348a4d85d6701b718b07bf9f56de2aea0fb2
+  data.tar.gz: 007c508efa144dfa7d617e36f12c00e3895cc871c9dc6cdfb00e4affd19eac3fc9ef4112898e7acf513408cae6077ff1e0bd5c2c8ffa1c71375c950c085be28e

data/app/clients/uffizzi_core/docker_hub_client.rb

@@ -19,6 +19,8 @@ class UffizziCore::DockerHubClient
     response = connection.post(url, params)
     request_result = RequestResult.new(result: response.body)
     request_result.result.token
+  rescue NoMethodError
+    nil
   end
 
   def public_images(q:, page: 1, per_page: 25)

data/app/clients/uffizzi_core/github_container_registry_client/request_result.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::GithubContainerRegistryClient
+  class RequestResult < Hashie::Mash
+    disable_warnings :key
+  end
+end

data/app/clients/uffizzi_core/github_container_registry_client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class UffizziCore::GithubContainerRegistryClient
+  attr_accessor :token, :registry_url
+
+  def initialize(registry_url:, username:, password:)
+    @registry_url = registry_url
+    @username = username
+    @password = password
+    @token = access_token&.result&.token
+  end
+
+  def access_token
+    service = URI.parse(registry_url).hostname
+    url = "/token?service=#{service}"
+
+    response = connection.get(url, {})
+
+    RequestResult.new(result: response.body)
+  end
+
+  def authentificated?
+    token.present?
+  end
+
+  def manifests(image:, tag:)
+    url = "/v2/#{@username}/#{image}/manifests/#{tag}"
+    response = token_connection.get(url)
+
+    RequestResult.quiet.new(result: response.body, headers: response.headers)
+  end
+
+  private
+
+  def connection
+    Faraday.new(registry_url) do |conn|
+      conn.request(:basic_auth, @username, @password)
+      conn.request(:json)
+      conn.response(:json)
+      conn.adapter(Faraday.default_adapter)
+    end
+  end
+
+  def token_connection
+    Faraday.new(registry_url) do |conn|
+      conn.request(:authorization, 'Bearer', token)
+      conn.request(:json)
+      conn.response(:json)
+      conn.adapter(Faraday.default_adapter)
+    end
+  end
+end

data/app/controllers/concerns/uffizzi_core/dependency_injection_concern.rb

@@ -4,7 +4,7 @@ module UffizziCore::DependencyInjectionConcern
   def user_access_module
     return unless module_exists?(:rbac)
 
-    UffizziCore::UserAccessService.new(module_class(:rbac))
+    module_class(:rbac).new
   end
 
   private
@@ -14,6 +14,6 @@ module UffizziCore::DependencyInjectionConcern
   end
 
   def module_class(module_name)
-    UffizziCore.dependencies[module_name]&.constantize
+    Rails.application.config.uffizzi_core[:dependencies][module_name]&.constantize
   end
 end

data/app/controllers/uffizzi_core/api/cli/v1/account/credentials_controller.rb

@@ -4,6 +4,17 @@
 class UffizziCore::Api::Cli::V1::Account::CredentialsController < UffizziCore::Api::Cli::V1::Account::ApplicationController
   before_action :authorize_uffizzi_core_api_cli_v1_account_credentials
 
+  # Get a list of accounts credential
+  #
+  # @path [GET] /api/cli/v1/account/credentials
+  #
+  # @parameter credential(required,body) [object<username:string, password: string, type:string>]
+  def index
+    credentials = resource_account.credentials.pluck(:type)
+
+    render json: { credentials: credentials }, status: :ok
+  end
+
   # rubocop:disable Layout/LineLength
   # Create account credential
   #
@@ -14,26 +25,39 @@ class UffizziCore::Api::Cli::V1::Account::CredentialsController < UffizziCore::A
   # @response [object<errors>] 422 Unprocessable entity
   #
   # @example
-  #    type can be one of UffizziCore::Credential::Amazon, UffizziCore::Credential::Azure, UffizziCore::Credential::DockerHub, UffizziCore::Credential::Google
+  #    type can be one of UffizziCore::Credential::Amazon, UffizziCore::Credential::Azure, UffizziCore::Credential::DockerHub, UffizziCore::Credential::Google, UffizziCore::Credential::GithubContainerRegistry
   # rubocop:enable Layout/LineLength
   def create
     credential_form = UffizziCore::Api::Cli::V1::Account::Credential::CreateForm.new
     credential_form.assign_attributes(credential_params)
     credential_form.account = resource_account
-    credential_form.registry_url = Settings.docker_hub.registry_url if credential_form.docker_hub?
-    if credential_form.google?
-      credential_form.registry_url = Settings.google.registry_url
-      credential_form.username = '_json_key'
-    end
+    credential_form.registry_url = registry_url(credential_form)
+    credential_form.username = '_json_key' if credential_form.google?
     credential_form.activate
 
-    if credential_form.save
-      UffizziCore::Account::CreateCredentialJob.perform_async(credential_form.id)
-    end
+    UffizziCore::Account::CreateCredentialJob.perform_async(credential_form.id) if credential_form.save
 
     respond_with credential_form
   end
 
+  # Check if credential of the type already exists in the account
+  #
+  # @path [GET] /api/cli/v1/account/credentials/{type}/check_credential
+  #
+  # @parameter credential(required,body) [object<type:string>]
+  # @response 422 Unprocessable entity
+  # @response 200 OK
+  def check_credential
+    credential_form = UffizziCore::Api::Cli::V1::Account::Credential::CheckCredentialForm.new
+    credential_form.type = params[:type]
+    credential_form.account = resource_account
+    if credential_form.valid?
+      respond_with credential_form
+    else
+      respond_with credential_form.errors, status: :unprocessable_entity
+    end
+  end
+
   # Delete account credential
   #
   # @path [DELETE] /api/cli/v1/account/credentials/{type}
@@ -52,4 +76,16 @@ class UffizziCore::Api::Cli::V1::Account::CredentialsController < UffizziCore::A
   def credential_params
     params.require(:credential)
   end
+
+  def registry_url(credential_form)
+    if credential_form.docker_hub?
+      Settings.docker_hub.registry_url
+    elsif credential_form.google?
+      Settings.google.registry_url
+    elsif credential_form.github_container_registry?
+      Settings.github_container_registry.registry_url
+    else
+      credential_form.registry_url
+    end
+  end
 end

data/app/controllers/uffizzi_core/api/cli/v1/projects/compose_files_controller.rb

@@ -78,10 +78,10 @@ class UffizziCore::Api::Cli::V1::Projects::ComposeFilesController < UffizziCore:
   def create_or_update_compose_file(params)
     existing_compose_file = resource_project.compose_file
     if existing_compose_file.present?
-      UffizziCore::Cli::ComposeFileService.update(existing_compose_file, params)
+      UffizziCore::ComposeFileService.update(existing_compose_file, params)
     else
       kind = UffizziCore::ComposeFile.kind.main
-      UffizziCore::Cli::ComposeFileService.create(params, kind)
+      UffizziCore::ComposeFileService.create(params, kind)
     end
   end
 

data/app/controllers/uffizzi_core/api/cli/v1/projects/deployments/application_controller.rb

@@ -2,6 +2,6 @@
 
 class UffizziCore::Api::Cli::V1::Projects::Deployments::ApplicationController < UffizziCore::Api::Cli::V1::Projects::ApplicationController
   def resource_deployment
-    @resource_deployment ||= resource_project.deployments.find(params[:deployment_id])
+    @resource_deployment ||= resource_project.deployments.active.find(params[:deployment_id])
   end
 end

data/app/controllers/uffizzi_core/api/cli/v1/projects/deployments_controller.rb

@@ -56,6 +56,33 @@ class UffizziCore::Api::Cli::V1::Projects::DeploymentsController < UffizziCore::
     respond_with deployment
   end
 
+  # Update the deployment with new compose file
+  #
+  # @path [PUT] /api/cli/v1/projects/{project_slug}/deployments/{id}"
+  #
+  # @parameter project_slug(required,path) [string] The project slug
+  # @parameter params(required,body)   [object<
+  #    compose_file: object<path: string, source: string, content: string>,
+  #    dependencies: Array<object<path: string, source: string, content: string>>>]
+  #
+  # @response [Deployment] 201 OK
+  # @response [object<errors: object<state: string>>] 422 Unprocessable Entity
+  # @response [object<errors: object<title: string>>] 404 Not found
+  # @response 401 Not authorized
+  def update
+    compose_file, errors = create_temporary_compose_file
+    return render_invalid_file if compose_file.invalid_file?
+    return render_errors(errors) if errors.present?
+
+    errors = check_credentials(compose_file)
+    return render_errors(errors) if errors.present?
+
+    deployment_id = params[:id]
+    deployment = UffizziCore::DeploymentService.update_from_compose(compose_file, resource_project, current_user, deployment_id)
+
+    respond_with deployment
+  end
+
   # @path [POST] /api/cli/v1/projects/{project_slug}/deployments/{id}/deploy_containers
   #
   # @parameter project_slug(required,path) [string] The project slug
@@ -99,15 +126,7 @@ class UffizziCore::Api::Cli::V1::Projects::DeploymentsController < UffizziCore::
   def find_or_create_compose_file
     existing_compose_file = resource_project.compose_file
     if compose_file_params.present?
-      create_params = {
-        project: resource_project,
-        user: current_user,
-        compose_file_params: compose_file_params,
-        dependencies: dependencies_params[:dependencies] || [],
-      }
-
-      kind = UffizziCore::ComposeFile.kind.temporary
-      UffizziCore::Cli::ComposeFileService.create(create_params, kind)
+      create_temporary_compose_file
     else
       raise ActiveRecord::RecordNotFound if existing_compose_file.blank?
 
@@ -116,6 +135,18 @@ class UffizziCore::Api::Cli::V1::Projects::DeploymentsController < UffizziCore::
     end
   end
 
+  def create_temporary_compose_file
+    create_params = {
+      project: resource_project,
+      user: current_user,
+      compose_file_params: compose_file_params,
+      dependencies: dependencies_params[:dependencies] || [],
+    }
+
+    kind = UffizziCore::ComposeFile.kind.temporary
+    UffizziCore::ComposeFileService.create(create_params, kind)
+  end
+
   def check_credentials(compose_file)
     credentials = resource_project.account.credentials
     check_credentials_form = UffizziCore::Api::Cli::V1::ComposeFile::CheckCredentialsForm.new
@@ -127,7 +158,7 @@ class UffizziCore::Api::Cli::V1::Projects::DeploymentsController < UffizziCore::
   end
 
   def deployments
-    @deployments ||= resource_project.deployments.active
+    @deployments ||= resource_project.deployments.existed
   end
 
   def deployment_params

data/app/controllers/uffizzi_core/api/cli/v1/projects/secrets_controller.rb

@@ -8,13 +8,10 @@ class UffizziCore::Api::Cli::V1::Projects::SecretsController < UffizziCore::Api:
   #
   # @path [GET] /api/cli/v1/projects/{project_slug}/secrets
   # @parameter project_slug(required,path) [string]
-  # @response [object<secrets: Array<object<name: string>> >] 200 OK
+  # @response [object<secrets: Array<object<name: string, created_at: date, updated_at: date>>>] 200 OK
   # @response 401 Not authorized
   def index
-    project_secrets = resource_project.secrets.present? ? resource_project.secrets : []
-    secrets = project_secrets.map { |secret| { name: secret['name'] } }
-
-    render json: { secrets: secrets }, status: :ok
+    respond_with resource_project.secrets, root: :secrets
   end
 
   # Add secret to project
@@ -22,43 +19,38 @@ class UffizziCore::Api::Cli::V1::Projects::SecretsController < UffizziCore::Api:
   # @path [POST] /api/cli/v1/projects/{project_slug}/secrets/bulk_create
   # @parameter project_slug(required,path) [string]
   # @parameter secrets(required,body) [object<secrets: Array<object <name: string, value: string>>>]
-  # @response [object<secrets: Array<object<name: string>>>] 201 Created
+  # @response [object<secrets: Array<object<name: string, created_at: date, updated_at: date>>>] 201 Created
   # @response 422 A compose file already exists for this project
   # @response 401 Not authorized
   def bulk_create
-    project_form = resource_project.becomes(UffizziCore::Api::Cli::V1::Project::UpdateForm)
-    project_form.assign_secrets!(secrets_params)
-    return render json: { errors: project_form.errors }, status: :unprocessable_entity unless project_form.save
+    secrets_form = UffizziCore::Api::Cli::V1::Secret::BulkAssignForm.new
+    secrets_form.secrets = resource_project.secrets
+    secrets_form.assign_secrets(secrets_params)
+    return respond_with secrets_form unless secrets_form.valid?
+
+    resource_project.secrets.replace(secrets_form.secrets)
 
-    UffizziCore::ProjectService.update_compose_secrets(project_form)
-    secrets = project_form.secrets.map { |secret| { name: secret['name'] } }
+    UffizziCore::ProjectService.update_compose_secrets(resource_project)
 
-    render json: { secrets: secrets }, status: :created
+    respond_with resource_project.secrets, root: :secrets
   end
 
-  # Delete a secret from project by secret id
+  # Delete a secret from project by secret name
   #
-  # @path [DELETE] /api/cli/v1/projects/{project_slug}/secrets/{id}
+  # @path [DELETE] /api/cli/v1/projects/{project_slug}/secrets/{secret_name}
   # @parameter project_slug(required,path) [string]
   # @response [Project] 200 OK
-  # @response 422
+  # @response 404
   # @response 401 Not authorized
   def destroy
     secret_name = CGI.unescape(params[:id])
-    secret = OpenStruct.new(name: secret_name)
-    project_form = resource_project.becomes(UffizziCore::Api::Cli::V1::Project::DeleteSecretForm)
-    project_form.secret = secret
+    secret = resource_project.secrets.find_by!(name: secret_name)
 
-    if project_form.invalid?
-      return respond_with project_form
-    end
+    UffizziCore::ProjectService.update_compose_secret_errors(resource_project, secret)
 
-    project_form.delete_secret!
-    if project_form.save!(validate: false)
-      UffizziCore::ProjectService.update_compose_secret_errors(project_form, secret)
-    end
+    secret.destroy
 
-    respond_with project_form
+    head :no_content
   end
 
   private

data/app/controllers/uffizzi_core/application_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class UffizziCore::ApplicationController < ActionController::Base
-  include Pundit
+  include Pundit::Authorization
   include UffizziCore::ResponseService
   include UffizziCore::AuthManagement
   include UffizziCore::AuthorizationConcern
@@ -12,11 +12,13 @@ class UffizziCore::ApplicationController < ActionController::Base
 
   protect_from_forgery with: :exception
   rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+  RESCUABLE_EXCEPTIONS = [RuntimeError, TypeError, NameError, ArgumentError, SyntaxError].freeze
+  rescue_from *RESCUABLE_EXCEPTIONS do |exception|
+    render_server_error(exception)
+  end
 
   before_action :authenticate_request!
   skip_before_action :verify_authenticity_token
-  rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
-
   respond_to :json
 
   def policy_context
@@ -31,6 +33,10 @@ class UffizziCore::ApplicationController < ActionController::Base
     render json: { errors: { title: ['Resource Not Found'] } }, status: :not_found
   end
 
+  def render_server_error(error)
+    render json: { errors: { title: [error] } }, status: :internal_server_error
+  end
+
   def render_errors(errors)
     json = { errors: errors }
 

data/app/errors/uffizzi_core/deployment/image_pull_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::ImagePullError < StandardError
+  attr_reader :deployment_id
+
+  def initialize(deployment_id)
+    super
+    @deployment_id = deployment_id
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/account/credential/check_credential_form.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Account::Credential::CheckCredentialForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+
+  attribute :type
+  attribute :account
+
+  validate :credential_exists?
+
+  private
+
+  def credential_exists?
+    errors.add(:type, 'Credential of that type already exist.') if account.credentials.by_type(type).exists?
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/account/credential/create_form.rb

@@ -21,6 +21,6 @@ class UffizziCore::Api::Cli::V1::Account::Credential::CreateForm < UffizziCore::
   end
 
   def credential_exists?
-    errors.add(:type, :exist) if account.credentials.where(type: type).exists?
+    errors.add(:type, :exist) if account.credentials.by_type(type).exists?
   end
 end

data/app/forms/uffizzi_core/api/cli/v1/compose_file/check_credentials_form.rb

@@ -12,9 +12,9 @@ class UffizziCore::Api::Cli::V1::ComposeFile::CheckCredentialsForm
 
   def check_containers_credentials
     compose_content = Base64.decode64(compose_file.content)
-    compose_data = UffizziCore::Cli::ComposeFileService.parse(compose_content)
+    compose_data = UffizziCore::ComposeFileService.parse(compose_content)
 
-    UffizziCore::Cli::ComposeFileService.containers_credentials(compose_data, credentials)
+    UffizziCore::ComposeFileService.containers_credentials(compose_data, credentials)
   rescue UffizziCore::ComposeFile::CredentialError => e
     errors.add(:credentials, e.message)
   end

data/app/forms/uffizzi_core/api/cli/v1/compose_file/cli_form.rb

@@ -3,7 +3,6 @@
 class UffizziCore::Api::Cli::V1::ComposeFile::CliForm
   include UffizziCore::ApplicationFormWithoutActiveRecord
 
-  attribute :credential, UffizziCore::Credential
   attribute :compose_content_data, Hash
   attribute :compose_data, Hash
   attribute :compose_dependencies, Array
@@ -13,27 +12,11 @@ class UffizziCore::Api::Cli::V1::ComposeFile::CliForm
   validates :content, presence: true
 
   validate :check_compose_parsed_data, if: -> { errors[:content].empty? }
-  validate :check_repositories, if: -> { credential.present? && errors[:content].empty? }
-  validate :check_branches, if: -> { credential.present? && errors[:content].empty? }
 
   def check_compose_parsed_data
     compose_content = Base64.decode64(content)
-    self.compose_data = UffizziCore::Cli::ComposeFileService.parse(compose_content)
+    self.compose_data = UffizziCore::ComposeFileService.parse(compose_content)
   rescue UffizziCore::ComposeFile::ParseError => e
     errors.add(:content, e.message)
   end
-
-  def check_repositories
-    self.compose_repositories = UffizziCore::Cli::ComposeFileService.load_repositories(compose_data, credential)
-  rescue UffizziCore::ComposeFile::NotFoundError => e
-    errors.add(:content, e.message)
-  end
-
-  def check_branches
-    return if compose_repositories.blank?
-
-    UffizziCore::Cli::ComposeFileService.check_github_branches(compose_data, compose_repositories, credential)
-  rescue UffizziCore::ComposeFile::NotFoundError => e
-    errors.add(:content, e.message)
-  end
 end

data/app/forms/uffizzi_core/api/cli/v1/compose_file/template_form.rb

@@ -19,7 +19,7 @@ class UffizziCore::Api::Cli::V1::ComposeFile::TemplateForm
   validate :check_template_attributes
 
   def assign_template_attributes!
-    self.template_attributes = UffizziCore::Cli::ComposeFileService.build_template_attributes(
+    self.template_attributes = UffizziCore::ComposeFileService.build_template_attributes(
       compose_data,
       source,
       credentials,

data/app/forms/uffizzi_core/api/cli/v1/deployment/update_form.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Deployment::UpdateForm < UffizziCore::Deployment
+  include UffizziCore::ApplicationForm
+
+  permit containers_attributes: [
+    :image,
+    :name,
+    :tag,
+    :port,
+    :public,
+    :memory_limit,
+    :memory_request,
+    :entrypoint,
+    :command,
+    :receive_incoming_requests,
+    :continuously_deploy,
+    { variables: [:name, :value],
+      secret_variables: [:name, :value],
+      repo_attributes: [
+        :namespace,
+        :name,
+        :slug,
+        :type,
+        :description,
+        :is_private,
+        :repository_id,
+        :branch,
+        :kind,
+        :dockerfile_path,
+        :dockerfile_context_path,
+        :deploy_preview_when_pull_request_is_opened,
+        :delete_preview_when_pull_request_is_closed,
+        :deploy_preview_when_image_tag_is_created,
+        :delete_preview_when_image_tag_is_updated,
+        :share_to_github,
+        :delete_preview_after,
+        { args: [:name, :value] },
+      ],
+      container_config_files_attributes: [
+        :config_file_id,
+        :mount_path,
+      ] },
+  ]
+
+  validate :check_all_containers_have_unique_ports
+  validate :check_exists_ingress_container
+  validate :check_max_memory_limit
+  validate :check_max_memory_request
+
+  def assign_dependences!(project, user)
+    self.project = project
+
+    self.containers = containers.map do |container|
+      container.repo.project = project if !container.repo.nil?
+
+      container
+    end
+
+    self.deployed_by = user
+
+    self
+  end
+
+  private
+
+  def check_all_containers_have_unique_ports
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :duplicate_ports) unless UffizziCore::DeploymentService.all_containers_have_unique_ports?(active_containers)
+  end
+
+  def check_exists_ingress_container
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :incorrect_ingress_container) unless UffizziCore::DeploymentService.ingress_container?(active_containers)
+  end
+
+  def check_max_memory_limit
+    return if UffizziCore::DeploymentService.valid_containers_memory_limit?(self)
+
+    errors.add(:containers, :max_memory_limit_error, max: project.account.container_memory_limit)
+  end
+
+  def check_max_memory_request
+    return if UffizziCore::DeploymentService.valid_containers_memory_request?(self)
+
+    errors.add(:containers, :max_memory_request_error, max: project.account.container_memory_limit)
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/project/update_form.rb

@@ -2,39 +2,9 @@
 
 class UffizziCore::Api::Cli::V1::Project::UpdateForm < UffizziCore::Project
   include UffizziCore::ApplicationForm
-  MAX_SECRET_KEY_LENGTH = 256
 
-  permit :name, :slug, :description, secrets: [:name, :value]
+  permit :name, :slug, :description
 
   validates :name, presence: true, uniqueness: { scope: :account }
   validates :slug, presence: true, uniqueness: true
-
-  validate :check_duplicates
-  validate :check_length
-
-  def assign_secrets!(new_secrets)
-    existing_secrets = secrets.presence || []
-
-    self.secrets = existing_secrets.union(new_secrets)
-  end
-
-  private
-
-  def check_duplicates
-    duplicates = []
-    groupped_secrets = secrets.group_by { |secret| secret['name'] }
-    groupped_secrets.each_pair do |key, value|
-      duplicates << key if value.size > 1
-    end
-
-    error_message = I18n.t('secrets.duplicates_exists', secrets: duplicates.join(', '))
-    errors.add(:secrets, error_message) if duplicates.present?
-  end
-
-  def check_length
-    secrets_with_invalid_key_length = secrets.select { |secret| secret['name'].length > MAX_SECRET_KEY_LENGTH }
-
-    error_message = I18n.t('secrets.invalid_key_length')
-    errors.add(:secrets, error_message) if secrets_with_invalid_key_length.present?
-  end
 end

data/app/forms/uffizzi_core/api/cli/v1/secret/bulk_assign_form.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Secret::BulkAssignForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+  MAX_SECRET_KEY_LENGTH = 256
+
+  attribute :secrets, Array
+  validate :check_duplicates
+  validate :check_length
+
+  def assign_secrets(new_secrets)
+    return if new_secrets.blank?
+
+    new_secrets.each do |new_secret|
+      secret = UffizziCore::Secret.new(name: new_secret['name'], value: new_secret['value'])
+      secrets.append(secret)
+    end
+  end
+
+  private
+
+  def check_duplicates
+    duplicates = []
+    groupped_secrets = secrets.group_by { |secret| secret['name'] }
+    groupped_secrets.each_pair do |key, value|
+      duplicates << key if value.size > 1
+    end
+
+    error_message = I18n.t('secrets.duplicates_exists', secrets: duplicates.join(', '))
+    errors.add(:secrets, error_message) if duplicates.present?
+  end
+
+  def check_length
+    secrets_with_invalid_key_length = secrets.select { |secret| secret['name'].length > MAX_SECRET_KEY_LENGTH }
+
+    error_message = I18n.t('secrets.invalid_key_length')
+    errors.add(:secrets, error_message) if secrets_with_invalid_key_length.present?
+  end
+end