uffizzi_core 0.1.3

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# @resource Project/Secrets
+class UffizziCore::Api::Cli::V1::Projects::SecretsController < UffizziCore::Api::Cli::V1::Projects::ApplicationController
+  before_action :authorize_uffizzi_core_api_cli_v1_projects_secrets
+
+  # Get secrets for the project
+  #
+  # @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 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
+  end
+
+  # Add secret to project
+  #
+  # @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 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
+
+    UffizziCore::ProjectService.update_compose_secrets(project_form)
+    secrets = project_form.secrets.map { |secret| { name: secret['name'] } }
+
+    render json: { secrets: secrets }, status: :created
+  end
+
+  # Delete a secret from project by secret id
+  #
+  # @path [DELETE] /api/cli/v1/projects/{project_slug}/secrets/{id}
+  # @parameter project_slug(required,path) [string]
+  # @response [Project] 200 OK
+  # @response 422
+  # @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
+
+    if project_form.invalid?
+      return respond_with project_form
+    end
+
+    project_form.delete_secret!
+    if project_form.save!(validate: false)
+      UffizziCore::ProjectService.update_compose_secret_errors(project_form, secret)
+    end
+
+    respond_with project_form
+  end
+
+  private
+
+  def secrets_params
+    params.require(:secrets)
+  end
+end

data/app/controllers/uffizzi_core/api/cli/v1/projects_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# @resource Project
+
+class UffizziCore::Api::Cli::V1::ProjectsController < UffizziCore::Api::Cli::V1::ApplicationController
+  before_action :authorize_uffizzi_core_api_cli_v1_projects
+
+  # Get projects of current user
+  #
+  # @path [GET] /api/cli/v1/projects
+  #
+  # @response [object<projects: Array<object<slug: string>> >] 200 OK
+  # @response 401 Not authorized
+  def index
+    projects = current_user.projects.active.order(updated_at: :desc)
+
+    respond_with projects
+  end
+end

data/app/controllers/uffizzi_core/api/cli/v1/sessions_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# @resource Uffizzi
+
+class UffizziCore::Api::Cli::V1::SessionsController < UffizziCore::Api::Cli::V1::ApplicationController
+  skip_before_action :authenticate_request!, only: [:create]
+
+  # Create session
+  #
+  # @path [POST] /api/cli/v1/session
+  #
+  # @parameter user(required,body)   [object<email: string, password: string >]
+  # @response [object<user: object<accounts: Array<object<id: integer, state: string>> >>] 201 Created successfully
+  # @response [object<errors: object<password: string >>] 422 Unprocessable entity
+  def create
+    session_form = UffizziCore::Api::Cli::V1::SessionCreateForm.new(session_params)
+
+    if session_form.valid?
+      sign_in(session_form.user)
+
+      return respond_with session_form.user
+    end
+
+    respond_with session_form
+  end
+
+  # Destroy session
+  #
+  # @path [DELETE] /api/cli/v1/session
+  #
+  # @response 204 No Content
+  def destroy
+    sign_out
+
+    head :no_content
+  end
+
+  private
+
+  def session_params
+    params.require(:user).permit(:email, :password)
+  end
+end

data/app/controllers/uffizzi_core/application_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class UffizziCore::ApplicationController < ActionController::Base
+  include Pundit
+  include UffizziCore::ResponseService
+  include UffizziCore::AuthManagement
+  include UffizziCore::AuthorizationConcern
+  include UffizziCore::DependencyInjectionConcern
+
+  DEFAULT_PAGE = 1
+  DEFAULT_PER_PAGE = 20
+
+  protect_from_forgery with: :exception
+  rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+  before_action :authenticate_request!
+  skip_before_action :verify_authenticity_token
+  rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+  respond_to :json
+
+  def policy_context
+    UffizziCore::BaseContext.new(current_user, user_access_module, params)
+  end
+
+  def self.responder
+    UffizziCore::JsonResponder
+  end
+
+  def render_not_found
+    render json: { errors: { title: ['Resource Not Found'] } }, status: :not_found
+  end
+
+  def render_errors(errors)
+    json = { errors: errors }
+
+    render json: json, status: :unprocessable_entity
+  end
+
+  def q_param
+    params[:q] || ActionController::Parameters.new
+  end
+
+  def page
+    params[:page] || DEFAULT_PAGE
+  end
+
+  def per_page
+    params[:per_page] || DEFAULT_PER_PAGE
+  end
+end

