TicketExtension::updateCMSActions() - Code Metrics - Inspection of "only paid attendees can check in" - TheBnl/event-tickets - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 433ab3...f1150e )

by Bram

created 2017-05-31 12:44 UTC

TicketExtension::updateCMSActions() A

↳ Parent: TicketExtension

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	6
nc	2
nop	1

<?php
/**
 * TicketExtension.php
 *
 * @author Bram de Leeuw
 * Date: 09/03/17
 */

namespace Broarm\EventTickets;

use CalendarEvent_Controller;
use DataExtension;
use FieldList;
use GridField;
use GridFieldAddNewButton;
use GridFieldConfig_RecordEditor;
use GridFieldDataColumns;
use GridFieldExportButton;
use GridFieldSortableHeader;
use HasManyList;
use HtmlEditorField;
use LiteralField;
use NumericField;
use SiteConfig;

/**
 * Class TicketExtension
 *
 * @package Broarm\EventTickets
 *
 * @property TicketExtension|\CalendarEvent $owner
 * @property int                            Capacity
 * @property int                            OrderMin
 * @property int                            OrderMax
 * @property string                         SuccessMessage
 * @property string                         SuccessMessageMail
 *
 * @method \HasManyList Tickets()
 * @method \HasManyList Reservations()
 * @method \HasManyList Attendees()
 * @method \HasManyList WaitingList()
 * @method \HasManyList Fields()
 */
class TicketExtension extends DataExtension
{
    /**
     * @var CalendarEvent_Controller
     */
    protected $controller;

    private static $db = array(

        'Capacity' => 'Int',
        'OrderMin' => 'Int',
        'OrderMax' => 'Int',
        'SuccessMessage' => 'HTMLText',
        'SuccessMessageMail' => 'HTMLText'
    );

    private static $has_many = array(

        'Tickets' => 'Broarm\EventTickets\Ticket.Event',
        'Reservations' => 'Broarm\EventTickets\Reservation.Event',
        'Attendees' => 'Broarm\EventTickets\Attendee.Event',
        'WaitingList' => 'Broarm\EventTickets\WaitingListRegistration.Event',
        'Fields' => 'Broarm\EventTickets\AttendeeExtraField.Event'
    );

    private static $defaults = array(

        'Capacity' => 50,
        'OrderMin' => 1,
        'OrderMax' => 5
    );

    private static $translate = array(

        'SuccessMessage',
        'SuccessMessageMail'
    );

    public function updateCMSFields(FieldList $fields)
    {
        $ticketsGridFieldConfig = GridFieldConfig_RecordEditor::create();
        // If the event dates are in the past remove ability to create new tickets, reservations and attendees.
        // This is done here instead of in the canCreate method because of the lack of context there.
        if (!$this->canCreateTickets()) {
            $ticketsGridFieldConfig->removeComponentsByType(new GridFieldAddNewButton());
        }

        $ticketLabel = _t('TicketExtension.Tickets', 'Tickets');
        $fields->addFieldsToTab(
            "Root.$ticketLabel", array(
            GridField::create('Tickets', $ticketLabel, $this->owner->Tickets(), $ticketsGridFieldConfig),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            NumericField::create('Capacity', _t('TicketExtension.Capacity', 'Capacity')),
            NumericField::create('OrderMin', _t('TicketExtension.OrderMin', 'Minimum amount of tickets required per reservation')),
            NumericField::create('OrderMax', _t('TicketExtension.OrderMax', 'Maximum amount of tickets allowed per reservation')),
            HtmlEditorField::create('SuccessMessage', _t('TicketExtension.SuccessMessage', 'Success message'))->setRows(4),
            HtmlEditorField::create('SuccessMessageMail', _t('TicketExtension.MailMessage', 'Mail message'))->setRows(4)
        ));

        if ($this->owner->Reservations()->exists()) {

            $reservationLabel = _t('TicketExtension.Reservations', 'Reservations');
            $fields->addFieldToTab(
                "Root.$reservationLabel",
                GridField::create('Reservations', $reservationLabel, $this->owner->Reservations(), GridFieldConfig_RecordEditor::create())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            );
        }

        if ($this->owner->Attendees()->exists()) {

            $guestListLabel = _t('TicketExtension.GuestList', 'GuestList');
            $fields->addFieldToTab(
                "Root.$guestListLabel",
                GridField::create('Attendees', $guestListLabel, $this->owner->Attendees(), GridFieldConfig_RecordEditor::create())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            );
        }

        if ($this->owner->WaitingList()->exists()) {

            $waitingListLabel = _t('TicketExtension.WaitingList', 'WaitingList');
            $fields->addFieldToTab(
                "Root.$waitingListLabel",
                GridField::create('WaitingList', $waitingListLabel, $this->owner->WaitingList(), GridFieldConfig_RecordEditor::create())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            );
        }

        $extraFieldsLabel = _t('TicketExtension.ExtraFields', 'Attendee fields');
        $fields->addFieldToTab(
            "Root.$extraFieldsLabel",
            GridField::create('WaitingList', $extraFieldsLabel, $this->owner->Fields(), GridFieldConfig_Fields::create())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        );

        $this->owner->extend('updateTicketExtensionFields', $fields);
    }

