TheAentMachine\AentGitLabCI\Command\NewDeployDockerComposeJobEventCommand

Complexity

Total Complexity

7

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	askForDeployType()	0	17	3
A	createDeployOnRemoteServerJob()	0	21	1
A	executeEvent()	0	27	2
A	getEventName()	0	3	1

<?php

namespace TheAentMachine\AentGitLabCI\Command;

use TheAentMachine\AentGitLabCI\Aenthill\Metadata;
use TheAentMachine\AentGitLabCI\Exception\GitLabCIFileException;
use TheAentMachine\AentGitLabCI\Exception\JobException;
use TheAentMachine\AentGitLabCI\Exception\PayloadException;
use TheAentMachine\AentGitLabCI\GitLabCI\GitLabCIFile;
use TheAentMachine\AentGitLabCI\GitLabCI\Job\DeployDockerComposeJob;
use TheAentMachine\AentGitLabCI\Question\GitLabCICommonQuestions;
use TheAentMachine\Aenthill\CommonEvents;
use TheAentMachine\Aenthill\CommonMetadata;
use TheAentMachine\Aenthill\Manifest;
use TheAentMachine\Command\AbstractEventCommand;
use TheAentMachine\Exception\ManifestException;
use TheAentMachine\Exception\MissingEnvironmentVariableException;

final class NewDeployDockerComposeJobEventCommand extends AbstractEventCommand
{
    /** @var string */
    private $envName;

    /** @var string */
    private $registryDomainName;

    /** @var string */
    private $dockerComposeFilename;

    protected function getEventName(): string
    {
        return CommonEvents::NEW_DEPLOY_DOCKER_COMPOSE_JOB_EVENT;
    }

    /**
     * @param null|string $payload
     * @return null|string
     * @throws GitLabCIFileException
     * @throws JobException
     * @throws ManifestException
     * @throws MissingEnvironmentVariableException
     * @throws PayloadException
     */
    protected function executeEvent(?string $payload): ?string
    {
        $aentHelper = $this->getAentHelper();

        $aentHelper->title('GitLab CI: adding a deploy stage');

        if (empty($payload)) {
            throw PayloadException::missingDockerComposeFilename();
        }


        $this->envName = Manifest::mustGetMetadata(CommonMetadata::ENV_NAME_KEY);
        $this->registryDomainName = Manifest::mustGetMetadata(Metadata::REGISTRY_DOMAIN_NAME_KEY);
        $this->dockerComposeFilename = $payload;

        $this->output->writeln("🦊 Docker Compose file: <info>$this->dockerComposeFilename</info>");
        $aentHelper->spacer();

        $job = $this->askForDeployType();

        $file = new GitLabCIFile();
        $file->findOrCreate();
        $file->addDeploy($job);

        $this->output->writeln('🦊 <info>' . GitLabCIFile::DEFAULT_FILENAME . '</info> has been successfully updated!');

        return null;
    }

    /**
     * @return DeployDockerComposeJob
     * @throws JobException
     */
    private function askForDeployType(): DeployDockerComposeJob
    {
        $deployType = Manifest::getMetadata(Metadata::DEPLOY_TYPE_KEY);

        if (null === $deployType) {
            $deployType = $this->getAentHelper()
                ->choiceQuestion('Select on which provider you want to deploy your stack', [
                    Metadata::DEPLOY_TYPE_REMOTE_SERVER
                ])
                ->ask();
        }

        switch ($deployType) {
            case Metadata::DEPLOY_TYPE_REMOTE_SERVER:
                return $this->createDeployOnRemoteServerJob();
            default:
                throw JobException::unknownDeployType($deployType);
        }
    }

    /**
     * @return DeployDockerComposeJob
     * @throws JobException
     */
    private function createDeployOnRemoteServerJob(): DeployDockerComposeJob
    {
        Manifest::addMetadata(Metadata::DEPLOY_TYPE_KEY, Metadata::DEPLOY_TYPE_REMOTE_SERVER);

        $gitlabCICommonQuestions = new GitLabCICommonQuestions($this->getAentHelper());

        $remoteIP = $gitlabCICommonQuestions->askForRemoteIP();
        $remoteUser = $gitlabCICommonQuestions->askForRemoteUser();
        $remoteBasePath = $gitlabCICommonQuestions->askForRemoteBasePath();
        $branches = $gitlabCICommonQuestions->askForBranches(false);
        $isManual = $gitlabCICommonQuestions->askForManual();

        return DeployDockerComposeJob::newDeployOnRemoteServer(
            $this->envName,
            $this->registryDomainName,
            $this->dockerComposeFilename,
            $remoteIP,
            $remoteUser,
            $remoteBasePath,
            $branches,
            $isManual
        );
    }
}