Module.php

<?php declare(strict_types=1);
/*
 * Amazon S3
 *
 * Files store that integrates with Amason S3.
 *
 * Copyright Daniel Berthereau 2019-2023
 *
 * This software is governed by the CeCILL license under French law and abiding
 * by the rules of distribution of free software.  You can use, modify and/ or
 * redistribute the software under the terms of the CeCILL license as circulated
 * by CEA, CNRS and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and rights to copy, modify
 * and redistribute granted by the license, users are provided only with a
 * limited warranty and the software's author, the holder of the economic
 * rights, and the successive licensors have only limited liability.
 *
 * In this respect, the user's attention is drawn to the risks associated with
 * loading, using, modifying and/or developing or reproducing the software by
 * the user in light of its specific status of free software, that may mean that
 * it is complicated to manipulate, and that also therefore means that it is
 * reserved for developers and experienced professionals having in-depth
 * computer knowledge. Users are therefore encouraged to load and test the
 * software's suitability as regards their requirements in conditions enabling
 * the security of their systems and/or data to be ensured and, more generally,
 * to use and operate it in the same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL license and that you accept its terms.
 */
namespace AmazonS3;

// Load the module dependencies when installed as a zip.
// With composer, libraries are stored in omeka vendor/ and the module has none.
if (file_exists(__DIR__ . '/vendor/autoload.php')) {
    require_once __DIR__ . '/vendor/autoload.php';
}

// Common may be installed but not registered in autoloader, in particular
// during upgrade. So dynamically register all classes of the module.
if (!defined('COMMON_PSR4_FALLBACK')) {
    foreach ([
        OMEKA_PATH . '/modules/Common/src',
        OMEKA_PATH . '/composer-addons/modules/Common/src',
        dirname(__DIR__) . '/Common/src',
    ] as $commonSrc) {
        if (file_exists($commonSrc . '/TraitModule.php')) {
            define('COMMON_PSR4_FALLBACK', $commonSrc);
            spl_autoload_register(static function ($class): void {
                if (str_starts_with($class, 'Common\\')) {
                    $file = COMMON_PSR4_FALLBACK . '/' . strtr(substr($class, 7), '\\', '/') . '.php';
                    if (file_exists($file)) {
                        require_once $file;
                    }
                }
            });
            break;
        }
    }
}

use AmazonS3\File\Store\AwsS3;
use Common\Stdlib\PsrMessage;
use Common\TraitModule;
use Laminas\Mvc\Controller\AbstractController;
use Laminas\Mvc\MvcEvent;
use Omeka\Module\AbstractModule;
use Omeka\Module\Exception\ModuleCannotInstallException;

class Module extends AbstractModule
{
    use TraitModule;

    const NAMESPACE = __NAMESPACE__;

    public function onBootstrap(MvcEvent $event): void
    {
        parent::onBootstrap($event);

        /** @var \Laminas\ServiceManager\ServiceManager $services */
        $services = $this->getServiceLocator();

        // The alias is set in all cases, because the module is on. Else, the
        // files will be silently saved locally.
        $services->setAlias('Omeka\File\Store', File\Store\AwsS3::class);

        try {
            // The store is checked to avoid issue in this main piece of Omeka.
            // Check here via a simple get, because this service is required in
            // most of the cases.
            $services->get(File\Store\AwsS3::class);
        } catch (\Laminas\ServiceManager\Exception\ServiceNotCreatedException $e) {
            $services->get('Omeka\Logger')->err($e->getMessage());
        }

        // Override ArchiveRepertory File classes to work with Amazon S3.
        if ($this->isModuleActive('ArchiveRepertory')) {
            $services->setAlias('ArchiveRepertory\FileWriter', File\ArchiveRepertory\FileWriter::class);
            $services->setAlias('ArchiveRepertory\FileManager', File\ArchiveRepertory\FileManager::class);
        }
    }

    protected function preInstall(): void
    {
        $services = $this->getServiceLocator();
        $translator = $services->get('MvcTranslator');

        if (!method_exists($this, 'checkModuleActiveVersion') || !$this->checkModuleActiveVersion('Common', '3.4.91')) {
            $message = new PsrMessage(
                'The module {module} should be upgraded to version {version} or later.', // @translate
                ['module' => 'Common', 'version' => '3.4.91']
            );
            throw new ModuleCannotInstallException((string) $message->setTranslator($translator));
        }

        if (!file_exists(__DIR__ . '/vendor/autoload.php')) {
            throw new ModuleCannotInstallException(
                $translator->translate('The AWS SDK library should be installed.') // @translate
                    . ' ' . $translator->translate('See module’s installation documentation.') // @translate
            );
        }
    }

    public function handleConfigForm(AbstractController $controller)
    {
        $result = $this->handleConfigFormAuto($controller);
        if (!$result) {
            return false;
        }

        $services = $this->getServiceLocator();
        $settings = $services->get('Omeka\Settings');

        try {
            $store = $services->get(File\Store\AwsS3::class);
        } catch (\Laminas\ServiceManager\Exception\ServiceNotCreatedException $e) {
            $controller->messenger()->addErrors(['Wrong credentials. Unable to connect to Amazon S3 service.']); // @translate
            return false;
        }

        // Check the bucket that is really used, and not the list of all the
        // buckets: listing them requires the permission "s3:ListAllMyBuckets"
        // on all the buckets, that a user dedicated to Omeka rarely has.
        if (!$store->canStore()) {
            $bucket = (string) $settings->get(AwsS3::OPTION_BUCKET);
            // Keep the error of the bucket: listing the buckets replaces it.
            $error = (string) $store->getLastError();
            // The list of the buckets is only used to help the user, when it
            // is available, so it never makes the config fail by itself.
            $buckets = $store->getBuckets();
            if (is_array($buckets) && $buckets && !in_array($bucket, $buckets)) {
                $controller->messenger()->addErrors([sprintf(
                    'Wrong bucket. Please specify an existing one, like: %s', // @translate
                    implode(', ', array_slice($buckets, 0, 3))
                )]);
            } else {
                $controller->messenger()->addErrors([sprintf(
                    'Unable to access the bucket "%1$s". Check the credentials, the region and the rights of the user on this bucket. %2$s', // @translate
                    $bucket, $error
                )]);
            }
            return false;
        }

        $region = $store->determineBucketRegion();
        if ($region !== false && $region != $settings->get(AwsS3::OPTION_REGION) && $region !=="") {
            $controller->messenger()->addErrors([sprintf(
                'Wrong region. Please use region of a bucket: %s', // @translate
                $region
            )]);
            return false;
        }

        return true;
    }
}