SilverCommerce\ContactAdmin\Model\Contact

Complexity

Total Complexity

70

Size/Duplication

Total Lines	702
Duplicated Lines	0 %

Importance

Changes	8
Bugs	0	Features	1

25 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefaultSearchContext()	0	6	1
A	LocationByPos()	0	2	1
A	getFullName()	0	17	3
A	onBeforeDelete()	0	12	3
A	getTitle()	0	21	4
A	getDefaultAddress()	0	8	2
A	getListsList()	0	10	1
A	getFlagged()	0	13	3
A	syncToMember()	0	21	6
A	canDelete()	0	17	5
A	getTagsList()	0	9	1
A	canCreate()	0	17	5
A	canView()	0	17	5
A	canEdit()	0	17	5
A	getCMSValidator()	0	12	1
A	getCMSFields()	0	65	2
A	getByMostLocations()	0	21	3
A	providePermissions()	0	57	1
B	getExportFields()	0	39	8
A	relField()	0	10	3
A	getModelAdminSearchContext()	0	6	1
A	onAfterWrite()	0	5	1
A	DefaultLocation()	0	15	2
A	getName()	0	3	1
A	getFlaggedNice()	0	8	2

<?php

namespace SilverCommerce\ContactAdmin\Model;

use SilverStripe\ORM\DB;
use SilverStripe\ORM\DataQuery;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\Member;
use SilverStripe\Security\Security;
use SilverStripe\TagField\TagField;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Security\Permission;
use SilverStripe\Versioned\Versioned;
use SilverStripe\Forms\RequiredFields;
use SilverStripe\ORM\Queries\SQLSelect;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Security\PermissionProvider;
use SilverCommerce\ContactAdmin\Model\ContactTag;
use SilverCommerce\ContactAdmin\Model\ContactLocation;
use SilverStripe\ORM\FieldType\DBHTMLText as HTMLText;
use SilverCommerce\CatalogueAdmin\Search\ContactSearchContext;
use SilverStripe\Forms\GridField\GridFieldConfig_RelationEditor;
use SilverCommerce\VersionHistoryField\Forms\VersionHistoryField;
use NathanCox\HasOneAutocompleteField\Forms\HasOneAutocompleteField;
use SilverStripe\Core\Config\Config;

/**
 * Details on a particular contact
 *
 * @property string FirstName
 * @property string Surname
 * @property string Company
 * @property string Phone
 * @property string Mobile
 * @property string Email
 * @property string Source
 * @property bool   Flagged
 *
 * @method \SilverStripe\ORM\HasManyList  Locations
 * @method \SilverStripe\ORM\HasManyList  Notes
 * @method \SilverStripe\ORM\ManyManyList Tags
 * @method \SilverStripe\ORM\ManyManyList Lists
 *
 * @author  ilateral
 * @package Contacts
 */
class Contact extends DataObject implements PermissionProvider
{
    const LOCATION_BY_POS = 'LocationByPos';

    const PERMISSION_MANAGE = 'CONTACTS_MANAGE';

    const PERMISSION_CREATE = 'CONTACTS_CREATE';

    const PERMISSION_VIEW = 'CONTACTS_VIEW';

    const PERMISSION_EDIT = 'CONTACTS_EDIT';

    const PERMISSION_DELETE = 'CONTACTS_DELETE';

    private static $table_name = 'Contact';

    /**
     * String used to seperate tags, lists, etc
     * when rendering a summary.
     *
     * @var string
     */
    private static $list_seperator = ", ";

    private static $db = [
        "FirstName" => "Varchar(255)",
        "Surname" => "Varchar(255)",
        "Company" => "Varchar(255)",
        "Phone" => "Varchar(15)",
        "Mobile" => "Varchar(15)",
        "Email" => "Varchar(255)",
        "Source" => "Text"
    ];

    private static $has_one = [
        "Member" => Member::class
    ];

    private static $has_many = [
        "Locations" => ContactLocation::class,
        "Notes" => ContactNote::class
    ];
    
    private static $many_many = [
        'Tags' => ContactTag::class
    ];

    private static $belongs_many_many = [
        'Lists' => ContactList::class
    ];
    
    private static $casting = [
        'TagsList' => 'Varchar',
        'ListsList' => 'Varchar',
        'FlaggedNice' => 'Boolean',
        'FullName' => 'Varchar',
        'Name' => 'Varchar',
        "DefaultAddress" => "Text"
    ];

    private static $field_labels = [
        "FlaggedNice" =>"Flagged",
        "DefaultAddress" => "Default Address",
        "TagsList" => "Tags",
        "ListsList" => "Lists",
        "Locations.Address1" => 'Address 1',
        "Locations.Address2" => 'Address 2',
        "Locations.City" => 'City',
        "Locations.Country" => 'Country',
        "Locations.PostCode" => 'Post Code',
        "Tags.Title" => 'Tag',
        "Lists.Title" => 'List'
    ];
    
