OC\Collaboration\Reference\Reference

Complexity

Total Complexity

23

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getId()	0	2	1
A	setRichObject()	0	3	1
A	setImageContentType()	0	2	1
A	getOpenGraphObject()	0	7	1
A	setAccessible()	0	2	1
A	toCache()	0	11	1
A	getRichObjectType()	0	5	2
A	setTitle()	0	2	1
A	getRichObject()	0	5	2
A	getImageContentType()	0	2	1
A	getImageUrl()	0	2	1
A	jsonSerialize()	0	6	1
A	fromCache()	0	10	1
A	getTitle()	0	2	1
A	getUrl()	0	2	1
A	setUrl()	0	2	1
A	setImageUrl()	0	2	1
A	getDescription()	0	2	1
A	__construct()	0	2	1
A	setDescription()	0	2	1
A	getAccessible()	0	2	1

<?php

declare(strict_types=1);

/**
 * @copyright Copyright (c) 2022 Julius Härtl <jus@bitgrid.net>
 *
 * @author Julius Härtl <jus@bitgrid.net>
 *
 * @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 OC\Collaboration\Reference;

use OCP\Collaboration\Reference\IReference;

class Reference implements IReference {
	private string $reference;

	private bool $accessible = true;

	private ?string $title = null;
	private ?string $description = null;
	private ?string $imageUrl = null;
	private ?string $contentType = null;
	private ?string $url = null;

	private ?string $richObjectType = null;
	private ?array $richObject = null;

	public function __construct(string $reference) {
		$this->reference = $reference;
	}

	public function getId(): string {
		return $this->reference;
	}

	public function setAccessible(bool $accessible): void {
		$this->accessible = $accessible;
	}

	public function getAccessible(): bool {
		return $this->accessible;
	}

	public function setTitle(string $title): void {
		$this->title = $title;
	}

	public function getTitle(): string {
		return $this->title ?? $this->reference;
	}

	public function setDescription(?string $description): void {
		$this->description = $description;
	}

	public function getDescription(): ?string {
		return $this->description;
	}

	public function setImageUrl(?string $imageUrl): void {
		$this->imageUrl = $imageUrl;
	}

	public function getImageUrl(): ?string {
		return $this->imageUrl;
	}

	public function setImageContentType(?string $contentType): void {
		$this->contentType = $contentType;
	}

	public function getImageContentType(): ?string {
		return $this->contentType;
	}

	public function setUrl(?string $url): void {
		$this->url = $url;
	}

	public function getUrl(): ?string {
		return $this->url;
	}

	public function setRichObject(string $type, ?array $richObject): void {
		$this->richObjectType = $type;
		$this->richObject = $richObject;
	}

	public function getRichObjectType(): string {
		if ($this->richObjectType === null) {
			return 'open-graph';
		}
		return $this->richObjectType;
	}

	public function getRichObject(): array {
		if ($this->richObject === null) {
			return $this->getOpenGraphObject();
		}
		return $this->richObject;
	}

	public function getOpenGraphObject(): array {
		return [
			'id' => $this->getId(),
			'name' => $this->getTitle(),
			'description' => $this->getDescription(),
			'thumb' => $this->getImageUrl(),
			'link' => $this->getUrl()
		];
	}

	public static function toCache(IReference $reference): array {
		return [
			'id' => $reference->getId(),
			'title' => $reference->getTitle(),
			'imageUrl' => $reference->getImageUrl(),
			'imageContentType' => $reference->getImageContentType(),
			'description' => $reference->getDescription(),
			'link' => $reference->getUrl(),
			'accessible' => $reference->getAccessible(),
			'richObjectType' => $reference->getRichObjectType(),
			'richObject' => $reference->getRichObject(),
		];
	}

	public static function fromCache(array $cache): IReference {
		$reference = new Reference($cache['id']);
		$reference->setTitle($cache['title']);
		$reference->setDescription($cache['description']);
		$reference->setImageUrl($cache['imageUrl']);
		$reference->setImageContentType($cache['imageContentType']);
		$reference->setUrl($cache['link']);
		$reference->setRichObject($cache['richObjectType'], $cache['richObject']);
		$reference->setAccessible($cache['accessible']);
		return $reference;
	}

	public function jsonSerialize() {
		return [
			'richObjectType' => $this->getRichObjectType(),
			'richObject' => $this->getRichObject(),
			'openGraphObject' => $this->getOpenGraphObject(),
			'accessible' => $this->accessible
		];
	}
}