GridFieldQueuedExportButton

Complexity

Total Complexity

21

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getHTMLFragments()	0	15	1
A	getActions()	0	3	1
A	handleAction()	0	7	3
A	startExport()	0	18	2
A	getURLHandlers()	0	6	1
B	checkExport()	0	40	5
A	downloadExport()	0	8	1
A	getExportColumns()	0	3	1
A	setExportColumns()	0	4	1
A	getCsvSeparator()	0	3	1
A	setCsvSeparator()	0	4	1
A	getCsvHasHeader()	0	3	1
A	setCsvHasHeader()	0	4	1

<?php

/**
 * A button you can add to a GridField to export that GridField as a CSV. Should work with any sized GridField,
 * as the export is done using a queuedjob in the background.
 */
class GridFieldQueuedExportButton implements GridField_HTMLProvider, GridField_ActionProvider, GridField_URLHandler {

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

    /**
     * @var array Map of a property name on the exported objects, with values being the column title in the CSV file.
     * Note that titles are only used when {@link $csvHasHeader} is set to TRUE.
     */
    protected $exportColumns;

    /**
     * @var string
     */
    protected $csvSeparator = ",";

    /**
     * @var boolean
     */
    protected $csvHasHeader = true;

    /**
     * Fragment to write the button to
     */
    protected $targetFragment;

    /**
     * @param string $targetFragment The HTML fragment to write the button into
     * @param array $exportColumns The columns to include in the export
     */
    public function __construct($targetFragment = "after", $exportColumns = null) {
        $this->targetFragment = $targetFragment;
        $this->exportColumns = $exportColumns;

It seems like $exportColumns can be null. However, the property $exportColumns is declared as array. Maybe change the type of the property to array|null or add a type check?

    }

    /**
     * Place the export button in a <p> tag below the field
     */
    public function getHTMLFragments($gridField) {
        $button = new GridField_FormAction(
            $gridField,
            'export',
            _t('TableListField.CSVEXPORT', 'Export to CSV'),
            'export',
            null

null is of type null, but the function expects a array.

        );
        $button->setAttribute('data-icon', 'download-csv');
        $button->addExtraClass('action_batch_export');
        $button->setForm($gridField->getForm());
        return array(
            $this->targetFragment => '<p class="grid-csv-button">' . $button->Field() . '</p>',
        );
    }

    /**
     * This class is an action button
     */
    public function getActions($gridField) {
        return array('export', 'findgridfield');
    }

    public function handleAction(GridField $gridField, $actionName, $arguments, $data) {
        if ($actionName == 'export') {
            return $this->startExport($gridField);
        } else if ($actionName == 'findgridfield') {
            return new GridFieldQueuedExportButton_Response($gridField);
        }
    }

    function startExport($gridField) {

It is generally recommended to explicitly declare the visibility for methods.

        $job = new GenerateCSVJob();

        // Set the parameters that allow re-discovering this gridfield during background execution
        $job->setGridField($gridField);
        $job->setSession(Controller::curr()->getSession()->get_all());

        // Set the parameters that control CSV exporting
        $job->setSeparator($this->csvSeparator);
        $job->setIncludeHeader($this->csvHasHeader);
        if ($this->exportColumns) $job->setColumns($this->exportColumns);

The expression $this->exportColumns of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

        // Queue the job
        singleton('QueuedJobService')->queueJob($job);

        // Redirect to the status update page
        return Controller::curr()->redirect($gridField->Link() . '/export/' . $job->getSignature());
    }

    /**
     * This class is also a URL handler
     */
    public function getURLHandlers($gridField) {
        return array(
            'export/$ID'          => 'checkExport',
            'export_download/$ID' => 'downloadExport'
        );
    }

    /**
     * Handle the export, for both the action button and the URL
     */
    public function checkExport($gridField, $request = null) {
        $id = $request->param('ID');
        $job = QueuedJobDescriptor::get()->filter('Signature', $id)->first();

        $controller = $gridField->getForm()->getController();

        $breadcrumbs = $controller->Breadcrumbs(false);
        $breadcrumbs->push(new ArrayData(array(
            'Title' => 'Export CSV',
            'Link'  => false
        )));

        $parents = $controller->Breadcrumbs(false)->items;
        $backlink = array_pop($parents)->Link;

        $data = new ArrayData(array(
            'Backlink'    => $backlink,
            'Breadcrumbs' => $breadcrumbs,
            'GridName'    => $gridField->getname()
        ));

        if ($job->JobStatus == QueuedJob::STATUS_COMPLETE) {
            $data->Link = $gridField->Link() . '/export_download/' . $job->Signature;
        } else if ($job->JobStatus == QueuedJob::STATUS_BROKEN) {
            $data->ErrorMessage = "Sorry, but there was an error exporting the CSV";
        } else if ($job->JobStatus == QueuedJob::STATUS_CANCELLED) {
            $data->ErrorMessage = "This export job was cancelled";
        } else {
            $data->Count = $job->StepsProcessed;
            $data->Total = $job->TotalSteps;
        }

        $return = $data->renderWith('GridFieldQueuedExportButton');

        if ($request->isAjax()) {
            return $return;
        } else {
            return $controller->customise(array('Content' => $return));
        }
    }

    public function downloadExport($gridField, $request = null) {

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

        $id = $request->param('ID');

        $now = Date("d-m-Y-H-i");
        $fileName = "export-$now.csv";

        return SS_HTTPRequest::send_file(file_get_contents('/tmp/' . $id . '.csv'), $fileName, 'text/csv');
    }

    /**
     * @return array
     */
    public function getExportColumns() {
        return $this->exportColumns;
    }

    /**
     * @param array
     */
    public function setExportColumns($cols) {
        $this->exportColumns = $cols;
        return $this;
    }

    /**
     * @return string
     */
    public function getCsvSeparator() {
        return $this->csvSeparator;
    }

    /**
     * @param string
     */
    public function setCsvSeparator($separator) {
        $this->csvSeparator = $separator;
        return $this;
    }

    /**
     * @return boolean
     */
    public function getCsvHasHeader() {
        return $this->csvHasHeader;
    }

    /**
     * @param boolean
     */
    public function setCsvHasHeader($bool) {
        $this->csvHasHeader = $bool;
        return $this;
    }
}

/**
 * A special type of SS_HTTPResponse that GridFieldQueuedExportButton returns in response to the "findgridfield"
 * action, which includes a reference to the gridfield
 */
class GridFieldQueuedExportButton_Response extends SS_HTTPResponse {

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

    private $gridField;

    public function __construct(GridField $gridField) {
        $this->gridField = $gridField;
        parent::__construct('', 500);
    }

    public function getGridField() {
        return $this->gridField;
    }
}