    private static $summary_fields = [
        "FlaggedNice",
        "FirstName",
        "Surname",
        "Email",
        "DefaultAddress",
        "TagsList",
        "ListsList"
    ];

    private static $searchable_fields = [
        "FirstName",
        "Surname",
        "Email",
        "Locations.Address1",
        "Locations.Address2",
        "Locations.City",
        "Locations.Country",
        "Locations.PostCode",
        "Tags.Title",
        "Lists.Title"
    ];

    private static $export_fields = [
        "FirstName",
        "Surname",
        "Company",
        "Phone",
        "Mobile",
        "Email",
        "Source",
        "TagsList",
        "ListsList"
    ];

    private static $default_sort = [
        "FirstName" => "ASC",
        "Surname" => "ASC"
    ];

    /**
     * Add extension classes
     *
     * @var    array
     * @config
     */
    private static $extensions = [
        Versioned::class . '.versioned',
    ];

    /**
     * Declare version history
     *
     * @var    array
     * @config
     */
    private static $versioning = [
        "History"
    ];

    /**
     * Fields that can be synced with associated member
     * 
     * @var array
     */
    private static $sync_fields = [
        "FirstName",
        "Surname",
        "Company",
        "Phone",
        "Mobile",
        "Email"
    ];
    
    public function getTitle()
    {
        $parts = [];

        if (!empty($this->FirstName)) {
            $parts[] = $this->FirstName;
        }

        if (!empty($this->Surname)) {
            $parts[] = $this->Surname;
        }

        if (!empty($this->Email)) {
            $parts[] = "($this->Email)";
        }

        $title = implode(" ", $parts);

        $this->extend("updateTitle", $title);
        
        return $title;
    }

    public function getFullName() 
    {
        $parts = [];

        if (!empty($this->FirstName)) {
            $parts[] = $this->FirstName;
        }

        if (!empty($this->Surname)) {
            $parts[] = $this->Surname;
        }

        $name = implode(" ", $parts);
        
        $this->extend("updateFullName", $name);

        return $name;
    }
    
    public function getFlaggedNice()
    {
        $obj = HTMLText::create();
        $obj->setValue(($this->Flagged)? '<span class="red">&#10033;</span>' : '');

        $this->extend("updateFlaggedNice", $obj);
       
        return $obj;
    }

    /**
     * Get a contact with the most locations assigned
     *
     * @return self|null
     */
    public static function getByMostLocations()
    {
        $id = null;
        $query = new SQLSelect();
        $query
            ->setFrom('Contact')
            ->setSelect('Contact.ID, count(ContactLocation.ID) as LocationsCount')
            ->addLeftJoin('ContactLocation', 'Contact.ID = ContactLocation.ContactID')
            ->addGroupBy('Contact.ID')
            ->addOrderBy('LocationsCount', 'DESC')
            ->setLimit(1);

        foreach($query->execute() as $row) {
            $id = $row['ID'];
        }

        if (!empty($id)) {
            return Contact::get()->byID($id);
        }

        return;
    }

    /**
     * Find from our locations one marked as default (of if not the
     * first in the list).
     *
     * If not location available, return a blank one
     *
     * @return ContactLocation
     */
    public function DefaultLocation()
    {
        $location = $this
            ->Locations()
            ->sort("Default", "DESC")
            ->first();
        
        if (empty($location)) {
            $location = ContactLocation::create();
            $location->ID = -1;
        }
        
        $this->extend("updateDefaultLocation", $location);

        return $location;
    }

    /**
     * Find from our locations one marked as default (of if not the
     * first in the list).
     *
     * @return string
     */
    public function getDefaultAddress()
    {
        $location = $this->DefaultLocation();

        if ($location) {

$location is of type SilverCommerce\ContactAdmin\Model\ContactLocation, thus it always evaluated to true.

            return $location->Address;
        } else {
            return "";
        }
    }

    /**
     * Get the complete name of the member
     *
     * @return string Returns the first- and surname of the member.
     */
    public function getName() 
    {
        return $this->getFullName();
    }

    /**
     * Generate as string of tag titles seperated by a comma
     *
     * @return string
     */
    public function getTagsList()
    {
        $tags = $this->Tags()->column("Title");

        $this->extend("updateTagsList", $tags);

        return implode(
            $this->config()->list_seperator,
            $tags
        );
    }

    /**
     * Generate as string of list titles seperated by a comma
     *
     * @return string
     */
    public function getListsList()
    {
        $return = "";

The assignment to $return is dead and can be removed.

        $list = $this->Lists()->column("Title");

        $this->extend("updateListsList", $tags);

        return implode(
            $this->config()->list_seperator,
            $list
        );
    }
    
