FM / Migration

/var/www/vhosts/ihelp.ro/httpdocs/vendor/robmorgan/phinx/src/Phinx/Migration/

/var/www/vhosts/ihelp.ro/httpdocs/vendor/robmorgan/phinx/src/Phinx/Migration

Name	Size	Mode	Actions
Manager/	-	0755	rm
AbstractMigration.php	7202	0644	edit dl rm
AbstractTemplateCreation.php	1595	0644	edit dl rm
CreationInterface.php	2094	0644	edit dl rm
IrreversibleMigrationException.php	384	0644	edit dl rm
Manager.php	40998	0644	edit dl rm
Migration.change.template.php.dist	538	0644	edit dl rm
Migration.up_down.template.php.dist	213	0644	edit dl rm
MigrationInterface.php	6791	0644	edit dl rm

Edit: /var/www/vhosts/ihelp.ro/httpdocs/vendor/robmorgan/phinx/src/Phinx/Migration/AbstractMigration.php (7202B)

<?php

/**
 * MIT License
 * For full license information, please view the LICENSE file that was distributed with this source code.
 */

namespace Phinx\Migration;

use Cake\Database\Query;
use Phinx\Db\Adapter\AdapterInterface;
use Phinx\Db\Table;
use RuntimeException;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Abstract Migration Class.
 *
 * It is expected that the migrations you write extend from this class.
 *
 * This abstract class proxies the various database methods to your specified
 * adapter.
 *
 * @author Rob Morgan <robbym@gmail.com>
 */
abstract class AbstractMigration implements MigrationInterface
{
    /**
     * @var string
     */
    protected $environment;

/**
     * @var int
     */
    protected $version;

/**
     * @var \Phinx\Db\Adapter\AdapterInterface|null
     */
    protected $adapter;

/**
     * @var \Symfony\Component\Console\Output\OutputInterface|null
     */
    protected $output;

/**
     * @var \Symfony\Component\Console\Input\InputInterface|null
     */
    protected $input;

/**
     * Whether this migration is being applied or reverted
     *
     * @var bool
     */
    protected $isMigratingUp = true;

/**
     * List of all the table objects created by this migration
     *
     * @var array<\Phinx\Db\Table>
     */
    protected $tables = [];

/**
     * @param string $environment Environment Detected
     * @param int $version Migration Version
     * @param \Symfony\Component\Console\Input\InputInterface|null $input Input
     * @param \Symfony\Component\Console\Output\OutputInterface|null $output Output
     */
    final public function __construct(string $environment, int $version, ?InputInterface $input = null, ?OutputInterface $output = null)
    {
        $this->environment = $environment;
        $this->version = $version;

if ($input !== null) {
            $this->setInput($input);
        }

if ($output !== null) {
            $this->setOutput($output);
        }
    }

/**
     * @inheritDoc
     */
    public function setAdapter(AdapterInterface $adapter): MigrationInterface
    {
        $this->adapter = $adapter;

return $this;
    }

/**
     * @inheritDoc
     */
    public function getAdapter(): ?AdapterInterface
    {
        return $this->adapter;
    }

/**
     * @inheritDoc
     */
    public function setInput(InputInterface $input): MigrationInterface
    {
        $this->input = $input;

return $this;
    }

/**
     * @inheritDoc
     */
    public function getInput(): ?InputInterface
    {
        return $this->input;
    }

/**
     * @inheritDoc
     */
    public function setOutput(OutputInterface $output): MigrationInterface
    {
        $this->output = $output;

return $this;
    }

/**
     * @inheritDoc
     */
    public function getOutput(): ?OutputInterface
    {
        return $this->output;
    }

/**
     * @inheritDoc
     */
    public function getName(): string
    {
        return static::class;
    }

/**
     * @inheritDoc
     */
    public function getEnvironment(): string
    {
        return $this->environment;
    }

/**
     * @inheritDoc
     */
    public function setVersion($version): MigrationInterface
    {
        $this->version = $version;

return $this;
    }

/**
     * @inheritDoc
     */
    public function getVersion(): int
    {
        return $this->version;
    }

/**
     * @inheritDoc
     */
    public function setMigratingUp(bool $isMigratingUp): MigrationInterface
    {
        $this->isMigratingUp = $isMigratingUp;

return $this;
    }

/**
     * @inheritDoc
     */
    public function isMigratingUp(): bool
    {
        return $this->isMigratingUp;
    }

/**
     * @inheritDoc
     */
    public function execute(string $sql, array $params = []): int
    {
        return $this->getAdapter()->execute($sql, $params);
    }

/**
     * @inheritDoc
     */
    public function query(string $sql, array $params = [])
    {
        return $this->getAdapter()->query($sql, $params);
    }

/**
     * @inheritDoc
     */
    public function getQueryBuilder(): Query
    {
        return $this->getAdapter()->getQueryBuilder();
    }

/**
     * @inheritDoc
     */
    public function fetchRow(string $sql)
    {
        return $this->getAdapter()->fetchRow($sql);
    }

/**
     * @inheritDoc
     */
    public function fetchAll(string $sql): array
    {
        return $this->getAdapter()->fetchAll($sql);
    }

/**
     * @inheritDoc
     */
    public function createDatabase(string $name, array $options): void
    {
        $this->getAdapter()->createDatabase($name, $options);
    }

/**
     * @inheritDoc
     */
    public function dropDatabase(string $name): void
    {
        $this->getAdapter()->dropDatabase($name);
    }

/**
     * @inheritDoc
     */
    public function createSchema(string $name): void
    {
        $this->getAdapter()->createSchema($name);
    }

/**
     * @inheritDoc
     */
    public function dropSchema(string $name): void
    {
        $this->getAdapter()->dropSchema($name);
    }

/**
     * @inheritDoc
     */
    public function hasTable(string $tableName): bool
    {
        return $this->getAdapter()->hasTable($tableName);
    }

/**
     * @inheritDoc
     */
    public function table(string $tableName, array $options = []): Table
    {
        $table = new Table($tableName, $options, $this->getAdapter());
        $this->tables[] = $table;

return $table;
    }

/**
     * Perform checks on the migration, print a warning
     * if there are potential problems.
     *
     * Right now, the only check is if there is both a `change()` and
     * an `up()` or a `down()` method.
     *
     * @return void
     */
    public function preFlightCheck(): void
    {
        if (method_exists($this, MigrationInterface::CHANGE)) {
            if (
                method_exists($this, MigrationInterface::UP) ||
                method_exists($this, MigrationInterface::DOWN)
            ) {
                $this->output->writeln(sprintf(
                    '<comment>warning</comment> Migration contains both change() and up()/down() methods.  <options=bold>Ignoring up() and down()</>.'
                ));
            }
        }
    }

/**
     * Perform checks on the migration after completion
     *
     * Right now, the only check is whether all changes were committed
     *
     * @throws \RuntimeException
     * @return void
     */
    public function postFlightCheck(): void
    {
        foreach ($this->tables as $table) {
            if ($table->hasPendingActions()) {
                throw new RuntimeException('Migration has pending actions after execution!');
            }
        }
    }

/**
     * Checks to see if the migration should be executed.
     *
     * Returns true by default.
     *
     * You can use this to prevent a migration from executing.
     *
     * @return bool
     */
    public function shouldExecute(): bool
    {
        return true;
    }
}

cmd: