mirror of
https://github.com/OpenXE-org/OpenXE.git
synced 2024-11-15 20:47:15 +01:00
782 lines
21 KiB
PHP
782 lines
21 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Xentral\Modules\GoogleCalendar\Data;
|
|
|
|
use DateTime;
|
|
use DateTimeInterface;
|
|
use JsonSerializable;
|
|
use Xentral\Modules\GoogleCalendar\Exception\InvalidArgumentException;
|
|
|
|
final class GoogleCalendarEventData implements JsonSerializable
|
|
{
|
|
/** @var string STATUS_CONFIRMED */
|
|
public const STATUS_CONFIRMED = 'confirmed';
|
|
|
|
/** @var string STATUS_TENTATIVE */
|
|
public const STATUS_TENTATIVE = 'tentative';
|
|
|
|
/** @var string STATUS_CANCELLED */
|
|
public const STATUS_CANCELLED = 'cancelled';
|
|
|
|
/** @var string VISIBILITY_PUBLIC */
|
|
public const VISIBILITY_PUBLIC = 'public';
|
|
|
|
/** @var string VISIBILITY_PRIVATE */
|
|
public const VISIBILITY_PRIVATE = 'private';
|
|
|
|
/** @var string VISIBILITY_DEFAULT */
|
|
public const VISIBILITY_DEFAULT = 'default';
|
|
|
|
/** @var string TRANSPARENCY_OPAQUE */
|
|
public const TRANSPARENCY_OPAQUE = 'opaque';
|
|
|
|
/** @var string TRANSPARENCY_TRANSPARENT */
|
|
public const TRANSPARENCY_TRANSPARENT = 'transparent';
|
|
|
|
/** @var string $kind */
|
|
private static $kind = 'calendar#event';
|
|
|
|
/** @var string $id */
|
|
private $id;
|
|
|
|
/** @var string $etag */
|
|
private $etag;
|
|
|
|
/** @var string $status */
|
|
private $status;
|
|
|
|
/** @var GoogleCalendarEventTimeValue $time */
|
|
private $time;
|
|
|
|
/** @var string $iCalUid */
|
|
private $iCalUid;
|
|
|
|
/** @var string $summary */
|
|
private $summary;
|
|
|
|
/** @var string $description */
|
|
private $description;
|
|
|
|
/** @var string $location */
|
|
private $location;
|
|
|
|
/** @var string $colorId */
|
|
private $colorId;
|
|
|
|
/** @var DateTime $created */
|
|
private $created;
|
|
|
|
/** @var DateTime $updated */
|
|
private $updated;
|
|
|
|
/** @var GoogleCalendarEventAttendeeValue $creator */
|
|
private $creator;
|
|
|
|
/** @var GoogleCalendarEventAttendeeValue $organizer */
|
|
private $organizer;
|
|
|
|
/** @var GoogleCalendarEventAttendeeValue[] $attendees */
|
|
private $attendees;
|
|
|
|
/** @var string $visibility */
|
|
private $visibility;
|
|
|
|
/** @var string $transparency */
|
|
private $transparency;
|
|
|
|
/** @var GoogleCalendarEventReminderValue[] */
|
|
private $reminders;
|
|
|
|
/** @var int $sequence */
|
|
private $sequence;
|
|
|
|
/** @var string $htmlLink */
|
|
private $htmlLink;
|
|
|
|
/**
|
|
* @param string $id
|
|
* @param string $etag
|
|
* @param string $status
|
|
* @param string $iCalUid
|
|
* @param DateTimeInterface $created
|
|
* @param DateTimeInterface $updated
|
|
* @param GoogleCalendarEventAttendeeValue $creator
|
|
* @param GoogleCalendarEventAttendeeValue $organizer
|
|
* @param GoogleCalendarEventTimeValue $time
|
|
* @param string $summary
|
|
* @param string $description
|
|
* @param string $location
|
|
* @param GoogleCalendarEventAttendeeValue[] $attendees
|
|
* @param GoogleCalendarEventReminderValue[] $reminders
|
|
* @param string $visibility
|
|
* @param string $transparency
|
|
* @param int $sequence
|
|
* @param string $colorId
|
|
* @param string $htmlLink
|
|
*/
|
|
public function __construct(
|
|
string $id,
|
|
string $etag,
|
|
string $status,
|
|
string $iCalUid = '',
|
|
DateTimeInterface $created = null,
|
|
DateTimeInterface $updated = null,
|
|
GoogleCalendarEventAttendeeValue $creator = null,
|
|
GoogleCalendarEventAttendeeValue $organizer = null,
|
|
GoogleCalendarEventTimeValue $time = null,
|
|
string $summary = '',
|
|
string $description = '',
|
|
string $location = '',
|
|
array $attendees = [],
|
|
array $reminders = [],
|
|
string $visibility = self::VISIBILITY_DEFAULT,
|
|
string $transparency = self::TRANSPARENCY_OPAQUE,
|
|
int $sequence = 0,
|
|
string $colorId = '',
|
|
string $htmlLink = ''
|
|
) {
|
|
$this->id = $id;
|
|
$this->etag = $etag;
|
|
if (
|
|
$status !== self::STATUS_CONFIRMED
|
|
&& $status !== self::STATUS_TENTATIVE
|
|
&& $status !== self::STATUS_CANCELLED
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event status; only "confirmed", "tentative" and "cancelled" are allowed'
|
|
);
|
|
}
|
|
$this->status = $status;
|
|
$this->iCalUid = $iCalUid;
|
|
$this->summary = $summary;
|
|
$this->description = $description;
|
|
$this->location = $location;
|
|
$this->colorId = $colorId;
|
|
$this->created = $created;
|
|
$this->updated = $updated;
|
|
$this->creator = $creator;
|
|
$this->organizer = $organizer;
|
|
$this->attendees = $attendees;
|
|
$this->time = $time;
|
|
if (
|
|
$visibility !== self::VISIBILITY_DEFAULT
|
|
&& $visibility !== self::VISIBILITY_PRIVATE
|
|
&& $visibility !== self::VISIBILITY_PUBLIC
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event visibility; only "default", "private" or "public" are allowed'
|
|
);
|
|
}
|
|
$this->visibility = $visibility;
|
|
if ($transparency !== self::TRANSPARENCY_OPAQUE && $transparency !== self::TRANSPARENCY_TRANSPARENT) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event transparency; only "opaque" or "transparent" are allowed'
|
|
);
|
|
}
|
|
$this->transparency = $transparency;
|
|
$this->reminders = $reminders;
|
|
$this->sequence = $sequence;
|
|
$this->htmlLink = $htmlLink;
|
|
}
|
|
|
|
/**
|
|
* @param array $data
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public static function fromArray(array $data): GoogleCalendarEventData
|
|
{
|
|
if (!isset($data['kind']) || $data['kind'] !== self::$kind) {
|
|
throw new InvalidArgumentException('Invalid resource type. Expected: calendar#event');
|
|
}
|
|
if (!isset($data['id'])) {
|
|
throw new InvalidArgumentException('Missing required resorce field "id".');
|
|
}
|
|
if (!isset($data['etag'])) {
|
|
throw new InvalidArgumentException('Missing required resorce field "etag".');
|
|
}
|
|
if (!isset($data['status'])) {
|
|
throw new InvalidArgumentException('Missing required resorce field "etag".');
|
|
}
|
|
|
|
//mandatory
|
|
$id = $data['id'];
|
|
$etag = $data['etag'];
|
|
$status = $data['status'];
|
|
|
|
//optional
|
|
$iCalUid = '';
|
|
if (isset($data['iCalUID'])) {
|
|
$iCalUid = $data['iCalUID'];
|
|
}
|
|
$created = null;
|
|
if (isset($data['created'])) {
|
|
$created = DateTime::createFromFormat('Y-m-d\TH:i:s.uP', $data['created']);
|
|
if ($created === false) {
|
|
throw new InvalidArgumentException('Invalid DateTime Format in "created".');
|
|
}
|
|
}
|
|
$updated = null;
|
|
if (isset($data['updated'])) {
|
|
$updated = DateTime::createFromFormat('Y-m-d\TH:i:s.uP', $data['updated']);
|
|
if ($updated === false) {
|
|
throw new InvalidArgumentException('Invalid DateTime Format in "updated".');
|
|
}
|
|
}
|
|
$creator = null;
|
|
if (isset($data['creator'])) {
|
|
$creator = GoogleCalendarEventAttendeeValue::createFromJsonArray($data['creator']);
|
|
}
|
|
$organizer = null;
|
|
if (isset($data['organizer'])) {
|
|
$organizer = GoogleCalendarEventAttendeeValue::createFromJsonArray($data['organizer']);
|
|
}
|
|
$time = null;
|
|
if (isset($data['start'], $data['end'])) {
|
|
$time = GoogleCalendarEventTimeValue::createFromJsonArray($data);
|
|
}
|
|
$sequence = 0;
|
|
if (isset($data['sequence'])) {
|
|
$sequence = $data['sequence'];
|
|
}
|
|
$summary = '';
|
|
if (isset($data['summary'])) {
|
|
$summary = $data['summary'];
|
|
}
|
|
$description = '';
|
|
if (isset($data['description'])) {
|
|
$description = $data['description'];
|
|
}
|
|
$location = '';
|
|
if (isset($data['location'])) {
|
|
$location = $data['location'];
|
|
}
|
|
$visibility = self::VISIBILITY_DEFAULT;
|
|
if (isset($data['visibility'])) {
|
|
$visibility = $data['visibility'];
|
|
}
|
|
$transparency = self::TRANSPARENCY_OPAQUE;
|
|
if (isset($data['transparency'])) {
|
|
$transparency = $data['transparency'];
|
|
}
|
|
$colorId = '';
|
|
if (isset($data['colorId'])) {
|
|
$colorId = $data['colorId'];
|
|
}
|
|
$htmlLink = '';
|
|
if (isset($data['htmlLink'])) {
|
|
$htmlLink = $data['htmlLink'];
|
|
}
|
|
$attendees = [];
|
|
if (isset($data['attendees']) && is_array($data['attendees'])) {
|
|
foreach ($data['attendees'] as $attendee) {
|
|
$attendees[] = GoogleCalendarEventAttendeeValue::createFromJsonArray($attendee);
|
|
}
|
|
}
|
|
$reminders = [];
|
|
if (isset($data['reminders']['overrides']) && is_array($data['reminders']['overrides'])) {
|
|
foreach ($data['reminders']['overrides'] as $reminder) {
|
|
$reminders[] = GoogleCalendarEventReminderValue::fromArray($reminder);
|
|
}
|
|
}
|
|
|
|
return new self(
|
|
$id,
|
|
$etag,
|
|
$status,
|
|
$iCalUid,
|
|
$created,
|
|
$updated,
|
|
$creator,
|
|
$organizer,
|
|
$time,
|
|
$summary,
|
|
$description,
|
|
$location,
|
|
$attendees,
|
|
$reminders,
|
|
$visibility,
|
|
$transparency,
|
|
$sequence,
|
|
$colorId,
|
|
$htmlLink
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function toArray(): array
|
|
{
|
|
$data = [];
|
|
if ($this->getTime() !== null) {
|
|
$time = $this->getTime()->toDataArray();
|
|
$data = array_merge($data, $time);
|
|
}
|
|
if ($this->getCreator() !== null) {
|
|
$data['creator'] = $this->getCreator()->toDataArray();
|
|
}
|
|
if ($this->getOrganizer() !== null) {
|
|
$data['organizer'] = $this->getOrganizer()->toDataArray();
|
|
}
|
|
$data['attendees'] = [];
|
|
foreach ($this->getAttendees() as $attendee) {
|
|
$data['attendees'][] = $attendee->toDataArray();
|
|
}
|
|
$data['reminders']['overrides'] = [];
|
|
foreach ($this->getReminders() as $reminder) {
|
|
$data['reminders']['overrides'][] = $reminder->toArray();
|
|
}
|
|
if ($this->getColorId() !== '') {
|
|
$data['colorId'] = $this->getColorId();
|
|
}
|
|
//$data['id'] = $this->getId();
|
|
$data['status'] = $this->getStatus();
|
|
//$data['iCalUid'] = $this->getICalUid();
|
|
$data['summary'] = $this->getSummary();
|
|
$data['description'] = $this->getDescription();
|
|
$data['location'] = $this->getLocation();
|
|
$data['visibility'] = $this->getVisibility();
|
|
$data['transparency'] = $this->getTransparency();
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getId(): string
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getEtag(): string
|
|
{
|
|
return $this->etag;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getStatus(): string
|
|
{
|
|
return $this->status;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventTimeValue
|
|
*/
|
|
public function getTime(): GoogleCalendarEventTimeValue
|
|
{
|
|
return $this->time;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getICalUid(): string
|
|
{
|
|
return $this->iCalUid;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getSummary(): string
|
|
{
|
|
return $this->summary;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getDescription(): string
|
|
{
|
|
return $this->description;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getLocation(): string
|
|
{
|
|
return $this->location;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getColorId(): string
|
|
{
|
|
return $this->colorId;
|
|
}
|
|
|
|
/**
|
|
* @return DateTimeInterface
|
|
*/
|
|
public function getCreated(): DateTimeInterface
|
|
{
|
|
return $this->created;
|
|
}
|
|
|
|
/**
|
|
* @return DateTimeInterface
|
|
*/
|
|
public function getUpdated(): DateTimeInterface
|
|
{
|
|
return $this->updated;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventAttendeeValue|null
|
|
*/
|
|
public function getCreator(): ?GoogleCalendarEventAttendeeValue
|
|
{
|
|
return $this->creator;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventAttendeeValue|null
|
|
*/
|
|
public function getOrganizer(): ?GoogleCalendarEventAttendeeValue
|
|
{
|
|
return $this->organizer;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventAttendeeValue[]
|
|
*/
|
|
public function getAttendees(): array
|
|
{
|
|
return $this->attendees;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getVisibility(): string
|
|
{
|
|
return $this->visibility;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getTransparency(): string
|
|
{
|
|
return $this->transparency;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventReminderValue[]
|
|
*/
|
|
public function getReminders(): array
|
|
{
|
|
return $this->reminders;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getSequence(): int
|
|
{
|
|
return $this->sequence;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getHtmlLink(): string
|
|
{
|
|
return $this->htmlLink;
|
|
}
|
|
|
|
/**
|
|
* @param string $status
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setStatus(string $status): GoogleCalendarEventData
|
|
{
|
|
if (
|
|
$status !== self::STATUS_CONFIRMED
|
|
&& $status !== self::STATUS_TENTATIVE
|
|
&& $status !== self::STATUS_CANCELLED
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event status; only "confirmed", "tentative" and "cancelled" are allowed.'
|
|
);
|
|
}
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->status = $status;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param DateTimeInterface $beginning
|
|
* @param DateTimeInterface $end
|
|
* @param bool $wholeday
|
|
* @param string $timezone
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setTime(
|
|
DateTimeInterface $beginning,
|
|
DateTimeInterface $end,
|
|
bool $wholeday = false,
|
|
string $timezone = ''
|
|
): GoogleCalendarEventData {
|
|
$time = new GoogleCalendarEventTimeValue($beginning, $end, $wholeday, $timezone);
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->time = $time;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $summary
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setSummary(string $summary): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->summary = $summary;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $description
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setDescription(string $description): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->description = $description;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $location
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setLocation(string $location): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->location = $location;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $colorId
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setColorId(string $colorId): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->colorId = $colorId;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $visibility
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setVisibility(string $visibility): GoogleCalendarEventData
|
|
{
|
|
if (
|
|
$visibility !== self::VISIBILITY_DEFAULT
|
|
&& $visibility !== self::VISIBILITY_PRIVATE
|
|
&& $visibility !== self::VISIBILITY_PUBLIC
|
|
) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event visibility; only "default", "private" or "public" are allowed'
|
|
);
|
|
}
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->visibility = $visibility;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $transparency
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setTransparency(string $transparency): GoogleCalendarEventData
|
|
{
|
|
if ($transparency !== self::TRANSPARENCY_OPAQUE && $transparency !== self::TRANSPARENCY_TRANSPARENT) {
|
|
throw new InvalidArgumentException(
|
|
'Invalid event transparency; only "opaque" or "transparent" are allowed'
|
|
);
|
|
}
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->transparency = $transparency;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param GoogleCalendarEventAttendeeValue|null $organizer
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function setOrganizer(GoogleCalendarEventAttendeeValue $organizer = null): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->organizer = $organizer;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $email
|
|
* @param string $displayName
|
|
* @param bool $optional
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function addAttendee(
|
|
string $email,
|
|
string $displayName = '',
|
|
bool $optional = false
|
|
): GoogleCalendarEventData {
|
|
$attendee = new GoogleCalendarEventAttendeeValue($email, $displayName, $optional);
|
|
$attendees = array_values($this->attendees);
|
|
$attendees[] = $attendee;
|
|
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->attendees = $attendees;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function removeAttendees(): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->attendees = [];
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @param string $method
|
|
* @param int $minutes
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function addReminder(string $method, int $minutes): GoogleCalendarEventData
|
|
{
|
|
$reminder = new GoogleCalendarEventReminderValue($method, $minutes);
|
|
$reminders = array_values($this->reminders);
|
|
$reminders[] = $reminder;
|
|
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->reminders = $reminders;
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
public function removeReminders(): GoogleCalendarEventData
|
|
{
|
|
$eventData = $this->cloneDeep();
|
|
$eventData->reminders = [];
|
|
|
|
return $eventData;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function jsonSerialize(): array
|
|
{
|
|
return $this->toArray();
|
|
}
|
|
|
|
/**
|
|
* @return GoogleCalendarEventData
|
|
*/
|
|
private function cloneDeep(): GoogleCalendarEventData
|
|
{
|
|
$time = $this->time;
|
|
if ($this->time !== null) {
|
|
$time = new GoogleCalendarEventTimeValue(
|
|
$this->time->getBeginning(),
|
|
$this->time->getEnd(),
|
|
$this->time->isWholeday(),
|
|
$this->time->getTimezone()
|
|
);
|
|
}
|
|
|
|
$created = null;
|
|
if ($this->created !== null) {
|
|
$created = clone $this->created;
|
|
}
|
|
$updated = null;
|
|
if ($this->updated !== null) {
|
|
$updated = clone $this->updated;
|
|
}
|
|
$creator = null;
|
|
if ($this->creator !== null) {
|
|
$creator = clone $this->creator;
|
|
}
|
|
$organizer = null;
|
|
if ($this->organizer !== null) {
|
|
$organizer = clone $this->organizer;
|
|
}
|
|
|
|
return new self(
|
|
$this->id,
|
|
$this->etag,
|
|
$this->status,
|
|
$this->iCalUid,
|
|
$created,
|
|
$updated,
|
|
$creator,
|
|
$organizer,
|
|
$time,
|
|
$this->summary,
|
|
$this->description,
|
|
$this->location,
|
|
$this->attendees,
|
|
$this->reminders,
|
|
$this->visibility,
|
|
$this->transparency,
|
|
$this->sequence,
|
|
$this->colorId,
|
|
$this->htmlLink
|
|
);
|
|
}
|
|
}
|