Chamilo\CoreBundle\Command\ConvertToMultiUrlCommand::execute()

Complexity

Conditions	29
Paths	> 20000

Size

Total Lines	317
Code Lines	221

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io          = new SymfonyStyle($input, $output);
        $newAdminUrl = (string) $input->getArgument('admin-url');
        $username    = (string) ($input->getOption('admin-username') ?? '');
        $preserveId  = (bool) $input->getOption('preserve-admin-id');
        $dryRun      = (bool) $input->getOption('dry-run');
        $force       = (bool) $input->getOption('force');

        $prefix = (string) ($this->params->has('database_prefix') ? $this->params->get('database_prefix') : '');
        $T = static fn(string $name) => $prefix.$name;

        /** @var AbstractSchemaManager $sm */
        $sm = $this->conn->createSchemaManager();
        $exists = fn(string $table) => $sm->tablesExist([$table]);

        // Canonical tables (based on your entities)
        $accessUrl             = $T('access_url');
        $relCourse             = $T('access_url_rel_course');
        $relCourseCategory     = $T('access_url_rel_course_category');
        $relSession            = $T('access_url_rel_session');
        $relUser               = $T('access_url_rel_user');
        $relUsergroup          = $T('access_url_rel_usergroup');

        $userRelCourseVote     = $T('user_rel_course_vote');   // url_id
        $trackOnline           = $T('track_e_online');         // access_url_id
        $sysAnnouncement       = $T('sys_announcement');       // access_url_id
        $skill                 = $T('skill');                   // access_url_id
        $branchSync            = $T('branch_sync');             // access_url_id
        $sessionCategory       = $T('session_category');        // access_url_id

        // Optional/legacy extras (existence-checked)
        $systemCalendar        = $T('system_calendar');         // access_url_id (if present)
        $trackCourseRanking    = $T('track_course_ranking');    // url_id (if present)
        $userTable             = $T('user');

        // Safety: expect single URL unless --force
        $countUrl = (int) $this->conn->fetchOne("SELECT COUNT(*) FROM {$accessUrl}");
        if (!$force && $countUrl !== 1) {
            $io->error("Aborting: expected exactly 1 row in access_url; found {$countUrl}. Use --force if you know what you are doing.");
            return Command::FAILURE;
        }

        // Fetch a deterministic "current" row (lowest id) for planning
        $row = $this->conn->fetchAssociative("SELECT * FROM {$accessUrl} ORDER BY id ASC LIMIT 1");
        if (!$row) {
            $io->error('No access_url row found. Nothing to convert.');
            return Command::FAILURE;
        }
        $currentId  = (int) $row['id'];
        $currentUrl = (string) $row['url'];

        // Resolve admin user id from username (fallback to 1)
        $adminUserId = 1;
        if ($username !== '') {
            $adminUserId = (int) ($this->conn->fetchOne(
                "SELECT id FROM {$userTable} WHERE username = :u",
                ['u' => $username],
                ['u' => Types::STRING]
            ) ?: 1);
            if ($adminUserId === 1 && $username !== '') {
                $io->warning("Username '{$username}' not found. Falling back to user id 1.");
            }
        } else {
            $io->note('No admin username provided; using admin id 1.');
        }

        // Inspect access_url columns to know if Gedmo Tree fields exist (and if root/tree_root exists)
        $columns = [];
        foreach ($sm->listTableColumns($accessUrl) as $col) {
            $columns[$col->getName()] = true;
        }
        $hasLft = isset($columns['lft']);
        $hasRgt = isset($columns['rgt']);
        $hasLvl = isset($columns['lvl']);
        $rootCol = isset($columns['tree_root']) ? 'tree_root' : (isset($columns['root']) ? 'root' : null);
        $hasTree = ($hasLft && $hasRgt && $hasLvl);

        // Plan (no writes here)
        $io->section('Current / Planned URLs');
        if ($preserveId) {
            $adminUrlId = $currentId;         // stays admin
            $oldUrlId   = $currentId + 1;     // secondary row
            $io->listing([
                "Keep current row as ADMIN: id={$adminUrlId} url will become {$newAdminUrl}",
                "Insert SECONDARY URL: id={$oldUrlId} url will be {$currentUrl}",
                "Move foreign keys: {$adminUrlId} -> {$oldUrlId} (includes user groups/classes).",
            ]);
        } else {
            $io->listing([
                "Keep current URL as SECONDARY: id={$currentId} url={$currentUrl}",
                "Insert new ADMIN URL with auto id: url={$newAdminUrl}",
                "No FK moves; only link admin user to new admin URL.",
            ]);
        }

        // Early exit on dry-run: show plan only
        if ($dryRun) {
            $io->success('Dry-run complete. No changes were committed.');
            $io->note('If you proceed for real, remember to enable multiple_access_urls afterwards.');
            return Command::SUCCESS;
        }

        $this->conn->beginTransaction();
        try {
            if ($preserveId) {
                // 1) Make current row ADMIN
                $sql = "UPDATE {$accessUrl} SET url = :adminUrl, description = :descr WHERE id = :id";
                $io->text("∙ Update current access_url -> ADMIN");
                $this->conn->executeStatement($sql, [
                    'adminUrl' => $newAdminUrl,
                    'descr'    => 'The main admin URL',
                    'id'       => $currentId,
                ], [
                    'adminUrl' => Types::STRING,
                    'descr'    => Types::STRING,
                    'id'       => Types::INTEGER,
                ]);

                // 2) Insert SECONDARY with explicit id = currentId+1 (old URL)
                $adminUrlId = $currentId;
                $oldUrlId   = $currentId + 1;

                $insertCols = ['id','url','description','active','created_by','tms','url_type'];
                $params     = [
                    'id'          => $oldUrlId,
                    'url'         => $currentUrl,
                    'description' => '',
                    'active'      => 1,
                    'created_by'  => 1,
                    'tms'         => new \DateTime('now', new \DateTimeZone('UTC')),
                    'url_type'    => null,
                ];
                $types      = [
                    'id'          => Types::INTEGER,
                    'url'         => Types::STRING,
                    'description' => Types::STRING,
                    'active'      => Types::BOOLEAN,
                    'created_by'  => Types::INTEGER,
                    'tms'         => Types::DATETIME_MUTABLE,
                    'url_type'    => Types::BOOLEAN,
                ];

                if ($hasTree) {
                    // Provide values at INSERT time to satisfy NOT NULL columns in strict MySQL
                    $insertCols[] = 'lft';
                    $insertCols[] = 'rgt';
                    $insertCols[] = 'lvl';
                    $params['lft'] = 1;
                    $params['rgt'] = 2;
                    $params['lvl'] = 0;
                    $types['lft'] = Types::INTEGER;
                    $types['rgt'] = Types::INTEGER;
                    $types['lvl'] = Types::INTEGER;
                }
                if ($rootCol) {
                    // Insert NULL for root; we will UPDATE to self id right after
                    $insertCols[] = $rootCol;
                    $params[$rootCol] = null;
                    $types[$rootCol]  = Types::INTEGER;
                }

                $io->text("∙ Insert SECONDARY access_url (explicit id = {$oldUrlId})");
                $placeholders = [];
                foreach ($insertCols as $c) {
                    $placeholders[] = ':'.$c;
                }
                $this->conn->executeStatement(
                    "INSERT INTO {$accessUrl} (".implode(',', $insertCols).") VALUES (".implode(',', $placeholders).")",
                    $params,
                    $types
                );

                // Initialize root column to self id if present
                if ($rootCol) {
                    $io->text("∙ Initialize tree root column for SECONDARY");
                    $this->conn->executeStatement(
                        "UPDATE {$accessUrl} SET {$rootCol} = :self WHERE id = :self",
                        ['self' => $oldUrlId],
                        ['self' => Types::INTEGER]
                    );
                }

                // 3) Move FKs from ADMIN to SECONDARY
                $move = function (string $table, string $col) use ($io, $adminUrlId, $oldUrlId, $exists) {
                    if (!$exists($table)) {
                        return;
                    }
                    $io->text("∙ Update {$table}.{$col} {$adminUrlId} -> {$oldUrlId}");
                    $this->conn->executeStatement(
                        "UPDATE {$table} SET {$col} = :to WHERE {$col} = :from",
                        ['to' => $oldUrlId, 'from' => $adminUrlId],
                        ['to' => Types::INTEGER, 'from' => Types::INTEGER]
                    );
                };

                $move($userRelCourseVote, 'url_id');
                $move($trackOnline,       'access_url_id');
                $move($sysAnnouncement,   'access_url_id');
                $move($skill,             'access_url_id');
                $move($relCourse,         'access_url_id');
                $move($relCourseCategory, 'access_url_id');
                $move($relSession,        'access_url_id');
                $move($relUser,           'access_url_id');
                $move($relUsergroup,      'access_url_id');
                $move($branchSync,        'access_url_id');
                $move($sessionCategory,   'access_url_id');

                if ($exists($systemCalendar)) {
                    $move($systemCalendar, 'access_url_id');
                }
                if ($exists($trackCourseRanking)) {
                    $move($trackCourseRanking, 'url_id');
                }

                // 4) Ensure admin user is linked to ADMIN url
                $io->text("∙ Ensure admin user has relation to ADMIN url");
                $this->conn->executeStatement(
                    "INSERT INTO {$relUser} (access_url_id, user_id)
                     SELECT :adminId, :userId
                     WHERE NOT EXISTS (
                       SELECT 1 FROM {$relUser} WHERE access_url_id = :adminId AND user_id = :userId
                     )",
                    ['adminId' => $adminUrlId, 'userId' => $adminUserId],
                    ['adminId' => Types::INTEGER, 'userId' => Types::INTEGER]
                );
            } else {
                // SAFER: Insert ADMIN with auto id; keep current as SECONDARY (no FK moves)
                $io->text("∙ Insert ADMIN access_url (auto id)");

                $insertCols = ['url','description','active','created_by','tms','url_type'];
                $params     = [
                    'url'         => $newAdminUrl,
                    'description' => 'The main admin URL',
                    'active'      => 1,
                    'created_by'  => 1,
                    'tms'         => new \DateTime('now', new \DateTimeZone('UTC')),
                    'url_type'    => null,
                ];
                $types      = [
                    'url'         => Types::STRING,
                    'description' => Types::STRING,
                    'active'      => Types::BOOLEAN,
                    'created_by'  => Types::INTEGER,
                    'tms'         => Types::DATETIME_MUTABLE,
                    'url_type'    => Types::BOOLEAN,
                ];

                if ($hasTree) {
                    // Provide lft/rgt/lvl at INSERT to satisfy NOT NULL
                    $insertCols[] = 'lft';
                    $insertCols[] = 'rgt';
                    $insertCols[] = 'lvl';
                    $params['lft'] = 1;
                    $params['rgt'] = 2;
                    $params['lvl'] = 0;
                    $types['lft'] = Types::INTEGER;
                    $types['rgt'] = Types::INTEGER;
                    $types['lvl'] = Types::INTEGER;
                }
                if ($rootCol) {
                    $insertCols[] = $rootCol;
                    $params[$rootCol] = null; // set later to self id
                    $types[$rootCol]  = Types::INTEGER;
                }

                $placeholders = [];
                foreach ($insertCols as $c) {
                    $placeholders[] = ':'.$c;
                }

                $this->conn->executeStatement(
                    "INSERT INTO {$accessUrl} (".implode(',', $insertCols).") VALUES (".implode(',', $placeholders).")",
                    $params,
                    $types
                );

                // Get new id deterministically
                $newId = (int) $this->conn->fetchOne(
                    "SELECT id FROM {$accessUrl} WHERE url = :u ORDER BY id DESC LIMIT 1",
                    ['u' => $newAdminUrl],
                    ['u' => Types::STRING]
                );

                // Initialize tree root to self id if present
                if ($rootCol) {
                    $io->text("∙ Initialize tree root column for ADMIN access_url");
                    $this->conn->executeStatement(
                        "UPDATE {$accessUrl}
                         SET {$rootCol} = :self
                         WHERE id = :self",
                        ['self' => $newId],
                        ['self' => Types::INTEGER]
                    );
                }

                // Ensure admin user is linked to new ADMIN url
                $io->text("∙ Ensure admin user has relation to ADMIN url");
                $this->conn->executeStatement(
                    "INSERT INTO {$relUser} (access_url_id, user_id)
                     SELECT :adminId, :userId
                     WHERE NOT EXISTS (
                       SELECT 1 FROM {$relUser} WHERE access_url_id = :adminId AND user_id = :userId
                     )",
                    ['adminId' => $newId, 'userId' => $adminUserId],
                    ['adminId' => Types::INTEGER, 'userId' => Types::INTEGER]
                );
            }

            $this->conn->commit();
            $io->success('Portal converted to MultiURL successfully.');
            $io->note('Remember to enable multi-URL mode in configuration (e.g., configuration.php or platform setting).');
            return Command::SUCCESS;
        } catch (DBALException $e) {
            $this->conn->rollBack();
            $io->error('Conversion failed: '.$e->getMessage());
            return Command::FAILURE;
        }