luya\helpers\ExportHelper

Complexity

Total Complexity

24

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	csv()	0	8	1
A	xlsx()	0	11	1
A	transformInput()	0	8	2
D	generateContentArray()	0	47	16
A	generateOutputString()	0	9	2
A	generateRow()	0	11	2

<?php

namespace luya\helpers;

use yii\db\ActiveQueryInterface;
use yii\db\ActiveRecordInterface;
use luya\helpers\ArrayHelper;
use yii\helpers\Html;

This use statement conflicts with another class in this namespace, luya\helpers\Html.

use luya\Exception;

/**
 * Exporting into Formats.
 *
 * @author Basil Suter <basil@nadar.io>
 * @since 1.0.0
 */
class ExportHelper
{
    /**
     * Export an Array or ActiveQuery instance into a CSV formated string.
     *
     * @param array|ActiveQueryInterface $input The data to export into a csv
     * @param array $keys Defines which keys should be packed into the generated CSV. The defined keys does not change the sort behavior of the generated csv.
     * @param string $header Whether the column name should be set as header inside the csv or not.
     * @return string The generated CSV as string.
     */
    public static function csv($input, array $keys = [], $header = true)
    {
        $delimiter = ",";
        $input = self::transformInput($input);
        $array = self::generateContentArray($input, $keys, $header);

It seems like $input defined by self::transformInput($input) on line 30 can also be of type object; however, luya\helpers\ExportHelper::generateContentArray() does only seem to accept array, maybe add an additional type check?

$keys is of type array, but the function expects a string.

It seems like $header defined by parameter $header on line 27 can also be of type string; however, luya\helpers\ExportHelper::generateContentArray() does only seem to accept boolean, maybe add an additional type check?

        return self::generateOutputString($array, $delimiter);
    }

    /**
     * Export an Array or ActiveQuery instance into a Excel formatted string.
     *
     * @param array|ActiveQueryInterface $input
     * @param array $keys Defines which keys should be packed into the generated xlsx. The defined keys does not change the sort behavior of the generated xls.
     * @param bool $header
     * @return mixed
     * @throws Exception
     * @since 1.0.4
     */
    public static function xlsx($input, array $keys = [], $header = true)
    {
        $input = self::transformInput($input);

        $array = self::generateContentArray($input, $keys, $header);

It seems like $input defined by self::transformInput($input) on line 48 can also be of type object; however, luya\helpers\ExportHelper::generateContentArray() does only seem to accept array, maybe add an additional type check?

$keys is of type array, but the function expects a string.

        $writer = new XLSXWriter();
        $writer->writeSheet($array);

        return $writer->writeToString();
    }

    /**
     * Check type of input and return correct array.
     *
     * @param array|object $input
     * @return array
     * @since 1.0.4
     */
    protected static function transformInput($input)
    {
        if ($input instanceof ActiveQueryInterface) {
            return $input->all();
        }

        return $input;
    }

    /**
     * Generate content by rows.
     *
     * @param array $contentRows
     * @param string$delimiter
     * @param string $keys
     * @param bool $generateHeader
     * @return array
     * @throws Exception
     * @since 1.0.4
     */
    protected static function generateContentArray($contentRows, $keys, $generateHeader = true)
    {
        if (is_scalar($contentRows)) {
            throw new Exception("Content must be either an array, object or traversable");
        }

        $attributeKeys = $keys;
        $header = [];
        $rows = [];
        $i = 0;
        foreach ($contentRows as $content) {
            // handle rows content
            if (!empty($keys) && is_array($content)) {
                foreach ($content as $k => $v) {
                    if (!in_array($k, $keys)) {
                        unset($content[$k]);
                    }
                }
            } elseif (!empty($keys) && is_object($content)) {
                $attributeKeys[get_class($content)] = $keys;
            }
            $rows[$i] = ArrayHelper::toArray($content, $attributeKeys, false);

$attributeKeys is of type string, but the function expects a array.

            // handler header
            if ($i == 0 && $generateHeader) {
                if ($content instanceof ActiveRecordInterface) {
                    foreach ($content as $k => $v) {

The expression $content of type object<yii\db\ActiveRecordInterface> is not traversable.

                        if (empty($keys)) {
                            $header[] = $content->getAttributeLabel($k);

The method getAttributeLabel() does not exist on yii\db\ActiveRecordInterface. Did you maybe mean getAttribute()?

                        } elseif (in_array($k, $keys)) {
                            $header[] = $content->getAttributeLabel($k);

The method getAttributeLabel() does not exist on yii\db\ActiveRecordInterface. Did you maybe mean getAttribute()?

                        }
                    }
                } else {
                    $header = array_keys($rows[0]);
                }
            }

            $i++;
        }

        if ($generateHeader) {
            return ArrayHelper::merge([$header], $rows);
        }

        return $rows;
    }

    /**
     * @param array $input
     * @param $delimiter
     * @return null|string
     * @since 1.0.4
     */
    protected static function generateOutputString(array $input, $delimiter)
    {
        $output = null;
        foreach ($input as $row) {
            $output.= self::generateRow($row, $delimiter, '"');
        }

        return $output;
    }

    /**
     * Generate a row by its items.
     *
     * @param array $row
     * @param string $delimiter
     * @param string $enclose
     * @return string
     * @since 1.0.4
     */
    protected static function generateRow(array $row, $delimiter, $enclose)
    {
        array_walk($row, function (&$item) use ($enclose) {
            if (!is_scalar($item)) {
                $item = "array";
            }
            $item = $enclose.Html::encode($item).$enclose;
        });

        return implode($delimiter, $row) . PHP_EOL;
    }
}