MongoDB.php

<?php
/**
 * This file is part of the Imbo package
 *
 * (c) Christer Edvartsen <cogo@starzinger.net>
 *
 * For the full copyright and license information, please view the LICENSE file that was
 * distributed with this source code.
 */

namespace Imbo\Database;

use Imbo\Model\Image,
    Imbo\Model\Images,
    Imbo\Resource\Images\Query,
    Imbo\Exception\DatabaseException,
    Imbo\Exception\DuplicateImageIdentifierException,
    Imbo\Helpers\BSONToArray,
    MongoDB\Client as MongoClient,
    MongoDB\Driver\Manager,
    MongoDB\Driver\Command,
    MongoDB\Collection as MongoCollection,
    MongoDB\Driver\Exception\Exception as MongoException,
    MongoDB\Model\BSONDocument,
    DateTime,
    DateTimeZone;

/**
 * MongoDB database driver
 *
 * A MongoDB database driver for Imbo
 *
 * Valid parameters for this driver:
 *
 * - (string) databaseName Name of the database. Defaults to 'imbo'
 * - (string) server The server string to use when connecting to MongoDB. Defaults to
 *                   'mongodb://localhost:27017'
 * - (array) options Options to use when creating the MongoDB\Client instance. Defaults to
 *                   ['connect' => true, 'connectTimeoutMS' => 1000].
 *
 * @author Christer Edvartsen <cogo@starzinger.net>
 * @package Database
 */
class MongoDB implements DatabaseInterface {
    /**
     * MongoDB client instance
     *
     * @var MongoClient
     */
    private $mongoClient;

    /**
     * The collection instances used by the driver
     *
     * @var array
     */
    private $collections = [
        'image' => null,
        'shortUrl' => null,
    ];

    /**
     * Parameters for the driver
     *
     * @var array
     */
    private $params = [
        // Database name
        'databaseName' => 'imbo',

        // Server string and ctor options
        'server'  => 'mongodb://localhost:27017',
        'options' => ['connect' => true, 'connectTimeoutMS' => 1000],
    ];

    /**
     * BSONToArray helper
     *
     * @var BSONToArray
     */
    private $bsonToArray;

    /**
     * Class constructor
     *
     * @param array $params Parameters for the driver
     * @param MongoClient $client MongoClient instance
     * @param MongoCollection $imageCollection MongoCollection instance for the images
     * @param MongoCollection $shortUrlCollection MongoCollection instance for the short URLs
     * @param BSONToArray $bsonToArray Helper to recursively convert documents to arrays
     */
    public function __construct(array $params = null, MongoClient $client = null, MongoCollection $imageCollection = null, MongoCollection $shortUrlCollection = null, BSONToArray $bsonToArray = null) {
        if ($params !== null) {
            $this->params = array_replace_recursive($this->params, $params);
        }

        if ($client !== null) {
            $this->mongoClient = $client;
        }

        if ($imageCollection !== null) {
            $this->collections['image'] = $imageCollection;
        }

        if ($shortUrlCollection !== null) {
            $this->collections['shortUrl'] = $shortUrlCollection;
        }

        if ($bsonToArray === null) {
            $bsonToArray = new BSONToArray();
        }

        $this->bsonToArray = $bsonToArray;
    }

