AnnotationsTable.php

Go to the documentation of this file.

<?php

namespace Elgg\Database;

use Elgg\Database;
use Elgg\Database\Clauses\AnnotationWhereClause;
use Elgg\EventsService;
use Elgg\Traits\TimeUsing;

class AnnotationsTable {

    use TimeUsing;
    
    public const TABLE_NAME = 'annotations';
    
    public const DEFAULT_JOIN_ALIAS = 'a_table';

    public function __construct(protected Database $db, protected EventsService $events) {
    }

    public function get(int $id): ?\ElggAnnotation {
        $qb = Select::fromTable(self::TABLE_NAME);
        $qb->select('*');

        $where = new AnnotationWhereClause();
        $where->ids = $id;
        $qb->addClause($where);

        $row = $this->db->getDataRow($qb);
        return !empty($row) ? new \ElggAnnotation($row) : null;
    }

    public function delete(\ElggAnnotation $annotation): bool {
        if (!$annotation->canEdit()) {
            return false;
        }

        if (!$this->events->trigger('delete', 'annotation', $annotation)) {
            return false;
        }

        $qb = Delete::fromTable(self::TABLE_NAME);
        $qb->where($qb->compare('id', '=', $annotation->id, ELGG_VALUE_INTEGER));
        $deleted = $this->db->deleteData($qb);

        if ($deleted) {
            elgg_delete_river([
                'annotation_id' => $annotation->id,
                'limit' => false,
            ]);
        }

        return $deleted !== false;
    }

    public function create(\ElggAnnotation $annotation, \ElggEntity $entity): int|bool {
        if ($annotation->id) {
            return $this->update($annotation);
        }
        
        if (is_null($annotation->owner_guid) || is_null($annotation->name) || is_null($annotation->value)) {
            return false;
        }

        $annotation->entity_guid = $entity->guid;

        // @todo It looks like annotations permissions are not being checked anywhere...
        // Uncomment once tests have been updated
        // See #11418
        //if (!$entity->canAnnotate(0, $annotation->name)) {
        //  return false;
        //}

        if (!$this->events->triggerBefore('create', 'annotation', $annotation)) {
            return false;
        }

        $time_created = $this->getCurrentTime()->getTimestamp();

        $qb = Insert::intoTable(self::TABLE_NAME);
        $qb->values([
            'entity_guid' => $qb->param($annotation->entity_guid, ELGG_VALUE_INTEGER),
            'name' => $qb->param($annotation->name, ELGG_VALUE_STRING),
            'value' => $qb->param($annotation->value, $annotation->value_type === 'text' ? ELGG_VALUE_STRING : ELGG_VALUE_INTEGER),
            'value_type' => $qb->param($annotation->value_type, ELGG_VALUE_STRING),
            'owner_guid' => $qb->param($annotation->owner_guid, ELGG_VALUE_INTEGER),
            'time_created' => $qb->param($time_created, ELGG_VALUE_INTEGER),
            'access_id' => $qb->param($annotation->access_id, ELGG_VALUE_INTEGER),
        ]);

        $result = $this->db->insertData($qb);
        if ($result === false) {
            return false;
        }

        $annotation->id = $result;
        $annotation->time_created = $time_created;

        if (!$this->events->trigger('create', 'annotation', $annotation)) {
            elgg_delete_annotation_by_id($result);

            return false;
        }

        $this->events->triggerAfter('create', 'annotation', $annotation);

        return $result;
    }

    public function update(\ElggAnnotation $annotation): bool {
        if (!$annotation->canEdit()) {
            return false;
        }
        
        if (is_null($annotation->owner_guid) || is_null($annotation->name) || is_null($annotation->value)) {
            return false;
        }

        if (!$this->events->triggerBefore('update', 'annotation', $annotation)) {
            return false;
        }

        $qb = Update::table(self::TABLE_NAME);
        $qb->set('name', $qb->param($annotation->name, ELGG_VALUE_STRING))
            ->set('value', $qb->param($annotation->value, $annotation->value_type === 'integer' ? ELGG_VALUE_INTEGER : ELGG_VALUE_STRING))
            ->set('value_type', $qb->param($annotation->value_type, ELGG_VALUE_STRING))
            ->set('access_id', $qb->param($annotation->access_id, ELGG_VALUE_INTEGER))
            ->set('owner_guid', $qb->param($annotation->owner_guid, ELGG_VALUE_INTEGER))
            ->where($qb->compare('id', '=', $annotation->id, ELGG_VALUE_INTEGER));

        $result = $this->db->updateData($qb);

        if ($result === false) {
            return false;
        }

        $this->events->trigger('update', 'annotation', $annotation);
        $this->events->triggerAfter('update', 'annotation', $annotation);

        return $result;
    }

    public function find(array $options = []) {
        $options['metastring_type'] = 'annotations';
        $options = QueryOptions::normalizeMetastringOptions($options);

        return Annotations::find($options);
    }

    public function deleteAll(array $options): bool {
        if (!$this->isValidOptionsForBatchOperation($options)) {
            return false;
        }

        $options['batch'] = true;
        $options['batch_size'] = 50;
        $options['batch_inc_offset'] = false;

        $annotations = Annotations::find($options);
        $count = $annotations->count();

        if (!$count) {
            return true;
        }

        $success = 0;
        foreach ($annotations as $annotation) {
            if ($annotation->delete()) {
                $success++;
            }
        }

        return $success === $count;
    }
    
    protected function isValidOptionsForBatchOperation(array $options): bool {
        $required = [
            'guid', 'guids',
            'annotation_owner_guid', 'annotation_owner_guids',
            'annotation_name', 'annotation_names',
            'annotation_value', 'annotation_values',
        ];

        foreach ($required as $key) {
            // check that it exists and is something.
            if (isset($options[$key]) && !elgg_is_empty($options[$key])) {
                return true;
            }
        }

        return false;
    }

    public function exists(int $entity_guid, string $name, int $owner_guid): bool {
        if (!$owner_guid) {
            return false;
        }

        $qb = Select::fromTable(self::TABLE_NAME);
        $qb->select('id');
        $qb->where($qb->compare('owner_guid', '=', $owner_guid, ELGG_VALUE_INTEGER))
            ->andWhere($qb->compare('entity_guid', '=', $entity_guid, ELGG_VALUE_INTEGER))
            ->andWhere($qb->compare('name', '=', $name, ELGG_VALUE_STRING));

        $result = $this->db->getDataRow($qb);

        return !empty($result) && $result->id;
    }
}