TicketExtension - 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 A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	233
Duplicated Lines	15.88 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

Metric	Value
wmc	25
lcom	1
cbo	13
dl	37
loc	233
rs	10
c	0
b	0
f	0

11 Methods

Rating	Name	Duplication	Size	Complexity
B	updateCMSFields()	21	52	5
A	onAfterWrite()	0	5	1
B	createDefaultFields()	0	23	5
A	updateCMSActions()	0	16	2
A	getAvailability()	0	4	1
A	getGuestList()	0	6	1
A	getSuccessContent()	8	8	2
A	getMailContent()	8	8	2
A	getMailLogo()	0	4	1
A	canCreateTickets()	0	9	3
A	getController()	0	6	2

How to fix Duplicated Code

<?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 A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

How to fix Duplicated Code

Duplicated Code

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 A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

How to fix Duplicated Code

Duplicated Code

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