data/app/errors/uffizzi_core/compose_file/build_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::BuildError < StandardError
+end

data/app/errors/uffizzi_core/compose_file/credential_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::CredentialError < StandardError
+end

data/app/errors/uffizzi_core/compose_file/not_found_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::NotFoundError < StandardError
+end

data/app/errors/uffizzi_core/compose_file/parse_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ParseError < StandardError
+end

data/app/errors/uffizzi_core/compose_file/secrets_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::SecretsError < StandardError
+end

data/app/errors/uffizzi_core/deployment_not_found_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class UffizziCore::DeploymentNotFoundError < 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/create_form.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Account::Credential::CreateForm < UffizziCore::Credential
+  include UffizziCore::ApplicationForm
+
+  permit :type, :registry_url, :username, :password
+
+  validates :password, presence: { message: :password_blank }
+  validate :check_registry_url, if: -> { errors[:password].empty? }
+  validate :check_credential_correctness, if: -> { errors[:password].empty? }
+  validate :credential_exists?, if: -> { errors[:password].empty? }
+
+  private
+
+  def check_registry_url
+    errors.add(:registry_url, :invalid_scheme) if URI.parse(registry_url).scheme.nil?
+  end
+
+  def check_credential_correctness
+    errors.add(:username, :incorrect) unless UffizziCore::CredentialService.correct_credentials?(self)
+  end
+
+  def credential_exists?
+    errors.add(:type, :exist) if account.credentials.where(type: type).exists?
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ComposeFile::CheckCredentialsForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+
+  attribute :compose_file
+  attribute :credentials
+
+  validate :check_containers_credentials
+
+  private
+
+  def check_containers_credentials
+    compose_content = Base64.decode64(compose_file.content)
+    compose_data = UffizziCore::Cli::ComposeFileService.parse(compose_content)
+
+    UffizziCore::Cli::ComposeFileService.containers_credentials(compose_data, credentials)
+  rescue UffizziCore::ComposeFile::CredentialError => e
+    errors.add(:credentials, e.message)
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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
+  attribute :compose_repositories, Array
+  attribute :content, String
+
+  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)
+  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/create_form.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ComposeFile::CreateForm < UffizziCore::ComposeFile
+  include UffizziCore::ApplicationForm
+
+  permit :source, :path, :content
+
+  validates :source, presence: true
+  validates :source, uniqueness: { scope: :project_id, message: 'A compose file with the same source already exists for this project' },
+                     if: -> { kind.main? }
+  validates :path, presence: true
+  validates :content, presence: true
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ComposeFile::TemplateForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+
+  SECRETS_ERROR_KEY = 'secret_variables'
+  TEMPLATE_BUILD_ERROR_KEY = 'template_build_error'
+
+  attribute :credentials
+  attribute :project, UffizziCore::Project
+  attribute :user, UffizziCore::User
+  attribute :compose_data, Hash
+  attribute :source, String
+  attribute :template_attributes, Hash
+  attribute :template_build_error, String
+  attribute :compose_dependencies, Array
+  attribute :compose_repositories, Array
+
+  validate :check_template_attributes
+
+  def assign_template_attributes!
+    self.template_attributes = UffizziCore::Cli::ComposeFileService.build_template_attributes(
+      compose_data,
+      source,
+      credentials,
+      project,
+      compose_dependencies,
+      compose_repositories,
+    )
+  rescue StandardError => e
+    self.template_build_error = e
+  end
+
+  private
+
+  def check_template_attributes
+    case template_build_error
+    when UffizziCore::ComposeFile::SecretsError
+      errors.add(SECRETS_ERROR_KEY, template_build_error.message)
+    when UffizziCore::ComposeFile::BuildError
+      errors.add(TEMPLATE_BUILD_ERROR_KEY, template_build_error.message)
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ComposeFile::UpdateForm < UffizziCore::ComposeFile
+  include UffizziCore::ApplicationForm
+
+  permit :content, :source, :path
+
+  validates :content, presence: true
+end

