982 lines
23 KiB
PHP
982 lines
23 KiB
PHP
<?php namespace models\summit;
|
|
/**
|
|
* Copyright 2015 OpenStack Foundation
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
**/
|
|
|
|
use App\Jobs\Emails\SummitAttendeeTicketRegenerateHashEmail;
|
|
use Illuminate\Support\Facades\Event;
|
|
use App\Events\RequestedSummitAttendeeTicketRefund;
|
|
use App\Events\SummitAttendeeTicketRefundAccepted;
|
|
use App\Models\Foundation\Summit\AllowedCurrencies;
|
|
use Illuminate\Support\Facades\Config;
|
|
use Doctrine\Common\Collections\ArrayCollection;
|
|
use Illuminate\Support\Facades\Log;
|
|
use models\exceptions\ValidationException;
|
|
use models\main\Member;
|
|
use models\utils\SilverstripeBaseModel;
|
|
use Doctrine\ORM\Mapping AS ORM;
|
|
/**
|
|
* @ORM\Entity
|
|
* @ORM\Table(name="SummitAttendeeTicket")
|
|
* @ORM\Entity(repositoryClass="App\Repositories\Summit\DoctrineSummitAttendeeTicketRepository")
|
|
* Class SummitAttendeeTicket
|
|
* @package models\summit
|
|
*/
|
|
class SummitAttendeeTicket extends SilverstripeBaseModel
|
|
implements IQREntity
|
|
{
|
|
|
|
/**
|
|
* @ORM\Column(name="ExternalOrderId", type="string")
|
|
* @var string
|
|
*/
|
|
private $external_order_id;
|
|
|
|
/**
|
|
* @ORM\Column(name="ExternalAttendeeId", type="string")
|
|
* @var
|
|
*/
|
|
private $external_attendee_id;
|
|
|
|
/**
|
|
* @ORM\Column(name="TicketBoughtDate", type="datetime")
|
|
* @var \DateTime
|
|
*/
|
|
private $bought_date;
|
|
|
|
/**
|
|
* @ORM\Column(name="TicketChangedDate", type="datetime")
|
|
* @var \DateTime
|
|
*/
|
|
private $changed_date;
|
|
|
|
/**
|
|
* @ORM\ManyToOne(targetEntity="SummitTicketType")
|
|
* @ORM\JoinColumn(name="TicketTypeID", referencedColumnName="ID")
|
|
* @var SummitTicketType
|
|
*/
|
|
private $ticket_type;
|
|
|
|
/**
|
|
* @ORM\ManyToOne(targetEntity="SummitAttendee", inversedBy="tickets")
|
|
* @ORM\JoinColumn(name="OwnerID", referencedColumnName="ID", nullable=true)
|
|
* @var SummitAttendee
|
|
*/
|
|
private $owner;
|
|
|
|
/**
|
|
* @ORM\ManyToOne(targetEntity="models\summit\SummitOrder", inversedBy="tickets")
|
|
* @ORM\JoinColumn(name="OrderID", referencedColumnName="ID")
|
|
* @var SummitOrder
|
|
*/
|
|
private $order;
|
|
|
|
/**
|
|
* @ORM\OneToMany(targetEntity="SummitAttendeeTicketTax", mappedBy="ticket", cascade={"persist","remove"}, orphanRemoval=true)
|
|
* @var SummitAttendeeTicketTax[]
|
|
*/
|
|
private $applied_taxes;
|
|
|
|
/**
|
|
* @ORM\ManyToOne(targetEntity="models\summit\SummitRegistrationPromoCode")
|
|
* @ORM\JoinColumn(name="PromoCodeID", referencedColumnName="ID", nullable=true)
|
|
* @var SummitRegistrationPromoCode
|
|
*/
|
|
private $promo_code;
|
|
|
|
/**
|
|
* @ORM\Column(name="Hash", type="string")
|
|
* @var string
|
|
*/
|
|
private $hash;
|
|
|
|
/**
|
|
* @ORM\Column(name="HashCreationDate", type="datetime")
|
|
* @var \DateTime
|
|
*/
|
|
private $hash_creation_date;
|
|
|
|
/**
|
|
* @ORM\Column(name="Number", type="string")
|
|
* @var string
|
|
*/
|
|
private $number;
|
|
|
|
/**
|
|
* @ORM\Column(name="Status", type="string")
|
|
* @var string
|
|
*/
|
|
private $status;
|
|
|
|
/**
|
|
* @ORM\Column(name="RawCost", type="float")
|
|
* @var float
|
|
*/
|
|
private $raw_cost;
|
|
|
|
/**
|
|
* @ORM\Column(name="Discount", type="float")
|
|
* @var float
|
|
*/
|
|
private $discount;
|
|
|
|
/**
|
|
* @ORM\Column(name="RefundedAmount", type="float")
|
|
* @var float
|
|
*/
|
|
private $refunded_amount;
|
|
|
|
/**
|
|
* @ORM\Column(name="Currency", type="string")
|
|
* @var string
|
|
*/
|
|
private $currency;
|
|
|
|
/**
|
|
* @ORM\Column(name="QRCode", type="string", nullable=true)
|
|
* @var string
|
|
*/
|
|
private $qr_code;
|
|
|
|
/**
|
|
* @ORM\OneToOne(targetEntity="SummitAttendeeBadge", mappedBy="ticket", cascade={"persist","remove"}, orphanRemoval=true)
|
|
* @var SummitAttendeeBadge
|
|
*/
|
|
private $badge;
|
|
|
|
/**
|
|
* @ORM\OneToMany(targetEntity="SummitAttendeeTicketFormerHash", mappedBy="ticket", cascade={"persist"}, orphanRemoval=true)
|
|
* @var SummitAttendeeTicketFormerHash[]
|
|
*/
|
|
private $former_hashes;
|
|
|
|
/**
|
|
* @ORM\Column(name="IsActive", type="boolean")
|
|
* @var bool
|
|
*/
|
|
private $is_active;
|
|
|
|
/**
|
|
* SummitAttendeeTicket constructor.
|
|
*/
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
$this->status = IOrderConstants::ReservedStatus;
|
|
$this->currency = AllowedCurrencies::USD;
|
|
$this->applied_taxes = new ArrayCollection();
|
|
$this->former_hashes = new ArrayCollection();
|
|
$this->raw_cost = 0.0;
|
|
$this->discount = 0.0;
|
|
$this->refunded_amount = 0.0;
|
|
$this->is_active = true;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getHash(): string
|
|
{
|
|
return $this->hash;
|
|
}
|
|
|
|
/**
|
|
* @return \DateTime
|
|
*/
|
|
public function getHashCreationDate(): \DateTime
|
|
{
|
|
return $this->hash_creation_date;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getNumber(): ?string
|
|
{
|
|
return $this->number;
|
|
}
|
|
|
|
/**
|
|
* @param string $number
|
|
*/
|
|
public function setNumber(string $number): void
|
|
{
|
|
$this->number = $number;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getStatus(): string
|
|
{
|
|
return $this->status;
|
|
}
|
|
|
|
/**
|
|
* @param string $status
|
|
*/
|
|
public function setStatus(string $status): void
|
|
{
|
|
$this->status = $status;
|
|
}
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
public function getRawCost(): ?float
|
|
{
|
|
return $this->raw_cost;
|
|
}
|
|
|
|
/**
|
|
* @param float $raw_cost
|
|
*/
|
|
public function setRawCost(float $raw_cost): void
|
|
{
|
|
$this->raw_cost = $raw_cost;
|
|
}
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
public function getRefundedAmount(): ?float
|
|
{
|
|
return $this->refunded_amount;
|
|
}
|
|
|
|
/**
|
|
* @param float $refunded_amount
|
|
*/
|
|
public function setRefundedAmount(float $refunded_amount): void
|
|
{
|
|
$this->refunded_amount = $refunded_amount;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getCurrency(): ?string
|
|
{
|
|
return $this->currency;
|
|
}
|
|
|
|
/**
|
|
* @param string $currency
|
|
*/
|
|
public function setCurrency(string $currency): void
|
|
{
|
|
$this->currency = $currency;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getQRCode(): ?string
|
|
{
|
|
return $this->qr_code;
|
|
}
|
|
|
|
public function generateHash():void
|
|
{
|
|
$token = $this->number;
|
|
if (!is_null($this->order)) {
|
|
$token .= $this->order->getHash();
|
|
}
|
|
$salt = random_bytes(16);
|
|
if(!empty($this->hash)){
|
|
$former_hash = new SummitAttendeeTicketFormerHash($this->hash, $this);
|
|
$this->former_hashes->add($former_hash);
|
|
}
|
|
$this->hash = hash('sha256', $token.$salt.time());
|
|
$this->hash_creation_date = new \DateTime('now', new \DateTimeZone('UTC'));
|
|
}
|
|
|
|
/**
|
|
* @throws ValidationException
|
|
*/
|
|
public function sendPublicEditEmail(){
|
|
if (!$this->isPaid())
|
|
throw new ValidationException("ticket is not paid");
|
|
|
|
if (!$this->hasOwner())
|
|
throw new ValidationException("ticket must have an assigned owner");
|
|
|
|
$this->generateQRCode();
|
|
$this->generateHash();
|
|
|
|
SummitAttendeeTicketRegenerateHashEmail::dispatch($this);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasOrder()
|
|
{
|
|
return $this->getOrderId() > 0;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getOrderId()
|
|
{
|
|
try {
|
|
return is_null($this->order) ? 0 : $this->order->getId();
|
|
} catch (\Exception $ex) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return SummitOrder
|
|
*/
|
|
public function getOrder(): SummitOrder
|
|
{
|
|
return $this->order;
|
|
}
|
|
|
|
/**
|
|
* @param SummitOrder $order
|
|
*/
|
|
public function setOrder(SummitOrder $order): void
|
|
{
|
|
$this->order = $order;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
* @throws \Exception
|
|
*/
|
|
public function canPubliclyEdit(): bool
|
|
{
|
|
if (empty($this->hash) || is_null($this->hash_creation_date)) return false;
|
|
$ttl_minutes = Config::get("registration.ticket_public_edit_ttl", 30);
|
|
$eol = new \DateTime('now', new \DateTimeZone('UTC'));
|
|
$eol->sub(new \DateInterval('PT' . $ttl_minutes . 'M'));
|
|
if ($this->hash_creation_date <= $eol)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function generateNumber(): string
|
|
{
|
|
$summit = $this->getOrder()->getSummit();
|
|
$this->number = strtoupper(str_replace(".", "", uniqid($summit->getTicketQRPrefix().'_', true)));
|
|
return $this->number;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getChangedDate()
|
|
{
|
|
return $this->changed_date;
|
|
}
|
|
|
|
/**
|
|
* @param mixed $changed_date
|
|
*/
|
|
public function setChangedDate($changed_date)
|
|
{
|
|
$this->changed_date = $changed_date;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getExternalOrderId():?string
|
|
{
|
|
return $this->external_order_id;
|
|
}
|
|
|
|
/**
|
|
* @param string $external_order_id
|
|
*/
|
|
public function setExternalOrderId($external_order_id)
|
|
{
|
|
$this->external_order_id = $external_order_id;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getExternalAttendeeId():?string
|
|
{
|
|
return $this->external_attendee_id;
|
|
}
|
|
|
|
/**
|
|
* @param string $external_attendee_id
|
|
*/
|
|
public function setExternalAttendeeId($external_attendee_id)
|
|
{
|
|
$this->external_attendee_id = $external_attendee_id;
|
|
}
|
|
|
|
/**
|
|
* @return \DateTime
|
|
*/
|
|
public function getBoughtDate()
|
|
{
|
|
return $this->bought_date;
|
|
}
|
|
|
|
/**
|
|
* @param \DateTime $bought_date
|
|
*/
|
|
public function setBoughtDate($bought_date)
|
|
{
|
|
$this->bought_date = $bought_date;
|
|
}
|
|
|
|
/**
|
|
* @return SummitTicketType
|
|
*/
|
|
public function getTicketType()
|
|
{
|
|
return $this->ticket_type;
|
|
}
|
|
|
|
/**
|
|
* @param $ticket_type
|
|
* @return $this
|
|
*/
|
|
public function setTicketType($ticket_type)
|
|
{
|
|
$this->ticket_type = $ticket_type;
|
|
$this->raw_cost = $this->ticket_type->getCost();
|
|
$this->currency = $this->ticket_type->getCurrency();
|
|
return $this->ticket_type->applyTo($this);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasTicketType()
|
|
{
|
|
return $this->getTicketTypeId() > 0;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getTicketTypeId()
|
|
{
|
|
try {
|
|
return is_null($this->ticket_type) ? 0 : $this->ticket_type->getId();
|
|
} catch (\Exception $ex) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return SummitAttendee|null
|
|
*/
|
|
public function getOwner():?SummitAttendee
|
|
{
|
|
return $this->owner;
|
|
}
|
|
|
|
/**
|
|
* @param SummitAttendee $owner
|
|
*/
|
|
public function setOwner($owner)
|
|
{
|
|
$this->owner = $owner;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasOwner()
|
|
{
|
|
return $this->getOwnerId() > 0;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getOwnerId()
|
|
{
|
|
try {
|
|
return is_null($this->owner) ? 0 : $this->owner->getId();
|
|
} catch (\Exception $ex) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isPaid():bool {
|
|
return $this->status == IOrderConstants::PaidStatus;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isCancelled():bool {
|
|
return $this->status == IOrderConstants::CancelledStatus;
|
|
}
|
|
|
|
use QRGeneratorTrait;
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function generateQRCode(): string
|
|
{
|
|
if(is_null($this->order)){
|
|
throw new ValidationException("ticket has not order set");
|
|
}
|
|
|
|
$this->qr_code = $this->generateQRFromFields([
|
|
$this->order->getSummit()->getTicketQRPrefix(),
|
|
$this->number
|
|
]);
|
|
|
|
return $this->qr_code;
|
|
}
|
|
|
|
/**
|
|
* @return SummitAttendeeBadge
|
|
*/
|
|
public function getBadge(): SummitAttendeeBadge
|
|
{
|
|
return $this->badge;
|
|
}
|
|
|
|
/**
|
|
* @param SummitAttendeeBadge $badge
|
|
*/
|
|
public function setBadge(SummitAttendeeBadge $badge): void
|
|
{
|
|
$this->badge = $badge;
|
|
$badge->setTicket($this);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasBadge()
|
|
{
|
|
return $this->getBadgeId() > 0 || !is_null($this->badge);
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getBadgeId()
|
|
{
|
|
try {
|
|
return is_null($this->badge) ? 0 : $this->badge->getId();
|
|
} catch (\Exception $ex) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public function setPaid($set_bought_date = true)
|
|
{
|
|
$this->status = IOrderConstants::PaidStatus;
|
|
if($set_bought_date)
|
|
$this->bought_date = new \DateTime('now', new \DateTimeZone('UTC'));
|
|
}
|
|
|
|
|
|
public function setCancelled()
|
|
{
|
|
if ($this->status == IOrderConstants::PaidStatus) return;
|
|
$this->status = IOrderConstants::CancelledStatus;
|
|
}
|
|
|
|
function cancelRefundRequest():void {
|
|
if(!$this->isRefundRequested())
|
|
throw new ValidationException(sprintf("You can not cancel any refund on this ticket"));
|
|
$this->status = IOrderConstants::PaidStatus;
|
|
}
|
|
|
|
public function setRefunded()
|
|
{
|
|
$this->status = IOrderConstants::RefundedStatus;
|
|
}
|
|
|
|
public function setRefundRequests()
|
|
{
|
|
$this->status = IOrderConstants::RefundRequestedStatus;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function canRefund():bool{
|
|
$validStatuses = [IOrderConstants::RefundRequestedStatus, IOrderConstants::PaidStatus];
|
|
if(!in_array($this->status, $validStatuses)){
|
|
return false;
|
|
}
|
|
if($this->isFree()){
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* @param float $amount
|
|
* @throws ValidationException
|
|
*/
|
|
public function refund(float $amount)
|
|
{
|
|
if (!$this->canRefund())
|
|
throw new ValidationException
|
|
(
|
|
sprintf
|
|
(
|
|
"can not request a refund on a %s ticket",
|
|
$this->status
|
|
)
|
|
);
|
|
|
|
$this->status = IOrderConstants::RefundedStatus;
|
|
$this->refunded_amount = $amount;
|
|
|
|
$tickets_to_return = [];
|
|
$promo_codes_to_return = [];
|
|
|
|
if(!isset($tickets_to_return[$this->getTicketTypeId()]))
|
|
$tickets_to_return[$this->getTicketTypeId()] = 0;
|
|
$tickets_to_return[$this->getTicketTypeId()] += 1;
|
|
if($this->hasPromoCode()){
|
|
if(!isset($promo_codes_to_return[$this->getPromoCode()->getCode()]))
|
|
$promo_codes_to_return[$this->getPromoCode()->getCode()] = 0;
|
|
$promo_codes_to_return[$this->getPromoCode()->getCode()] +=1;
|
|
}
|
|
|
|
Event::dispatch(new SummitAttendeeTicketRefundAccepted($this->getId(), $tickets_to_return, $promo_codes_to_return));
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function hasPromoCode(): bool
|
|
{
|
|
return $this->getPromoCodeId() > 0;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getPromoCodeId(): int
|
|
{
|
|
try {
|
|
return is_null($this->promo_code) ? 0 : $this->promo_code->getId();
|
|
}
|
|
catch(\Exception $ex){
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return SummitRegistrationPromoCode
|
|
*/
|
|
public function getPromoCode(): ?SummitRegistrationPromoCode
|
|
{
|
|
return $this->promo_code;
|
|
}
|
|
|
|
/**
|
|
* @param SummitRegistrationPromoCode $promo_code
|
|
*/
|
|
public function setPromoCode(SummitRegistrationPromoCode $promo_code): void
|
|
{
|
|
$this->promo_code = $promo_code;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isRefundRequested():bool{
|
|
return $this->status == IOrderConstants::RefundRequestedStatus;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isRefunded():bool{
|
|
return $this->status == IOrderConstants::RefundedStatus;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isBadgePrinted():bool{
|
|
if($this->hasBadge()){
|
|
$badge = $this->getBadge();
|
|
return $badge->isPrinted();
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* @param bool $refund_entire_order
|
|
* @throws ValidationException
|
|
*/
|
|
public function requestRefund($refund_entire_order = false): void
|
|
{
|
|
if ($this->status != IOrderConstants::PaidStatus)
|
|
throw new ValidationException(sprintf( "you can not request a refund for this ticket %s ( invalid status %s)", $this->number, $this->status));
|
|
|
|
$summit = $this->getOrder()->getSummit();
|
|
$begin_date = $summit->getBeginDate();
|
|
if(is_null($begin_date)) return;
|
|
|
|
if($this->isBadgePrinted())
|
|
throw new ValidationException(sprintf( "you can not request a refund for this ticket %s ( badge already printed)", $this->number));
|
|
|
|
$now = new \DateTime('now', new \DateTimeZone('UTC'));
|
|
|
|
if($now > $begin_date){
|
|
Log::debug("SummitAttendeeTicket::requestRefund: now is greater than Summit.BeginDate");
|
|
throw new ValidationException("you can not request a refund after summit started");
|
|
}
|
|
|
|
$interval = $begin_date->diff($now);
|
|
|
|
$days_before_event_starts = intval($interval->format('%a'));
|
|
|
|
Log::debug(sprintf("SummitAttendeeTicket::requestRefund: days_before_event_starts %s", $days_before_event_starts));
|
|
|
|
$this->status = IOrderConstants::RefundRequestedStatus;
|
|
|
|
if (!$refund_entire_order)
|
|
Event::dispatch(new RequestedSummitAttendeeTicketRefund($this->getId(), $days_before_event_starts));
|
|
}
|
|
|
|
/**
|
|
* @param array $taxes
|
|
*/
|
|
public function applyTaxes(array $taxes)
|
|
{
|
|
$amount = $this->raw_cost;
|
|
$amount -= $this->discount;
|
|
foreach ($taxes as $tax) {
|
|
if (!$tax instanceof SummitTaxType) continue;
|
|
if (!$tax->mustApplyTo($this->ticket_type)) continue;
|
|
$ticketTax = new SummitAttendeeTicketTax();
|
|
$ticketTax->setTicket($this);
|
|
$ticketTax->setTax($tax);
|
|
$ticketTax->setAmount(($amount * $tax->getRate()) / 100.00);
|
|
$this->applied_taxes->add($ticketTax);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
public function getFinalAmount(): float
|
|
{
|
|
$amount = $this->raw_cost;
|
|
$amount -= $this->discount;
|
|
foreach ($this->applied_taxes as $tax) {
|
|
$amount += $tax->getAmount();
|
|
}
|
|
return $amount;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isFree():bool {
|
|
return $this->getFinalAmount() == 0;
|
|
}
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
public function getTaxesAmount(): float
|
|
{
|
|
$amount = 0.0;
|
|
foreach ($this->getAppliedTaxes() as $appliedTax) {
|
|
$amount += $appliedTax->getAmount();
|
|
}
|
|
return $amount;
|
|
}
|
|
|
|
/**
|
|
* @return SummitAttendeeTicketTax[]
|
|
*/
|
|
public function getAppliedTaxes()
|
|
{
|
|
return $this->applied_taxes;
|
|
}
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
public function getDiscount(): float
|
|
{
|
|
return $this->discount;
|
|
}
|
|
|
|
/**
|
|
* @param float $amount
|
|
* @return $this
|
|
*/
|
|
public function setDiscount(float $amount)
|
|
{
|
|
$this->discount = $amount > $this->raw_cost ? $this->raw_cost: $amount;
|
|
return $this;
|
|
}
|
|
|
|
public function clearOwner()
|
|
{
|
|
$this->owner = null;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getOwnerFullName():?string{
|
|
if(is_null($this->owner)) null;
|
|
return $this->owner->getFullName();
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getOwnerFirstName():?string{
|
|
if(is_null($this->owner)) return null;
|
|
return $this->owner->getFirstName();
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getOwnerSurname():?string{
|
|
if(is_null($this->owner)) return null;
|
|
return $this->owner->getSurname();
|
|
}
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getOwnerCompany():?string{
|
|
if(is_null($this->owner)) return null;
|
|
return $this->owner->getCompanyName();
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getOwnerEmail():?string{
|
|
try {
|
|
return is_null($this->owner)? null : $this->owner->getEmail();
|
|
}
|
|
catch (\Exception $ex){
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return int|null
|
|
*/
|
|
public function getBadgeTypeId():?int{
|
|
if(is_null($this->badge)) return 0;
|
|
return $this->badge->getType()->getId();
|
|
}
|
|
|
|
/**
|
|
* @return null|string
|
|
*/
|
|
public function getBadgeTypeName():?string{
|
|
if(is_null($this->badge)) return null;
|
|
return $this->badge->getType()->getName();
|
|
}
|
|
|
|
/**
|
|
* @return null|string
|
|
*/
|
|
public function getTicketTypeName():?string{
|
|
if(is_null($this->ticket_type)) return null;
|
|
return $this->ticket_type->getName();
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getBadgeFeaturesNames():array {
|
|
$res = [];
|
|
if(is_null($this->badge)) return [];
|
|
foreach ($this->badge->getFeatures() as $feature){
|
|
$res[] = $feature->getName();
|
|
}
|
|
foreach ($this->badge->getType()->getBadgeFeatures() as $feature){
|
|
if(in_array($feature->getName(),$res)) continue;
|
|
$res[] = $feature->getName();
|
|
}
|
|
|
|
return $res;
|
|
}
|
|
|
|
public function getBadgeFeatures():array{
|
|
$res = [];
|
|
if(is_null($this->badge)) return [];
|
|
|
|
foreach ($this->badge->getFeatures() as $feature){
|
|
$res[$feature->getId()] = $feature;
|
|
}
|
|
|
|
foreach ($this->badge->getType()->getBadgeFeatures() as $feature){
|
|
if(key_exists($feature->getId(), $res)) continue;
|
|
$res[$feature->getId()] = $feature;
|
|
}
|
|
|
|
return $res;
|
|
}
|
|
|
|
/**
|
|
* @return null|string
|
|
*/
|
|
public function getPromoCodeValue():?string{
|
|
return $this->hasPromoCode() ? $this->promo_code->getCode() : null;
|
|
}
|
|
|
|
/**
|
|
* @param Member $member
|
|
* @return bool
|
|
*/
|
|
public function canEditTicket(Member $member):bool{
|
|
if($member->isAdmin()) return true;
|
|
// i am ticket owner
|
|
if($this->hasOwner() && $this->owner->getEmail() == $member->getEmail()) return true;
|
|
// i am order owner
|
|
if($this->order->getOwnerEmail() == $member->getEmail()) return true;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isActive(): bool
|
|
{
|
|
return $this->is_active;
|
|
}
|
|
|
|
public function activate(): void
|
|
{
|
|
$this->is_active = true;
|
|
}
|
|
|
|
public function deActivate(): void
|
|
{
|
|
$this->is_active = false;
|
|
}
|
|
|
|
}
|