    /**
     * {@inheritdoc}
     */
    public function insertImage($user, $imageIdentifier, Image $image, $updateIfDuplicate = true) {
        $now = time();

        if ($added = $image->getAddedDate()) {
            $added = $added->getTimestamp();
        }

        if ($updated = $image->getUpdatedDate()) {
            $updated = $updated->getTimestamp();
        }

        if ($updateIfDuplicate && $this->imageExists($user, $imageIdentifier)) {
            try {
                $this->getImageCollection()->updateOne(
                    ['user' => $user, 'imageIdentifier' => $imageIdentifier],
                    ['$set' => ['updated' => $now]]
                );

                return true;
            } catch (MongoException $e) {
                throw new DatabaseException('Unable to save image data', 500, $e);
            }
        }

        $data = [
            'size'             => $image->getFilesize(),
            'user'             => $user,
            'imageIdentifier'  => $imageIdentifier,
            'extension'        => $image->getExtension(),
            'mime'             => $image->getMimeType(),
            'metadata'         => [],
            'added'            => $added ?: $now,
            'updated'          => $updated ?: $now,
            'width'            => $image->getWidth(),
            'height'           => $image->getHeight(),
            'checksum'         => $image->getChecksum(),
            'originalChecksum' => $image->getOriginalChecksum(),
        ];

        try {
            $this->getImageCollection()->insertOne($data);
        } catch (MongoException $e) {
            foreach ($e->getWriteResult()->getWriteErrors() as $error) {
                if ($error->getCode() === 11000) {
                    throw new DuplicateImageIdentifierException(
                        'Duplicate image identifier when attempting to insert image into DB.',
                        503
                    );
                }
            }

            throw new DatabaseException('Unable to save image data', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteImage($user, $imageIdentifier) {
        try {
            $data = $this->getImageCollection()->findOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
            ]);

            if ($data === null) {
                throw new DatabaseException('Image not found', 404);
            }

            $this->getImageCollection()->deleteOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
            ]);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to delete image data', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function updateMetadata($user, $imageIdentifier, array $metadata) {
        try {
            // Fetch existing metadata and merge with the incoming data
            $existing = $this->getMetadata($user, $imageIdentifier);
            $updatedMetadata = array_merge($existing, $metadata);

            $this->getImageCollection()->updateOne(
                ['user' => $user, 'imageIdentifier' => $imageIdentifier],
                ['$set' => ['metadata' => $updatedMetadata]]
            );
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to update meta data', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($user, $imageIdentifier) {
        try {
            $data = $this->getImageCollection()->findOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
            ]);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch meta data', 500, $e);
        }

        if ($data === null) {
            throw new DatabaseException('Image not found', 404);
        }

