Backpack\CRUD\app\Library\CrudPanel\Traits\Reorder::updateTreeOrder()

Complexity

Conditions	13
Paths	1

Size

Total Lines	67
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes	12
Bugs	5	Features	1

<?php
    public function updateTreeOrder($request)
    {
        $primaryKey = $this->model->getKeyName();

        $columns = $this->getOperationSetting('reorderColumnNames');

It seems like getOperationSetting() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        // we use the upsert method that should update the values of the matching ids.
        // it has the drawback of creating new entries when the id is not found
        // for that reason we get a list of all the ids and filter the ones
        // sent in the request that are not in the database
        $itemKeys = $this->model->query()->select($primaryKey)->get()->pluck($primaryKey);

        // filter the items that are not in the database and map the request
        $reorderItems = collect($request)->filter(function ($item) use ($itemKeys) {

$request of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            return $item['item_id'] !== '' && $item['item_id'] !== null && $itemKeys->contains($item['item_id']);
        })->map(function ($item) use ($primaryKey, $columns) {
            $item[$primaryKey] = $item['item_id'];
            $item[$columns['parent_id']] = empty($item['parent_id']) ? null : $item['parent_id'];
            $item[$columns['depth']] = empty($item['depth']) ? null : (int) $item['depth'];
            $item[$columns['lft']] = empty($item['left']) ? null : (int) $item['left'];
            $item[$columns['rgt']] = empty($item['right']) ? null : (int) $item['right'];
            
            // unset mapped items properties.
            if($columns['parent_id'] !== 'parent_id') { unset($item['parent_id']); };
            if($columns['depth'] !== 'depth') { unset($item['depth']); }
            if($columns['lft'] !== 'left') { unset($item['left']); }
            if($columns['rgt'] !== 'right') { unset($item['right']); }
            
            // unset the item_id property
            unset($item['item_id']);

            return $item;
        })->toArray();

        $sentIds = array_column($reorderItems, $primaryKey);

        $itemKeys = $itemKeys->filter(function ($id) use ($sentIds) {
            return in_array($id, $sentIds);
        });

        // wrap the queries in a transaction to avoid partial updates
        DB::connection($this->model->getConnectionName())->transaction(function () use ($reorderItems, $primaryKey, $itemKeys, $columns) {
            // create a string of ?,?,?,? to use as bind placeholders for item keys
            $reorderItemsBindString = implode(',', array_fill(0, count($reorderItems), '?'));

            // each of this properties will be updated using a single query with a CASE statement
            // this ensures that only 4 queries are run, no matter how many items are reordered
            foreach (array_values($columns) as $column) {
                $query = '';
                $bindings = [];
                $query .= "UPDATE {$this->model->getTable()} SET {$column} = CASE ";
                foreach ($reorderItems as $item) {
                    $query .= "WHEN {$primaryKey} = ? THEN ? ";
                    $bindings[] = $item[$primaryKey];
                    $bindings[] = $item[$column];
                }
                // add the bind placeholders for the item keys at the end the array of bindings
                array_push($bindings, ...$itemKeys->toArray());

                // add the where clause to the query to help match the items
                $query .= "ELSE {$column} END WHERE {$primaryKey} IN ({$reorderItemsBindString})";

                DB::connection($this->model->getConnectionName())->statement($query, $bindings);
            }
        });

        return count($reorderItems);
    }