    /**
     * Trigger actions after write
     */
    public function onAfterWrite()
    {
        $this->createDefaultFields();
        parent::onAfterWrite();
    }

    /**
     * Creates and sets up the default fields
     */
    public function createDefaultFields()
    {
        $fields = Attendee::config()->get('default_fields');
        if (!$this->owner->Fields()->exists()) {
            foreach ($fields as $fieldName => $fieldType) {
                $field = AttendeeExtraField::create();
                $field->Title = _t("AttendeeField.$fieldName", $fieldName);
                $field->FieldName = $fieldName;
                $field->Required = true;
                $field->Editable = false;

                if (is_array($fieldType)) {
                    foreach ($fieldType as $property => $value) {
                        $field->setField($property, $value);
                    }
                } else {
                    $field->FieldType = $fieldType;
                }

                $this->owner->Fields()->add($field);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            }
        }
    }

    /**
     * Extend the page actions with an start check in action
     *
     * @param FieldList $actions
     */
    public function updateCMSActions(FieldList $actions)
    {
        $checkInButton = new LiteralField('StartCheckIn',
            "<a class='action ss-ui-button ui-button ui-widget ui-state-default ui-corner-all ui-button-text-only'
                id='Edit_StartCheckIn'
                role='button'
                href='{$this->owner->Link('checkin')}'
                target='_blank'>
                Start check in
            </a>"
        );

        if ($this->owner->Attendees()->exists()) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $actions->push($checkInButton);
        }
    }

    /**
     * Get the leftover capacity
     *
     * @return int

     */
    public function getAvailability()
    {
        return $this->owner->Capacity - $this->owner->Attendees()->count();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get only the attendees who are certain to attend
     * Fixme: Using callback filter instead of join, because join gives ambiguous error on 'EventID'
     *
     * @return \ArrayList
     */
    public function getGuestList()
    {
        return $this->owner->Attendees()->filterByCallback(function(Attendee $attendee, HasManyList $list) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            return $attendee->Reservation()->Status === 'PAID';
        });
    }

    /**
     * Get the success message
     *
     * @return mixed|string
     */
    public function getSuccessContent()

    {
        if (!empty($this->owner->SuccessMessage)) {
            return $this->owner->dbObject('SuccessMessage');
        } else {
            return SiteConfig::current_site_config()->dbObject('SuccessMessage');
        }
    }

    /**
     * Get the mail message
     *
     * @return mixed|string
     */
    public function getMailContent()

    {
        if (!empty($this->owner->SuccessMessageMail)) {
            return $this->owner->dbObject('SuccessMessageMail');
        } else {
            return SiteConfig::current_site_config()->dbObject('SuccessMessageMail');
        }
    }

    /**
     * Get the Ticket logo
     *
     * @return \Image
     */
    public function getMailLogo()
    {
        return SiteConfig::current_site_config()->TicketLogo();
    }

    /**
     * Check if the current event can have tickets
     *
     * @return bool
     */
    public function canCreateTickets()
    {
        $currentDate = $this->owner->getController()->CurrentDate();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        if ($currentDate && $currentDate->exists()) {
            return $currentDate->dbObject('StartDate')->InFuture();
        }

        return false;
    }

    /**
     * Get the calendar controller
     *
     * @return CalendarEvent_Controller
     */
    public function getController()
    {
        return $this->controller
            ? $this->controller
            : $this->controller = CalendarEvent_Controller::create($this->owner);
    }
}


Push — master ( 433ab3...f1150e )

TicketExtension::updateCMSActions() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* TicketExtension.php
4			*
5			* @author Bram de Leeuw
6			* Date: 09/03/17
7			*/
8
9			namespace Broarm\EventTickets;
10
11			use CalendarEvent_Controller;
12			use DataExtension;
13			use FieldList;
14			use GridField;
15			use GridFieldAddNewButton;
16			use GridFieldConfig_RecordEditor;
17			use GridFieldDataColumns;
18			use GridFieldExportButton;
19			use GridFieldSortableHeader;
20			use HasManyList;
21			use HtmlEditorField;
22			use LiteralField;
23			use NumericField;
24			use SiteConfig;
25
26			/**
27			* Class TicketExtension
28			*
29			* @package Broarm\EventTickets
30			*
31			* @property TicketExtension\|\CalendarEvent $owner
32			* @property int Capacity
33			* @property int OrderMin
34			* @property int OrderMax
35			* @property string SuccessMessage
36			* @property string SuccessMessageMail
37			*
38			* @method \HasManyList Tickets()
39			* @method \HasManyList Reservations()
40			* @method \HasManyList Attendees()

TheBnl / event-tickets

Push — master ( 433ab3...f1150e )

TicketExtension::updateCMSActions() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like