        return $this->bsonToArray->toArray($data['metadata']->getArrayCopy());
    }

    /**
     * {@inheritdoc}
     */
    public function deleteMetadata($user, $imageIdentifier) {
        try {
            $data = $this->getImageCollection()->findOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
            ]);

            if ($data === null) {
                throw new DatabaseException('Image not found', 404);
            }

            $this->getImageCollection()->updateOne(
                ['user' => $user, 'imageIdentifier' => $imageIdentifier],
                ['$set' => ['metadata' => []]]
            );
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to delete meta data', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getImages(array $users, Query $query, Images $model) {
        // Initialize return value
        $images = [];
        $queryData = [];

        // Query data
        if ($users) {
            // Only filter on users if the array contains any values
            $queryData['user']['$in'] = $users;
        }

        $from = $query->from();
        $to = $query->to();

        if ($from || $to) {
            $tmp = [];

            if ($from !== null) {
                $tmp['$gte'] = $from;
            }

            if ($to !== null) {
                $tmp['$lte'] = $to;
            }

            $queryData['added'] = $tmp;
        }

        $imageIdentifiers = $query->imageIdentifiers();

        if (!empty($imageIdentifiers)) {
            $queryData['imageIdentifier']['$in'] = $imageIdentifiers;
        }

        $checksums = $query->checksums();

        if (!empty($checksums)) {
            $queryData['checksum']['$in'] = $checksums;
        }

        $originalChecksums = $query->originalChecksums();

        if (!empty($originalChecksums)) {
            $queryData['originalChecksum']['$in'] = $originalChecksums;
        }

        // Sorting
        $sort = ['added' => -1];

        if ($querySort = $query->sort()) {
            $sort = [];

            foreach ($querySort as $s) {
                $sort[$s['field']] = ($s['sort'] === 'asc' ? 1 : -1);
            }
        }

        // Fields to fetch
        $fields = array_fill_keys([
            'extension', 'added', 'checksum', 'originalChecksum', 'updated',
            'user', 'imageIdentifier', 'mime', 'size', 'width', 'height'
        ], true);

        if ($query->returnMetadata()) {
            $fields['metadata'] = true;
        }

        try {
            $options = [
                'projection' => $fields,
                'limit' => $query->limit(),
                'sort' => $sort,
            ];

            // Skip some images if a page has been set
            if (($page = $query->page()) > 1) {
                $skip = $query->limit() * ($page - 1);
                $options['skip'] = $skip;
            }

            $cursor = $this->getImageCollection()->find($queryData, $options);

            foreach ($cursor as $image) {
                unset($image['_id']);
                $image['added'] = new DateTime('@' . $image['added'], new DateTimeZone('UTC'));
                $image['updated'] = new DateTime('@' . $image['updated'], new DateTimeZone('UTC'));
                $images[] = $this->bsonToArray->toArray($image->getArrayCopy());
            }

            // Update model
            $model->setHits($this->getImageCollection()->count($queryData));
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to search for images', 500, $e);
        }

        return $images;
    }

    /**
     * {@inheritdoc}
     */
    public function getImageProperties($user, $imageIdentifier) {
        try {
            $data = $this->getImageCollection()->findOne(
                ['user' => $user, 'imageIdentifier' => $imageIdentifier],
                array_fill_keys(['size', 'width', 'height', 'mime', 'extension', 'added', 'updated'], true)
            );
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch image data', 500, $e);
        }
        if ($data === null) {
            throw new DatabaseException('Image not found', 404);
        }
        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function load($user, $imageIdentifier, Image $image) {
        $data = $this->getImageProperties($user, $imageIdentifier);

        $image->setWidth($data['width'])
              ->setHeight($data['height'])
              ->setFilesize($data['size'])
              ->setMimeType($data['mime'])
              ->setExtension($data['extension'])
              ->setAddedDate(new DateTime('@' . $data['added'], new DateTimeZone('UTC')))
              ->setUpdatedDate(new DateTime('@' . $data['updated'], new DateTimeZone('UTC')));

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getLastModified(array $users, $imageIdentifier = null) {
        $query = [];

        if ($users) {
            $query['user']['$in'] = $users;
        }

        if ($imageIdentifier !== null) {
            $query['imageIdentifier'] = $imageIdentifier;
        }

        try {
            $data = $this->getImageCollection()->findOne($query, [
                'sort' => [
                    'updated' => -1,
                ],
                'projection' => [
                    'updated' => true
                ],
            ]);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch image data', 500, $e);
        }

        if ($data === null && $imageIdentifier !== null) {
            throw new DatabaseException('Image not found', 404);
        } else if ($data === null) {
            $data = ['updated' => time()];
        }

        return new DateTime('@' . $data['updated'], new DateTimeZone('UTC'));
    }

    /**
     * {@inheritdoc}
     */
    public function setLastModifiedNow($user, $imageIdentifier) {
        return $this->setLastModifiedTime($user, $imageIdentifier, new DateTime('@' . time(), new DateTimeZone('UTC')));
    }

    /**
     * {@inheritdoc}
     */
    public function setLastModifiedTime($user, $imageIdentifier, DateTime $time) {
        $data = $this->getImageCollection()->findOne([
            'user' => $user,
            'imageIdentifier' => $imageIdentifier,
        ]);

        if ($data === null) {
            throw new DatabaseException('Image not found', 404);
        }

        $this->getImageCollection()->updateOne(
            ['user' => $user, 'imageIdentifier' => $imageIdentifier],
            ['$set' => ['updated' => $time->getTimestamp()]]
        );

        return $time;
    }

    /**
     * {@inheritdoc}
     */
    public function getNumImages($user = null) {
        try {
            $query = [];

            if ($user) {
                $query['user'] = $user;
            }

            $result = (int) $this->getImageCollection()->count($query);

            return $result;
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch information from the database', 500, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getNumBytes($user = null) {
        try {
            $pipeline = [
                [
                    '$group' => [
                        '_id' => null,
                        'numBytes' => [
                            '$sum' => '$size',
                        ],
                    ],
                ],
            ];

            if ($user) {
                array_unshift($pipeline, [
                    '$match' => [
                        'user' => $user,
                    ],
                ]);
            }

            $docs = $this->getImageCollection()->aggregate($pipeline)->toArray();
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch information from the database', 500, $e);
        }

        return empty($docs) ? 0 : array_sum(array_map(function(BSONDocument $doc) : int {
            return $doc->numBytes;
        }, $docs));
    }

    /**
     * {@inheritdoc}
     */
    public function getNumUsers() {
        try {
            $result = (int) count($this->getImageCollection()->distinct('user'));

            return $result;
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch information from the database', 500, $e);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getStatus() {
        try {
            // Create a manager and try to get servers
            $manager = new Manager($this->params['server']);
            $manager->executeCommand($this->params['databaseName'], new Command(['ping' => 1]));

            return true;
        } catch (MongoException $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getImageMimeType($user, $imageIdentifier) {
        try {
            $data = $this->getImageCollection()->findOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
            ]);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to fetch image meta data', 500, $e);
        }

        if ($data === null) {
            throw new DatabaseException('Image not found', 404);
        }

        return $data['mime'];
    }

    /**
     * {@inheritdoc}
     */
    public function imageExists($user, $imageIdentifier) {
        $data = $this->getImageCollection()->findOne([
            'user' => $user,
            'imageIdentifier' => $imageIdentifier,
        ]);

        return $data !== null;
    }

    /**
     * {@inheritdoc}
     */
    public function insertShortUrl($shortUrlId, $user, $imageIdentifier, $extension = null, array $query = []) {
        try {
            $data = [
                'shortUrlId' => $shortUrlId,
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
                'extension' => $extension,
                'query' => serialize($query),
            ];

            $this->getShortUrlCollection()->insertOne($data);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to create short URL', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getShortUrlId($user, $imageIdentifier, $extension = null, array $query = []) {
        try {
            $result = $this->getShortUrlCollection()->findOne([
                'user' => $user,
                'imageIdentifier' => $imageIdentifier,
                'extension' => $extension,
                'query' => serialize($query),
            ], [
                'shortUrlId' => true,
            ]);

            if (!$result) {
                return null;
            }

            return $result['shortUrlId'];
        } catch (MongoException $e) {
            return null;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getShortUrlParams($shortUrlId) {
        try {
            $result = $this->getShortUrlCollection()->findOne([
                'shortUrlId' => $shortUrlId,
            ], [
                '_id' => false
            ]);

            if (!$result) {
                return null;
            }

            $result['query'] = unserialize($result['query']);

            return $result;
        } catch (MongoException $e) {
            return null;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function deleteShortUrls($user, $imageIdentifier, $shortUrlId = null) {
        $query = [
            'user' => $user,
            'imageIdentifier' => $imageIdentifier,
        ];

        if ($shortUrlId) {
            $query['shortUrlId'] = $shortUrlId;
        }

        try {
            $this->getShortUrlCollection()->deleteMany($query);
        } catch (MongoException $e) {
            throw new DatabaseException('Unable to delete short URLs', 500, $e);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getAllUsers() {
        return $this->getImageCollection()->distinct('user');
    }

    /**
     * Fetch the image collection
     *
     * @return MongoCollection
     */
    private function getImageCollection() {
        return $this->getCollection('image');
    }

    /**
     * Fetch the shortUrl collection
     *
     * @return MongoCollection
     */
    private function getShortUrlCollection() {
        return $this->getCollection('shortUrl');
    }

    /**
     * Get the mongo collection instance
     *
     * @param string $type "image" or "shortUrl"
     * @return MongoCollection
     */
    private function getCollection($type) {
        if ($this->collections[$type] === null) {
            try {
                $this->collections[$type] = $this->getMongoClient()->selectCollection(
                    $this->params['databaseName'],
                    $type
                );
            } catch (MongoException $e) {
                throw new DatabaseException('Could not select collection', 500, $e);
            }
        }

        return $this->collections[$type];
    }

    /**
     * Get the mongo client instance
     *
     * @return MongoClient
     */
    private function getMongoClient() {
        if ($this->mongoClient === null) {
            try {
                $this->mongoClient = new MongoClient($this->params['server'], $this->params['options']);
            } catch (MongoException $e) {
                throw new DatabaseException('Could not connect to database', 500, $e);
            }
        }

        return $this->mongoClient;
    }
}