    public function getFlagged()
    {
        $flagged = false;
        
        foreach ($this->Notes() as $note) {
            if ($note->Flag) {
                $flagged = true;
            }
        }

        $this->extend("updateFlagged", $flagged);

        return $flagged;
    }
    
    /**
     * Update an associated member with the data from this contact
     * 
     * @return void
     */
    public function syncToMember()
    {
        $member = $this->Member();

The method Member() does not exist on SilverCommerce\ContactAdmin\Model\Contact. Since you implemented __call, consider adding a @method annotation.

        $sync = $this->config()->sync_fields;
        $write = false;

        if (!$member->exists()) {
            return;
        }

        foreach ($this->getChangedFields() as $field => $change) {
            // If this field is a field to sync, and it is different
            // then update member
            if (in_array($field, $sync) && $member->$field != $this->$field) {
                $member->$field = $this->$field;
                $write = true;
            }
        }

        if ($write) {
            $member->write();
        }
    }

    /**
     * Load custom search context to allow for filtering by flagged notes
     * 
     * @return ContactSearchContext
     */
    public function getDefaultSearchContext()
    {
        return ContactSearchContext::create(
            static::class,
            $this->scaffoldSearchFields(),
            $this->defaultSearchFilters()
        );
    }

    /**
     * Load custom search context for model admin plus
     * 
     * @return ContactSearchContext
     */
    public function getModelAdminSearchContext()
    {
        return ContactSearchContext::create(
            static::class,
            $this->scaffoldSearchFields(),
            $this->defaultSearchFilters()
        );
    }

    public function getCMSFields()
    {
        $self = $this;
        $this->beforeUpdateCMSFields(
            function ($fields) use ($self) {
                $fields->removeByName("Tags");
                $fields->removeByName("Notes");
            
                $tag_field = TagField::create(
                    'Tags',
                    null,
                    ContactTag::get(),
                    $self->Tags()
                )->setRightTitle(
                    _t(
                        "Contacts.TagDescription",
                        "List of tags related to this contact, seperated by a comma."
                    )
                )->setShouldLazyLoad(true);
            
                if ($self->exists()) {
                    $gridField = GridField::create(
                        'Notes',
                        'Notes',
                        $self->Notes()
                    );
                
                    $config = GridFieldConfig_RelationEditor::create();

                    $gridField->setConfig($config);

                    $fields->addFieldToTab(
                        "Root.Notes",
                        $gridField
                    );

                    $fields->addFieldToTab(
                        "Root.History",
                        VersionHistoryField::create(
                            "History",
                            _t("SilverCommerce\VersionHistoryField.History", "History"),
                            $self
                        )->addExtraClass("stacked")
                    );
                }
            
                $fields->addFieldsToTab(
                    "Root.Main",
                    [
                    $member_field = HasOneAutocompleteField::create(

The assignment to $member_field is dead and can be removed.

                        'MemberID',
                        _t(
                            'SilverCommerce\ContactAdmin.LinkContactToAccount',
                            'Link this contact to a user account?'
                        ),
                        Member::class,
                        'Title'
                    ),
                    $tag_field
                    ]
                );
            }
        );

        return parent::getCMSFields();
    }
    
    public function getCMSValidator()
    {
        $validator = new RequiredFields(
            array(
            "FirstName",
            "Surname"
            )
        );

        $this->extend('updateCMSValidator', $validator);

        return $validator;
    }

    public function LocationByPos($pos = 0)

The parameter $pos is not used and could be removed.

    {
    }

    /**
     * Get the default export fields for this object
     *
     * @return array
     */
    public function getExportFields()
    {
        $raw_fields = $this->config()->get('export_fields');
        $loc_fields = ContactLocation::singleton()->getExportFields();

        // Merge associative / numeric keys
        $fields = [];
        foreach ($raw_fields as $key => $value) {
            if (is_int($key)) {
                $key = $value;
            }
            $fields[$key] = $value;
        }

        // Work out address fields for export
        $most_locations = self::getByMostLocations();
        $location_count = 0;

        if (!empty($most_locations)) {
            $location_count = $most_locations->Locations()->count();
        }

        for ($i = 0; $i < $location_count; $i++) {
            foreach ($loc_fields as $key => $value) {
                if (is_int($key)) {
                    $key = $value;
                }
                $fields[self::LOCATION_BY_POS . $i . '.' . $key] = 'Address' . $i . '_' . $value;
            }
        }

        $this->extend("updateExportFields", $fields);

        // Final fail-over, just list ID field
        if (!$fields) {
            $fields['ID'] = 'ID';
        }

        return $fields;
    }