data/app/forms/uffizzi_core/api/cli/v1/config_file/create_form.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ConfigFile::CreateForm < UffizziCore::ConfigFile
+  include UffizziCore::ApplicationForm
+
+  permit :filename, :kind, :payload
+
+  validates :filename, presence: true
+  validates :kind, presence: true
+  validates :payload, presence: true
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Deployment::CreateForm < UffizziCore::Deployment
+  include UffizziCore::ApplicationForm
+
+  permit :creation_source,
+         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/delete_secret_form.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Project::DeleteSecretForm < UffizziCore::Project
+  include UffizziCore::ApplicationForm
+
+  attr_accessor :secret
+
+  permit secrets: [:name, :value]
+
+  validate :check_existence
+
+  def delete_secret!
+    existing_secrets = secrets.presence || []
+
+    self.secrets = existing_secrets.reject { |existing_secret| existing_secret['name'] == secret.name }
+  end
+
+  private
+
+  def check_existence
+    existing_secrets = secrets.presence || []
+
+    detected_secret = existing_secrets.detect { |existing_secret| existing_secret['name'] == secret.name }
+
+    errors.add(:secret, :not_found, name: secret.name) if detected_secret.nil?
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Project::UpdateForm < UffizziCore::Project
+  include UffizziCore::ApplicationForm
+  MAX_SECRET_KEY_LENGTH = 256
+
+  permit :name, :slug, :description, secrets: [:name, :value]
+
+  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/session_create_form.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::SessionCreateForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+
+  attribute :email, String
+  attribute :password, String
+
+  validates :email, :password, presence: true
+  validate :check_authenticate, if: :email
+
+  def user
+    @user ||= UffizziCore::User.active.by_email(email).first
+  end
+
+  def check_authenticate
+    return unless wrong_email_or_password?
+
+    errors.add(:password, 'Email or password is incorrect.')
+  end
+
+  private
+
+  def wrong_email_or_password?
+    return true if user.nil?
+
+    !user.authenticate(password)
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/template/create_form.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Template::CreateForm < UffizziCore::Template
+  include UffizziCore::ApplicationForm
+
+  permit :name,
+         payload: {
+           containers_attributes: [
+             :image,
+             :tag,
+             :port,
+             :public,
+             :memory_limit,
+             :memory_request,
+             :entrypoint,
+             :command,
+             :receive_incoming_requests,
+             :continuously_deploy,
+             :name,
+             { variables: [:name, :value],
+               secret_variables: [:name, :value],
+               repo_attributes: [
+                 :namespace,
+                 :name,
+                 :slug,
+                 :type,
+                 :description,
+                 :repository_id,
+                 :is_private,
+                 :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_max_memory_limit
+  validate :check_max_memory_request
+
+  private
+
+  def check_max_memory_limit
+    return if UffizziCore::TemplateService.valid_containers_memory_limit?(self)
+
+    errors.add(:payload, :max_memory_limit_error, max: project.account.container_memory_limit)
+  end
+
+  def check_max_memory_request
+    return if UffizziCore::TemplateService.valid_containers_memory_request?(self)
+
+    errors.add(:payload, :max_memory_request_error, max: project.account.container_memory_limit)
+  end
+end

data/app/forms/uffizzi_core/application_form.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module UffizziCore::ApplicationForm
+  extend ActiveSupport::Concern
+
+  include UffizziCore::MassAssignmentControlConcern
+
+  class_methods do
+    delegate :model_name, :name, to: :superclass
+  end
+end

data/app/forms/uffizzi_core/application_form_without_active_record.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module UffizziCore::ApplicationFormWithoutActiveRecord
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+    include ActiveModel::Validations::Callbacks
+    include ::Virtus.model
+  end
+
+  def persisted?
+    false
+  end
+end