memories/lib/Db/TimelineWrite.php

288 lines
10 KiB
PHP
Raw Normal View History

2022-08-20 02:53:21 +00:00
<?php
2022-10-19 17:10:36 +00:00
2022-08-20 02:53:21 +00:00
declare(strict_types=1);
namespace OCA\Memories\Db;
use OCA\Memories\AppInfo\Application;
use OCA\Memories\Exif;
2022-10-19 17:10:36 +00:00
use OCP\DB\QueryBuilder\IQueryBuilder;
2022-08-20 02:53:21 +00:00
use OCP\Files\File;
use OCP\IDBConnection;
2022-10-25 00:47:25 +00:00
use OCP\IPreview;
2023-02-06 02:29:09 +00:00
use Psr\Log\LoggerInterface;
2022-08-20 02:53:21 +00:00
require_once __DIR__.'/../ExifFields.php';
2023-02-06 02:34:54 +00:00
const DELETE_TABLES = ['memories', 'memories_livephoto', 'memories_places'];
2023-02-09 08:35:35 +00:00
const TRUNCATE_TABLES = ['memories_mapclusters'];
2023-02-06 02:34:54 +00:00
2022-10-19 17:10:36 +00:00
class TimelineWrite
{
2023-02-09 05:55:12 +00:00
use TimelineWriteMap;
use TimelineWriteOrphans;
use TimelineWritePlaces;
2022-09-09 07:31:42 +00:00
protected IDBConnection $connection;
2022-10-25 00:47:25 +00:00
protected IPreview $preview;
2022-11-22 11:10:25 +00:00
protected LivePhoto $livePhoto;
2022-08-20 02:53:21 +00:00
2022-12-04 17:40:58 +00:00
public function __construct(IDBConnection $connection)
2022-10-19 17:10:36 +00:00
{
2022-09-09 07:31:42 +00:00
$this->connection = $connection;
$this->preview = \OC::$server->get(IPreview::class);
2022-11-22 11:10:25 +00:00
$this->livePhoto = new LivePhoto($connection);
2022-09-09 07:31:42 +00:00
}
2022-08-20 02:53:21 +00:00
/**
2022-10-19 17:10:36 +00:00
* Check if a file has a valid mimetype for processing.
*
* @return int 0 for invalid, 1 for image, 2 for video
*/
2022-10-19 17:10:36 +00:00
public function getFileType(File $file): int
{
$mime = $file->getMimeType();
2022-10-19 17:10:36 +00:00
if (\in_array($mime, Application::IMAGE_MIMES, true)) {
2022-10-25 17:25:26 +00:00
// Make sure preview generator supports the mime type
if (!$this->preview->isMimeSupported($mime)) {
return 0;
}
return 1;
2022-10-19 17:10:36 +00:00
}
if (\in_array($mime, Application::VIDEO_MIMES, true)) {
return 2;
}
2022-10-19 17:10:36 +00:00
return 0;
}
2022-08-20 02:53:21 +00:00
/**
2022-10-19 17:10:36 +00:00
* Process a file to insert Exif data into the database.
*
2023-03-07 20:27:25 +00:00
* @param File $file File node to process
* @param int $force 0 = none, 1 = force, 2 = force if orphan
2023-03-07 20:20:07 +00:00
*
2022-08-23 09:35:51 +00:00
* @return int 2 if processed, 1 if skipped, 0 if not valid
2022-08-20 02:53:21 +00:00
*/
2022-09-13 17:39:38 +00:00
public function processFile(
File &$file,
2023-03-07 20:20:07 +00:00
int $force = 0
2022-09-13 17:39:38 +00:00
): int {
2022-08-20 02:53:21 +00:00
// There is no easy way to UPSERT in a standard SQL way, so just
// do multiple calls. The worst that can happen is more updates,
// but that's not a big deal.
// https://stackoverflow.com/questions/15252213/sql-standard-upsert-call
// Check if we want to process this file
$fileType = $this->getFileType($file);
2022-10-19 17:10:36 +00:00
$isvideo = (2 === $fileType);
if (!$fileType) {
2022-08-23 09:35:51 +00:00
return 0;
2022-08-20 02:53:21 +00:00
}
// Get parameters
$mtime = $file->getMtime();
$fileId = $file->getId();
// Check if need to update
2022-09-11 02:22:57 +00:00
$query = $this->connection->getQueryBuilder();
$query->select('fileid', 'mtime', 'mapcluster', 'orphan', 'lat', 'lon')
2022-09-11 02:22:57 +00:00
->from('memories')
2022-10-19 17:10:36 +00:00
->where($query->expr()->eq('fileid', $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)))
;
2022-09-25 11:30:28 +00:00
$cursor = $query->executeQuery();
$prevRow = $cursor->fetch();
$cursor->closeCursor();
2022-11-22 11:10:25 +00:00
// Check in live-photo table in case this is a video part of a Live Photo
2022-11-22 11:10:25 +00:00
if (!$prevRow) {
$query = $this->connection->getQueryBuilder();
$query->select('fileid', 'mtime')
->from('memories_livephoto')
->where($query->expr()->eq('fileid', $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)))
;
$cursor = $query->executeQuery();
$prevRow = $cursor->fetch();
$cursor->closeCursor();
}
2023-03-07 20:20:07 +00:00
// Check if a forced update is required
$isForced = (1 === $force);
if (2 === $force) {
2023-03-07 20:27:25 +00:00
$isForced = !$prevRow
2023-03-07 20:20:07 +00:00
// Could be live video, force regardless
2023-03-07 20:27:25 +00:00
|| !\array_key_exists('orphan', $prevRow)
2023-03-07 20:20:07 +00:00
// If orphan, force for sure
2023-03-07 20:27:25 +00:00
|| $prevRow['orphan'];
2023-03-07 20:20:07 +00:00
}
// Skip if not forced and file has not changed
if (!$isForced && $prevRow && ((int) $prevRow['mtime'] === $mtime)) {
2022-08-23 09:35:51 +00:00
return 1;
2022-08-20 02:53:21 +00:00
}
// Get exif data
$exif = [];
2022-10-19 17:10:36 +00:00
2022-08-20 02:53:21 +00:00
try {
$exif = Exif::getExifFromFile($file);
2022-10-19 17:10:36 +00:00
} catch (\Exception $e) {
}
2022-08-20 02:53:21 +00:00
// Hand off if Live Photo video part
2022-11-22 11:10:25 +00:00
if ($isvideo && $this->livePhoto->isVideoPart($exif)) {
$this->livePhoto->processVideoPart($file, $exif);
return 2;
}
2022-08-20 02:53:21 +00:00
// Get more parameters
$dateTaken = Exif::getDateTaken($file, $exif);
$dayId = floor($dateTaken / 86400);
$dateTaken = gmdate('Y-m-d H:i:s', $dateTaken);
2022-10-15 19:15:07 +00:00
[$w, $h] = Exif::getDimensions($exif);
2023-01-26 19:52:19 +00:00
$liveid = $this->livePhoto->getLivePhotoId($file, $exif);
2022-08-20 02:53:21 +00:00
2022-11-10 03:48:03 +00:00
// Video parameters
$videoDuration = 0;
if ($isvideo) {
$videoDuration = round((float) ($exif['Duration'] ?? $exif['TrackDuration'] ?? 0));
2022-11-10 03:48:03 +00:00
}
2022-11-22 10:36:04 +00:00
// Clean up EXIF to keep only useful metadata
$filteredExif = [];
foreach ($exif as $key => $value) {
2022-11-22 10:36:04 +00:00
// Truncate any fields > 2048 chars
2022-11-07 21:13:16 +00:00
if (\is_string($value) && \strlen($value) > 2048) {
$value = substr($value, 0, 2048);
2022-11-07 21:13:16 +00:00
}
2022-11-22 10:36:04 +00:00
// Only keep fields in the whitelist
if (\array_key_exists($key, EXIF_FIELDS_LIST)) {
$filteredExif[$key] = $value;
2022-11-22 10:36:04 +00:00
}
2022-11-07 21:13:16 +00:00
}
// Store JSON string
$exifJson = json_encode($filteredExif);
2022-11-07 21:13:16 +00:00
// Store error if data > 64kb
2022-11-21 09:43:17 +00:00
if (\is_string($exifJson)) {
if (\strlen($exifJson) > 65535) {
$exifJson = json_encode(['error' => 'Exif data too large']);
}
} else {
$exifJson = json_encode(['error' => 'Exif data encoding error']);
2022-11-07 21:13:16 +00:00
}
2023-02-05 21:43:25 +00:00
// Store location data
$lat = \array_key_exists('GPSLatitude', $exif) ? (float) $exif['GPSLatitude'] : null;
$lon = \array_key_exists('GPSLongitude', $exif) ? (float) $exif['GPSLongitude'] : null;
$oldLat = $prevRow ? (float) $prevRow['lat'] : null;
$oldLon = $prevRow ? (float) $prevRow['lon'] : null;
2023-02-09 08:35:35 +00:00
$mapCluster = $prevRow ? (int) $prevRow['mapcluster'] : -1;
if ($lat || $lon || $oldLat || $oldLon) {
2023-02-09 08:35:35 +00:00
try {
$mapCluster = $this->mapGetCluster($mapCluster, $lat, $lon, $oldLat, $oldLon);
2023-02-09 08:35:35 +00:00
} catch (\Error $e) {
$logger = \OC::$server->get(LoggerInterface::class);
$logger->log(3, 'Error updating map cluster data: '.$e->getMessage(), ['app' => 'memories']);
}
2023-02-06 02:29:09 +00:00
try {
2023-02-09 05:55:12 +00:00
$this->updatePlacesData($fileId, $lat, $lon);
2023-02-08 03:48:19 +00:00
} catch (\Error $e) {
2023-02-06 02:29:09 +00:00
$logger = \OC::$server->get(LoggerInterface::class);
2023-02-09 08:35:35 +00:00
$logger->log(3, 'Error updating places data: '.$e->getMessage(), ['app' => 'memories']);
2023-02-06 02:29:09 +00:00
}
2023-02-05 21:43:25 +00:00
}
2023-02-10 17:36:20 +00:00
// NULL if invalid
$mapCluster = $mapCluster <= 0 ? null : $mapCluster;
2023-02-08 18:45:25 +00:00
// Parameters for insert or update
$params = [
'fileid' => $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT),
'objectid' => $query->createNamedParameter((string) $fileId, IQueryBuilder::PARAM_STR),
'dayid' => $query->createNamedParameter($dayId, IQueryBuilder::PARAM_INT),
'datetaken' => $query->createNamedParameter($dateTaken, IQueryBuilder::PARAM_STR),
'mtime' => $query->createNamedParameter($mtime, IQueryBuilder::PARAM_INT),
'isvideo' => $query->createNamedParameter($isvideo, IQueryBuilder::PARAM_INT),
'video_duration' => $query->createNamedParameter($videoDuration, IQueryBuilder::PARAM_INT),
'w' => $query->createNamedParameter($w, IQueryBuilder::PARAM_INT),
'h' => $query->createNamedParameter($h, IQueryBuilder::PARAM_INT),
'exif' => $query->createNamedParameter($exifJson, IQueryBuilder::PARAM_STR),
'liveid' => $query->createNamedParameter($liveid, IQueryBuilder::PARAM_STR),
'lat' => $query->createNamedParameter($lat, IQueryBuilder::PARAM_STR),
'lon' => $query->createNamedParameter($lon, IQueryBuilder::PARAM_STR),
2023-02-09 08:35:35 +00:00
'mapcluster' => $query->createNamedParameter($mapCluster, IQueryBuilder::PARAM_INT),
2023-02-08 18:45:25 +00:00
];
2022-08-20 02:53:21 +00:00
if ($prevRow) {
// Update existing row
// No need to set objectid again
2022-09-11 02:22:57 +00:00
$query->update('memories')
2022-10-19 17:10:36 +00:00
->where($query->expr()->eq('fileid', $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)))
;
2023-02-08 18:45:25 +00:00
foreach ($params as $key => $value) {
if ('objectid' !== $key && 'fileid' !== $key) {
$query->set($key, $value);
}
}
2022-09-11 02:22:57 +00:00
$query->executeStatement();
2022-08-20 02:53:21 +00:00
} else {
2022-08-22 18:42:06 +00:00
// Try to create new row
try {
2023-02-08 18:45:25 +00:00
$query->insert('memories')->values($params);
2022-09-11 02:22:57 +00:00
$query->executeStatement();
2022-08-22 18:42:06 +00:00
} catch (\Exception $ex) {
2022-10-19 17:10:36 +00:00
error_log('Failed to create memories record: '.$ex->getMessage());
2022-08-22 18:42:06 +00:00
}
2022-08-20 02:53:21 +00:00
}
2022-08-23 09:35:51 +00:00
return 2;
2022-08-20 02:53:21 +00:00
}
/**
2022-10-19 17:10:36 +00:00
* Remove a file from the exif database.
2022-08-20 02:53:21 +00:00
*/
2022-10-19 17:10:36 +00:00
public function deleteFile(File &$file)
{
2023-02-09 16:40:26 +00:00
// Get full record
$query = $this->connection->getQueryBuilder();
$query->select('*')
->from('memories')
->where($query->expr()->eq('fileid', $query->createNamedParameter($file->getId(), IQueryBuilder::PARAM_INT)))
;
$record = $query->executeQuery()->fetch();
// Delete all records regardless of existence
2023-02-06 02:47:10 +00:00
foreach (DELETE_TABLES as $table) {
2022-11-23 18:40:41 +00:00
$query = $this->connection->getQueryBuilder();
$query->delete($table)
->where($query->expr()->eq('fileid', $query->createNamedParameter($file->getId(), IQueryBuilder::PARAM_INT)))
;
$query->executeStatement();
2023-02-06 02:34:54 +00:00
}
2023-02-09 16:40:26 +00:00
// Delete from map cluster
if ($record && ($cid = (int) $record['mapcluster']) > 0) {
2023-02-10 17:29:42 +00:00
$this->mapRemoveFromCluster($cid, (float) $record['lat'], (float) $record['lon']);
2023-02-09 16:40:26 +00:00
}
2022-08-20 02:53:21 +00:00
}
2022-09-11 00:15:40 +00:00
/**
* Clear the entire index. Does not need confirmation!
2022-10-19 17:10:36 +00:00
*
2022-09-11 00:15:40 +00:00
* @param File $file
*/
2022-10-19 17:10:36 +00:00
public function clear()
{
2022-11-23 09:49:00 +00:00
$p = $this->connection->getDatabasePlatform();
2023-02-09 08:35:35 +00:00
foreach (array_merge(DELETE_TABLES, TRUNCATE_TABLES) as $table) {
2023-02-06 02:34:54 +00:00
$this->connection->executeStatement($p->getTruncateTableSQL('*PREFIX*'.$table, false));
}
2022-09-11 00:15:40 +00:00
}
2022-10-19 17:10:36 +00:00
}