Sunnysideup\PerfectCmsImages\Api\SortOutFolders

Complexity

Total Complexity

30

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getListOfImages()	0	27	5
B	getFieldDetails()	0	24	9
A	getFolderArray()	0	16	4
B	removeUnusedFiles()	0	26	8
A	run()	0	16	4

<?php

namespace Sunnysideup\PerfectCmsImages\Api;

use SilverStripe\Control\Director;
use SilverStripe\Control\Controller;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Dev\BuildTask;
use SilverStripe\ORM\DB;

use SilverStripe\Assets\Image;
use SilverStripe\Assets\Folder;

use Sunnysideup\PerfectCmsImages\Api\PerfectCMSImages;

use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;

use SilverStripe\Core\ClassInfo;

use SilverStripe\Core\Injector\Injector;
class SortOutFolders
{

    use Configurable;

    /**
     * @var Folder
     */
    protected $unusedImagesFolder = null;

    /**
     *
     * @var bool
     */
    protected $debug = false;

    /**
     *
     * @var bool
     */
    protected $verbose = false;

    private static $unused_images_folder_name = 'unusedimages';

    /**
     * Create test jobs for the purposes of testing.
     * The array must contains arrays with
     * - folder
     * - used_by (has_one / has_many / many_many relation)
     *
     * @param HTTPRequest $request
     */
    public function run(string $unusedFolderName, array $data) // phpcs:ignore

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

    {

        $folderArray = $this->getFolderArray($data);
        if ($this->verbose) {
            print_r($folderArray);
        }

        $listOfImageIds = $this->getListOfImages($folderArray);
        if ($this->verbose) {
            print_r($listOfImageIds);
        }

        // remove
        foreach($listOfImageIds as $folderName => $listOfIds) {
            $this->removeUnusedFiles($folderName, $listOfIds);
        }
    }


    protected function getFolderArray(array $data) :array
    {

        // check folders
        $folderArray = [];
        foreach($data as $dataInner) {
            $folder = $dataInner['folder'] ?? '';
            if($folder) {
                $folderArray[$folder] = [];
                $classes = $dataInner['used_by'] ?? [];
                foreach($classes as $classAndMethodList) {
                    $folderArray[$folder][$classAndMethodList] = $classAndMethodList;
                }
            }
        }
        return $folderArray;
    }

    protected function getListOfImages(array $folderArray) : array
    {
        $listOfImageIds = [];
        foreach($folderArray as $folderName => $classAndMethodList) {

            // find all images that should be there...
            $listOfIds = [];
            foreach($classAndMethodList as $classAndMethod) {
                list($className, $method) = explode('.', $classAndMethod);
                $fieldDetails = $this->getFieldDetails($className, $method);
                if(empty($field)) {

The variable $field seems to never exist and therefore empty should always be true.

                    user_error('Could not find relation: '.$className.'.'.$method);
                }
                if($fieldDetails['dataType'] === 'has_one') {
                    $list = $className::get()->columnUnique($method.'ID');
                } else {
                    $dataClassName = $fieldDetails['dataClassName'];
                    $list = $dataClassName::get()->relation($method)->columnUnique('ID');
                }
                $listOfImageIds = array_merge(
                    $listOfImageIds,
                    $list
                );
            }
            $listOfImageIds[$folderName] = $listOfIds;
        }
        return $listOfImageIds;
    }

    protected function removeUnusedFiles(string $folderName, array $listOfImageIds)

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

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

    {
        $folder = Folder::find_or_make($this->config()->get('unused_images_folder_name'));
        $unusedFolderName = $this->unusedImagesFolder->Name;
        $where = " ParentID = " . $folder->ID. ' AND File.ID NOT IN('.implode('.$listOfImageIds.').')';

'.$listOfImageIds.' of type string is incompatible with the type array expected by parameter $pieces of implode().

        $unused = Image::get()->where($where);
        if ($unused->exists()) {
            foreach ($unused as $file) {
                $oldName = $file->getFullPath();
                if($this->verbose) {
                    DB::alteration_message('DEBUG ONLY '.$file->getFileName().' to '.$unusedFolderName);
                }
                if($this->debug) {
                    echo 'skipping as we are in debug mode';
                } else {
                    $file->ParentID = $this->unusedImagesFolder->ID;
                    $file->write();
                    $file->doPublish();
                    $newName = str_replace($folder->Name, $unusedFolderName, $oldName);
                    $oldNameFull = Controller::join_links(ASSETS_PATH, $oldName);
                    $newNameFull = Controller::join_links(ASSETS_PATH, $newName);
                    if (file_exists($oldNameFull) && $newNameFull !== $oldNameFull) {
                        if(file_exists($newNameFull)) {
                            unlink($newNameFull);
                        }
                        rename($oldNameFull, $newNameFull);
                    }
                }
            }
        }
    }

    protected static $my_cache = [];

    protected function getFieldDetails(string $originClassName, string $originMethod) : array
    {
        $key = $originClassName.'_'.$originMethod;
        if(! isset(self::$my_cache[$key])) {
            $types = ['has_one', 'has_many', 'many_many'];
            $classNames = ClassInfo::ancestry($originClassName, true);
            foreach ($classNames as $className) {
                $obj = Injector::inst()->get($className);

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

                foreach ($types as $type) {
                    $rels = Config::inst()->get($className, $type, Config::UNINHERITED);
                    if (is_array($rels) && ! empty($rels)) {
                        foreach ($rels as $relName => $relType) {
                            if (Image::class === $relType && $relName === $originatingFieldName) {

The variable $originatingFieldName seems to be never defined.

                                self::$my_cache[$key] = [
                                    'dataClassName' => $className,
                                    'dataType' => $type,
                                ];
                            }
                        }
                    }
                }
            }
        }
        return self::$my_cache[$key];
    }


}