class.ilBuddyList.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2015 ILIAS open source, Extended GPL, see docs/LICENSE */

require_once 'Services/Contact/BuddySystem/classes/class.ilBuddySystemRelationRepository.php';
require_once 'Services/Contact/BuddySystem/classes/class.ilBuddySystemRelationCollection.php';
require_once 'Services/Contact/BuddySystem/classes/class.ilBuddySystemRelation.php';
require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemException.php';
require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateAlreadyGivenException.php';
require_once 'Services/Contact/BuddySystem/classes/states/class.ilBuddySystemLinkedRelationState.php';
require_once 'Services/Contact/BuddySystem/classes/states/class.ilBuddySystemUnlinkedRelationState.php';
require_once 'Services/Contact/BuddySystem/classes/states/class.ilBuddySystemRequestedRelationState.php';
require_once 'Services/Contact/BuddySystem/classes/states/class.ilBuddySystemIgnoredRequestRelationState.php';

class ilBuddyList
{
    protected $owner_id;

    protected $relations;

    protected $repository;

    protected static $instances = array();

    protected $relations_read = false;

    protected $event_handler;

    public static function getInstanceByUserId($usr_id)
    {
        if (ilObjUser::_isAnonymous($usr_id)) {
            throw new ilBuddySystemException(sprintf("You cannot create an instance for the anonymous user (id: %s)", $usr_id));
        }

        if (isset(self::$instances[$usr_id])) {
            return self::$instances[$usr_id];
        }

        self::$instances[$usr_id] = new self($usr_id);
        return self::$instances[$usr_id];
    }

    public static function getInstanceByGlobalUser()
    {
        global $DIC;

        return self::getInstanceByUserId($DIC->user()->getId());
    }

    protected function __construct($owner_id)
    {
        global $DIC;

        $this->setOwnerId($owner_id);
        $this->setRepository(new ilBuddySystemRelationRepository($this->getOwnerId()));

        $this->event_handler = $DIC['ilAppEventHandler'];
    }

    public function reset()
    {
        $this->relations_read = false;
        $this->relations      = null;
        unset(self::$instances[$this->getOwnerId()]);
    }

    public function getRepository()
    {
        return $this->repository;
    }

    public function setRepository($repository)
    {
        $this->repository = $repository;
    }

    public function readFromRepository()
    {
        $this->setRelations(new ilBuddySystemRelationCollection((array) $this->getRepository()->getAll()));
    }

    protected function performLazyLoading()
    {
        if (!$this->relations_read) {
            $this->readFromRepository();
            $this->relations_read = true;
        }
    }

    public function getRelations()
    {
        if (null === $this->relations) {
            $this->performLazyLoading();
        }

        return $this->relations;
    }

    public function setRelations(ilBuddySystemRelationCollection $relations)
    {
        $this->relations = $relations;
    }

    public function getOwnerId()
    {
        return $this->owner_id;
    }

    public function getLinkedRelations()
    {
        return $this->getRelations()->filter(function (ilBuddySystemRelation $relation) {
            return $relation->isLinked();
        });
    }

    public function getRequestRelationsForOwner()
    {
        $owner = $this->getOwnerId();
        return $this->getRequestedRelations()->filter(function (ilBuddySystemRelation $relation) use ($owner) {
            return $relation->getBuddyUserId() == $owner;
        });
    }

    public function getRequestRelationsByOwner()
    {
        $owner = $this->getOwnerId();
        return $this->getRequestedRelations()->filter(function (ilBuddySystemRelation $relation) use ($owner) {
            return $relation->getUserId() == $owner;
        });
    }

    public function getRequestedRelations()
    {
        return $this->getRelations()->filter(function (ilBuddySystemRelation $relation) {
            return $relation->isRequested();
        });
    }

    public function getIgnoredRelationsForOwner()
    {
        $owner = $this->getOwnerId();
        return $this->getIgnoredRelations()->filter(function (ilBuddySystemRelation $relation) use ($owner) {
            return $relation->getBuddyUserId() == $owner;
        });
    }

    public function getIgnoredRelationsByOwner()
    {
        $owner = $this->getOwnerId();
        return $this->getIgnoredRelations()->filter(function (ilBuddySystemRelation $relation) use ($owner) {
            return $relation->getUserId() == $owner;
        });
    }

    public function getIgnoredRelations()
    {
        return $this->getRelations()->filter(function (ilBuddySystemRelation $relation) {
            return $relation->isIgnored();
        });
    }

    public function getRelationUserIds()
    {
        return $this->getRelations()->getKeys();
    }

