nextcloud/apps/dav/lib/BackgroundJob/UpdateCalendarResourcesRoom...

354 lines
10 KiB
PHP
Raw Normal View History

<?php
/**
* @copyright 2018, Georg Ehrke <oc.list@georgehrke.com>
*
* @author Georg Ehrke <oc.list@georgehrke.com>
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
namespace OCA\DAV\BackgroundJob;
use OC\BackgroundJob\TimedJob;
use OCA\DAV\CalDAV\CalDavBackend;
use OCP\Calendar\BackendTemporarilyUnavailableException;
use OCP\Calendar\Resource\IManager as IResourceManager;
use OCP\Calendar\Resource\IResource;
use OCP\Calendar\Room\IManager as IRoomManager;
use OCP\Calendar\Room\IRoom;
use OCP\IDBConnection;
class UpdateCalendarResourcesRoomsBackgroundJob extends TimedJob {
/** @var IResourceManager */
private $resourceManager;
/** @var IRoomManager */
private $roomManager;
/** @var IDBConnection */
private $db;
/** @var CalDavBackend */
private $calDavBackend;
/** @var string */
private $resourceDbTable;
/** @var string */
private $resourcePrincipalUri;
/** @var string */
private $roomDbTable;
/** @var string */
private $roomPrincipalUri;
/**
* UpdateCalendarResourcesRoomsBackgroundJob constructor.
*
* @param IResourceManager $resourceManager
* @param IRoomManager $roomManager
* @param IDBConnection $dbConnection
* @param CalDavBackend $calDavBackend
*/
public function __construct(IResourceManager $resourceManager, IRoomManager $roomManager,
IDBConnection $dbConnection, CalDavBackend $calDavBackend) {
$this->resourceManager = $resourceManager;
$this->roomManager = $roomManager;
$this->db = $dbConnection;
$this->calDavBackend = $calDavBackend;
$this->resourceDbTable = 'calendar_resources';
$this->resourcePrincipalUri = 'principals/calendar-resources';
$this->roomDbTable = 'calendar_rooms';
$this->roomPrincipalUri = 'principals/calendar-rooms';
// run once an hour
$this->setInterval(60 * 60);
}
/**
* @param $argument
*/
public function run($argument) {
$this->runResources();
$this->runRooms();
}
/**
* run timed job for resources
*/
private function runResources() {
$resourceBackends = $this->resourceManager->getBackends();
$cachedResources = $this->getCached($this->resourceDbTable);
$cachedResourceIds = $this->getCachedResourceIds($cachedResources);
$remoteResourceIds = [];
foreach($resourceBackends as $resourceBackend) {
try {
$remoteResourceIds[$resourceBackend->getBackendIdentifier()] =
$resourceBackend->listAllResources();
} catch(BackendTemporarilyUnavailableException $ex) {
// If the backend is temporarily unavailable
// ignore this backend in this execution
unset($cachedResourceIds[$resourceBackend->getBackendIdentifier()]);
}
}
$sortedResources = $this->sortByNewDeletedExisting($cachedResourceIds, $remoteResourceIds);
foreach($sortedResources['new'] as $backendId => $newResources) {
foreach ($newResources as $newResource) {
$backend = $this->resourceManager->getBackend($backendId);
if ($backend === null) {
continue;
}
$resource = $backend->getResource($newResource);
$this->addToCache($this->resourceDbTable, $resource);
}
}
foreach($sortedResources['deleted'] as $backendId => $deletedResources) {
foreach ($deletedResources as $deletedResource) {
$this->deleteFromCache($this->resourceDbTable,
$this->resourcePrincipalUri, $backendId, $deletedResource);
}
}
foreach($sortedResources['edited'] as $backendId => $editedResources) {
foreach ($editedResources as $editedResource) {
$backend = $this->resourceManager->getBackend($backendId);
if ($backend === null) {
continue;
}
$resource = $backend->getResource($editedResource);
$this->updateCache($this->resourceDbTable, $resource);
}
}
}
/**
* run timed job for rooms
*/
private function runRooms() {
$roomBackends = $this->roomManager->getBackends();
$cachedRooms = $this->getCached($this->roomDbTable);
$cachedRoomIds = $this->getCachedRoomIds($cachedRooms);
$remoteRoomIds = [];
foreach($roomBackends as $roomBackend) {
try {
$remoteRoomIds[$roomBackend->getBackendIdentifier()] =
$roomBackend->listAllRooms();
} catch(BackendTemporarilyUnavailableException $ex) {
// If the backend is temporarily unavailable
// ignore this backend in this execution
unset($cachedRoomIds[$roomBackend->getBackendIdentifier()]);
}
}
$sortedRooms = $this->sortByNewDeletedExisting($cachedRoomIds, $remoteRoomIds);
foreach($sortedRooms['new'] as $backendId => $newRooms) {
foreach ($newRooms as $newRoom) {
$backend = $this->roomManager->getBackend($backendId);
if ($backend === null) {
continue;
}
$resource = $backend->getRoom($newRoom);
$this->addToCache($this->roomDbTable, $resource);
}
}
foreach($sortedRooms['deleted'] as $backendId => $deletedRooms) {
foreach ($deletedRooms as $deletedRoom) {
$this->deleteFromCache($this->roomDbTable,
$this->roomPrincipalUri, $backendId, $deletedRoom);
}
}
foreach($sortedRooms['edited'] as $backendId => $editedRooms) {
foreach ($editedRooms as $editedRoom) {
$backend = $this->roomManager->getBackend($backendId);
if ($backend === null) {
continue;
}
$resource = $backend->getRoom($editedRoom);
$this->updateCache($this->roomDbTable, $resource);
}
}
}
/**
* get cached db rows for resources / rooms
* @param string $tableName
* @return array
*/
private function getCached($tableName):array {
$query = $this->db->getQueryBuilder();
$query->select('*')->from($tableName);
$rows = [];
$stmt = $query->execute();
while($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
$rows[] = $row;
}
return $rows;
}
/**
* @param array $cachedResources
* @return array
*/
private function getCachedResourceIds(array $cachedResources):array {
$cachedResourceIds = [];
foreach ($cachedResources as $cachedResource) {
if (!isset($cachedResourceIds[$cachedResource['backend_id']])) {
$cachedResourceIds[$cachedResource['backend_id']] = [];
}
$cachedResourceIds[$cachedResource['backend_id']][] =
$cachedResource['resource_id'];
}
return $cachedResourceIds;
}
/**
* @param array $cachedRooms
* @return array
*/
private function getCachedRoomIds(array $cachedRooms):array {
$cachedRoomIds = [];
foreach ($cachedRooms as $cachedRoom) {
if (!isset($cachedRoomIds[$cachedRoom['backend_id']])) {
$cachedRoomIds[$cachedRoom['backend_id']] = [];
}
$cachedRoomIds[$cachedRoom['backend_id']][] =
$cachedRoom['resource_id'];
}
return $cachedRoomIds;
}
/**
* sort list of ids by whether they appear only in the backend /
* only in the cache / in both
*
* @param array $cached
* @param array $remote
* @return array
*/
private function sortByNewDeletedExisting(array $cached, array $remote):array {
$sorted = [
'new' => [],
'deleted' => [],
'edited' => [],
];
$backendIds = array_merge(array_keys($cached), array_keys($remote));
foreach($backendIds as $backendId) {
if (!isset($cached[$backendId])) {
$sorted['new'][$backendId] = $remote[$backendId];
} elseif (!isset($remote[$backendId])) {
$sorted['deleted'][$backendId] = $cached[$backendId];
} else {
$sorted['new'][$backendId] = array_diff($remote[$backendId], $cached[$backendId]);
$sorted['deleted'][$backendId] = array_diff($cached[$backendId], $remote[$backendId]);
$sorted['edited'][$backendId] = array_intersect($remote[$backendId], $cached[$backendId]);
}
}
return $sorted;
}
/**
* add entry to cache that exists remotely but not yet in cache
*
* @param string $table
* @param IResource|IRoom $remote
*/
private function addToCache($table, $remote) {
$query = $this->db->getQueryBuilder();
$query->insert($table)
->values([
'backend_id' => $query->createNamedParameter($remote->getBackend()->getBackendIdentifier()),
'resource_id' => $query->createNamedParameter($remote->getId()),
'email' => $query->createNamedParameter($remote->getEMail()),
'displayname' => $query->createNamedParameter($remote->getDisplayName()),
'group_restrictions' => $query->createNamedParameter(
$this->serializeGroupRestrictions(
$remote->getGroupRestrictions()
))
])
->execute();
}
/**
* delete entry from cache that does not exist anymore remotely
*
* @param string $table
* @param string $principalUri
* @param string $backendId
* @param string $resourceId
*/
private function deleteFromCache($table, $principalUri, $backendId, $resourceId) {
$query = $this->db->getQueryBuilder();
$query->delete($table)
->where($query->expr()->eq('backend_id', $query->createNamedParameter($backendId)))
->andWhere($query->expr()->eq('resource_id', $query->createNamedParameter($resourceId)))
->execute();
$calendar = $this->calDavBackend->getCalendarByUri($principalUri, implode('-', [$backendId, $resourceId]));
if ($calendar !== null) {
$this->calDavBackend->deleteCalendar($calendar['id']);
}
}
/**
* update an existing entry in cache
*
* @param string $table
* @param IResource|IRoom $remote
*/
private function updateCache($table, $remote) {
$query = $this->db->getQueryBuilder();
$query->update($table)
->set('email', $query->createNamedParameter($remote->getEMail()))
->set('displayname', $query->createNamedParameter($remote->getDisplayName()))
->set('group_restrictions', $query->createNamedParameter(
$this->serializeGroupRestrictions(
$remote->getGroupRestrictions()
)))
->where($query->expr()->eq('backend_id', $query->createNamedParameter($remote->getBackend()->getBackendIdentifier())))
->andWhere($query->expr()->eq('resource_id', $query->createNamedParameter($remote->getId())))
->execute();
}
/**
* serialize array of group restrictions to store them in database
*
* @param array $groups
* @return string
*/
private function serializeGroupRestrictions(array $groups):string {
return \json_encode($groups);
}
}