    /**
     * Check field 
     *
     * @param string $fieldName string
     *
     * @return mixed Will return null on a missing value
     */
    public function relField($fieldName)
    {
        /** @todo This is a bit in-effitient, woud be nice to do this with slightly less queries */
        if (strpos($fieldName, self::LOCATION_BY_POS) !== false) {
            $pos = (int) substr($fieldName, strlen(self::LOCATION_BY_POS), 1);
            $loc_field = substr($fieldName, strpos($fieldName, '.') + 1);
            $location = $this->Locations()->limit(1, $pos)->first();
            return empty($location) ? "" : $location->$loc_field;
        } else {
            return parent::relField($fieldName);
        }
    }

    public function providePermissions()
    {
        return array(
            self::PERMISSION_MANAGE => array(
                'name' => _t(
                    'Contacts.PERMISSION_MANAGE_CONTACTS_DESCRIPTION',
                    'Manage contacts'
                ),
                'help' => _t(
                    'Contacts.PERMISSION_MANAGE_CONTACTS_HELP',
                    'Allow creation and editing of contacts'
                ),
                'category' => _t('Contacts.Contacts', 'Contacts')
            ),
            self::PERMISSION_CREATE => array(
                'name' => _t(
                    'Contacts.PERMISSION_CREATE_CONTACTS_DESCRIPTION',
                    'Create contacts'
                ),
                'help' => _t(
                    'Contacts.PERMISSION_CREATE_CONTACTS_HELP',
                    'Allow creation of contacts'
                ),
                'category' => _t('Contacts.Contacts', 'Contacts')
            ),
            self::PERMISSION_VIEW => array(
                'name' => _t(
                    'Contacts.PERMISSION_VIEW_CONTACTS_DESCRIPTION',
                    'View contacts'
                ),
                'help' => _t(
                    'Contacts.PERMISSION_CREATE_CONTACTS_HELP',
                    'Allow viewing of contacts'
                ),
                'category' => _t('Contacts.Contacts', 'Contacts')
            ),
            self::PERMISSION_EDIT => array(
                'name' => _t(
                    'Contacts.PERMISSION_EDIT_CONTACTS_DESCRIPTION',
                    'Edit contacts'
                ),
                'help' => _t(
                    'Contacts.PERMISSION_EDIT_CONTACTS_HELP',
                    'Allow editing of contacts'
                ),
                'category' => _t('Contacts.Contacts', 'Contacts')
            ),
            self::PERMISSION_DELETE => array(
                'name' => _t(
                    'Contacts.PERMISSION_DELETE_CONTACTS_DESCRIPTION',
                    'Delete contacts'
                ),
                'help' => _t(
                    'Contacts.PERMISSION_DELETE_CONTACTS_HELP',
                    'Allow deleting of contacts'
                ),
                'category' => _t('Contacts.Contacts', 'Contacts')
            )
        );
    }
    
    public function canView($member = null)
    {
        $extended = $this->extendedCan(__FUNCTION__, $member);

        if ($extended !== null) {
            return $extended;
        }

        if (!$member) {
            $member = Security::getCurrentUser();
        }

        if ($member && Permission::checkMember($member->ID, [self::PERMISSION_MANAGE, self::PERMISSION_VIEW])) {
            return true;
        }

        return false;
    }

    public function canCreate($member = null, $context = [])
    {
        $extended = $this->extendedCan(__FUNCTION__, $member, $context);

        if ($extended !== null) {
            return $extended;
        }

        if (!$member) {
            $member = Security::getCurrentUser();
        }

        if ($member && Permission::checkMember($member->ID, [self::PERMISSION_MANAGE, self::PERMISSION_CREATE])) {
            return true;
        }

        return false;
    }

    public function canEdit($member = null)
    {
        $extended = $this->extendedCan(__FUNCTION__, $member);

        if ($extended !== null) {
            return $extended;
        }

        if (!$member) {
            $member = Security::getCurrentUser();
        }

        if ($member && Permission::checkMember($member->ID, [self::PERMISSION_MANAGE, self::PERMISSION_EDIT])) {
            return true;
        }

        return false;
    }

    public function canDelete($member = null, $context = [])

The parameter $context is not used and could be removed.

    {
        $extended = $this->extendedCan(__FUNCTION__, $member);

        if ($extended !== null) {
            return $extended;
        }

        if (!$member) {
            $member = Security::getCurrentUser();
        }

        if ($member && Permission::checkMember($member->ID, self::PERMISSION_DELETE)) {
            return true;
        }

        return false;
    }

    /**
     * Sync to associated member (if needed)
     * 
     * @return void
     */
    public function onAfterWrite()
    {
        parent::onAfterWrite();

        $this->syncToMember();
    }

    /**
     * Cleanup DB on removal
     */
    public function onBeforeDelete()
    {
        parent::onBeforeDelete();
        
        // Delete all locations attached to this order
        foreach ($this->Locations() as $item) {
            $item->delete();
        }

        // Delete all notes attached to this order
        foreach ($this->Notes() as $item) {
            $item->delete();
        }
    }
}