    public function setOwnerId($owner_id)
    {
        if (!is_numeric($owner_id)) {
            throw new InvalidArgumentException(sprintf("Please pass a numeric owner id, given: %s", var_export($owner_id, 1)));
        }

        $this->owner_id = $owner_id;
    }

    protected function getRelationTargetUserId(ilBuddySystemRelation $relation)
    {
        return ($relation->getUserId() == $this->getOwnerId() ? $relation->getBuddyUserId() : $relation->getUserId());
    }

    public function getRelationByUserId($usr_id)
    {
        if (!is_numeric($usr_id)) {
            throw new InvalidArgumentException(sprintf("Please pass a numeric owner id, given: %s", var_export($usr_id, 1)));
        }

        if ($this->getRelations()->containsKey($usr_id)) {
            return $this->getRelations()->get($usr_id);
        }

        require_once 'Services/Contact/BuddySystem/classes/states/class.ilBuddySystemRelationStateFactory.php';
        $relation = new ilBuddySystemRelation(ilBuddySystemRelationStateFactory::getInstance()->getInitialState());
        $relation->setIsOwnedByRequest(true);
        $relation->setUserId($this->getOwnerId());
        $relation->setBuddyUserId($usr_id);
        $relation->setTimestamp(time());

        $this->getRelations()->set($usr_id, $relation);

        return $relation;
    }

    public function link(ilBuddySystemRelation $relation)
    {
        try {
            if ($relation->isLinked()) {
                require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateAlreadyGivenException.php';
                throw new ilBuddySystemRelationStateAlreadyGivenException('buddy_bs_action_already_linked');
            }

            if ($this->getOwnerId() == $relation->getUserId()) {
                throw new ilBuddySystemException("You can only accept a request when you are not the initiator");
            }

            $relation->link();

            $this->getRepository()->save($relation);
            $this->getRelations()->set($this->getRelationTargetUserId($relation), $relation);
        } catch (ilBuddySystemRelationStateException $e) {
            throw $e;
        }

        return $this;
    }

    public function unlink(ilBuddySystemRelation $relation)
    {
        try {
            $relation->unlink();
            $this->getRepository()->save($relation);
            $this->getRelations()->set($this->getRelationTargetUserId($relation), $relation);
        } catch (ilBuddySystemException $e) {
            if ($relation->isUnlinked()) {
                require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateAlreadyGivenException.php';
                throw new ilBuddySystemRelationStateAlreadyGivenException('buddy_bs_action_already_unlinked');
            }

            throw $e;
        }

        return $this;
    }

    public function request(ilBuddySystemRelation $relation)
    {
        if (ilObjUser::_isAnonymous($this->getRelationTargetUserId($relation))) {
            throw new ilBuddySystemException(sprintf("You cannot add the anonymous user to the list (id: %s)", $this->getRelationTargetUserId($relation)));
        }

        if (!strlen(ilObjUser::_lookupLogin($this->getRelationTargetUserId($relation)))) {
            throw new ilBuddySystemException(sprintf("You cannot add a non existing user (id: %s)", $this->getRelationTargetUserId($relation)));
        }

        try {
            $relation->request();
            $this->getRepository()->save($relation);
            $this->getRelations()->set($this->getRelationTargetUserId($relation), $relation);
        } catch (ilBuddySystemException $e) {
            if ($relation->isRequested()) {
                require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateAlreadyGivenException.php';
                throw new ilBuddySystemRelationStateAlreadyGivenException('buddy_bs_action_already_requested');
            }

            throw $e;
        }

        $this->event_handler->raise(
            'Services/Contact',
            'contactRequested',
            array(
                'usr_id' => $this->getRelationTargetUserId($relation)
            )
        );

        return $this;
    }

    public function ignore(ilBuddySystemRelation $relation)
    {
        try {
            if ($relation->isLinked()) {
                require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateTransitionException.php';
                throw new ilBuddySystemRelationStateTransitionException('buddy_bs_action_already_linked');
            }

            if ($this->getOwnerId() == $relation->getUserId()) {
                throw new ilBuddySystemException("You can only ignore a request when you are not the initiator");
            }

            $relation->ignore();

            $this->getRepository()->save($relation);
            $this->getRelations()->set($this->getRelationTargetUserId($relation), $relation);
        } catch (ilBuddySystemException $e) {
            if ($relation->isIgnored()) {
                require_once 'Services/Contact/BuddySystem/exceptions/class.ilBuddySystemRelationStateAlreadyGivenException.php';
                throw new ilBuddySystemRelationStateAlreadyGivenException('buddy_bs_action_already_ignored');
            }

            throw $e;
        }

        return $this;
    }

    public function destroy()
    {
        $this->getRepository()->destroy();
        $this->getRelations()->clear();
        return $this;
    }
}