createNewFolder()

Complexity

Conditions	51
Paths	8660

Size

Total Lines	314
Code Lines	186

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
function createNewFolder(
    string $title,
    int $parent_id,
    int $complexity,
    int $duration,
    int $create_auth_without,
    int $edit_auth_without,
    string $icon,
    string $icon_selected,
    string $access_rights,
    int $user_is_admin,
    array $user_accessible_folders,
    int $user_is_manager,
    int $user_can_create_root_folder,
    int $user_can_manage_all_users,
    int $user_id,
    string $user_roles
): array
{
    $session = SessionManager::getSession();
    $lang = new Language();

    // Load config if $SETTINGS not defined
    try {
        include_once __DIR__.'/../includes/config/tp.config.php';
    } catch (Exception $e) {
        throw new Exception("Error file '/includes/config/tp.config.php' not exists", 1);
    }

    // Init
    $error = false;

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

    $newId = '';

    // check if title is numeric
    if (is_numeric($title) === true) {
        return array(
            'error' => true,
            'message' => $lang->get('error_only_numbers_in_folder_name'),
            'newId' => $newId,
        );
    }
    // Check if parent folder is allowed for this user
    if (
        in_array($parent_id, $user_accessible_folders) === false
        && (int) $user_is_admin !== 1
    ) {
        return array(
            'error' => true,
            'message' => $lang->get('error_not_allowed_to'),
            'newId' => $newId."1",
        );
    }

    //Check if duplicate folders name are allowed
    if (
        isset($SETTINGS['duplicate_folder']) === true

The variable $SETTINGS seems to never exist and therefore isset should always be false.

        && (int) $SETTINGS['duplicate_folder'] === 0
    ) {
        DB::query(
            'SELECT *
            FROM ' . prefixTable('nested_tree') . '
            WHERE title = %s',
            $title
        );
        $counter = DB::count();
        if ($counter !== 0) {
            return array(
                'error' => true,
                'message' => $lang->get('error_group_exist'),
                'newId' => $newId,
            );
        }
    }

    //check if parent folder is personal
    $data = DB::queryfirstrow(
        'SELECT personal_folder, bloquer_creation, bloquer_modification
        FROM ' . prefixTable('nested_tree') . '
        WHERE id = %i',
        $parent_id
    );

    // inherit from parent the specific settings it has
    if (DB::count() > 0) {
        $parentBloquerCreation = $data['bloquer_creation'];
        $parentBloquerModification = $data['bloquer_modification'];
    } else {
        $parentBloquerCreation = 0;
        $parentBloquerModification = 0;
    }

    if (isset($data) === true && (int) $data['personal_folder'] === 1) {
        $isPersonal = 1;
    } else {
        $isPersonal = 0;

        // check if complexity level is good
        // if manager or admin don't care
        if (
            $user_is_admin === 0
            && ((int) $user_is_manager !== 1
                || (int) $user_can_manage_all_users !== 1)
        ) {
            // get complexity level for this folder
            $data = DB::queryfirstrow(
                'SELECT valeur
                FROM ' . prefixTable('misc') . '
                WHERE intitule = %i AND type = %s',
                $parent_id,
                'complex'
            );
            if (isset($data['valeur']) === true && intval($complexity) < intval($data['valeur'])) {
                return array(
                    'error' => true,
                    'message' => $lang->get('error_folder_complexity_lower_than_top_folder')
                        . ' [<b>' . TP_PW_COMPLEXITY[$data['valeur']][1] . '</b>]',
                    'newId' => $newId,
                );
            }
        }
    }

    if (
        (int) $isPersonal === 1
        || (int) $user_is_admin === 1
        || ((int) $user_is_manager === 1 || (int) $user_can_manage_all_users === 1)
        || (isset($SETTINGS['enable_user_can_create_folders']) === true
            && (int) $SETTINGS['enable_user_can_create_folders'] == 1)
        || ((int) $user_can_create_root_folder && null !== $user_can_create_root_folder && (int) $user_can_create_root_folder === 1)
    ) {
        //create folder
        DB::insert(
            prefixTable('nested_tree'),
            array(
                'parent_id' => $parent_id,
                'title' => $title,
                'personal_folder' => $isPersonal,
                'renewal_period' => isset($duration) === true && (int) $duration !== 0 ? $duration : 0,
                'bloquer_creation' => isset($create_auth_without) === true && (int) $create_auth_without === 1 ? '1' : $parentBloquerCreation,
                'bloquer_modification' => isset($edit_auth_without) === true && (int) $edit_auth_without === 1 ? '1' : $parentBloquerModification,
                'fa_icon' => empty($icon) === true ? TP_DEFAULT_ICON : $icon,
                'fa_icon_selected' => empty($icon_selected) === true ? TP_DEFAULT_ICON_SELECTED : $icon_selected,
                'categories' => '',
            )
        );
        $newId = DB::insertId();

        //Add complexity
        DB::insert(
            prefixTable('misc'),
            array(
                'type' => 'complex',
                'intitule' => $newId,
                'valeur' => $complexity,
            )
        );

        // ensure categories are set
        handleFoldersCategories(
            [$newId]
        );

        // Update timestamp
        DB::update(
            prefixTable('misc'),
            array(
                'valeur' => time(),
            ),
            'type = %s AND intitule = %s',
            'timestamp',
            'last_folder_change'
        );

        // add new folder id in SESSION
        if ($session->has('user-accessible_folders') === true) {
            $session->set('user-accessible_folders', array_unique(array_merge($session->get('user-accessible_folders'), [$newId]), SORT_NUMERIC));
            if ((int) $isPersonal === 1) {
                SessionManager::addRemoveFromSessionArray('user-personal_folders', [$newId], 'add');
            }
        }

        // Load tree
        $tree = new NestedTree(prefixTable('nested_tree'), 'id', 'parent_id', 'title');

        // rebuild tree
        $tree->rebuild();


        // --> build json tree if not Admin
        if ($user_is_admin === 0) {
            // Get path
            $path = '';
            $tree_path = $tree->getPath(0, false);
            foreach ($tree_path as $fld) {
                $path .= empty($path) === true ? $fld->title : '/'.$fld->title;
            }
            $new_json = [
                "path" => $path,
                "id" => $newId,
                "level" => count($tree_path),
                "title" => $title,
                "disabled" => 0,
                "parent_id" => $parent_id,
                "perso" => $isPersonal,
                "is_visible_active" => 0,
            ];

            // update cache_tree
            $cache_tree = DB::queryfirstrow(
                'SELECT increment_id, folders, visible_folders
                FROM ' . prefixTable('cache_tree').' WHERE user_id = %i',
                (int) $user_id
            );
            if (empty($cache_tree) === true) {
                DB::insert(
                    prefixTable('cache_tree'),
                    array(
                        'user_id' => $user_id,
                        'folders' => json_encode($newId),
                        'visible_folders' => json_encode($new_json),
                        'timestamp' => time(),
                        'data' => '[{}]',
                    )
                );
            } else {
                $a_folders = is_null($cache_tree['folders']) === true ? [] : json_decode($cache_tree['folders'], true);
                array_push($a_folders, $newId);
                $a_visible_folders = is_null($cache_tree['visible_folders']) === true || empty($cache_tree['visible_folders']) === true ? [] : json_decode($cache_tree['visible_folders'], true);
                array_push($a_visible_folders, $new_json);
                DB::update(
                    prefixTable('cache_tree'),
                    array(
                        'folders' => json_encode($a_folders),
                        'visible_folders' => json_encode($a_visible_folders),
                        'timestamp' => time(),
                    ),
                    'increment_id = %i',
                    (int) $cache_tree['increment_id']
                );
            }
        }
        // <-- end - build json tree

        // Create expected groups access rights based upon option selected
        if (
            isset($SETTINGS['subfolder_rights_as_parent']) === true
            && (int) $SETTINGS['subfolder_rights_as_parent'] === 1
        ) {
            //If it is a subfolder, then give access to it for all roles that allows the parent folder
            $rows = DB::query('SELECT role_id, type FROM ' . prefixTable('roles_values') . ' WHERE folder_id = %i', $parent_id);
            foreach ($rows as $record) {
                //add access to this subfolder
                DB::insert(
                    prefixTable('roles_values'),
                    array(
                        'role_id' => $record['role_id'],
                        'folder_id' => $newId,
                        'type' => $record['type'],
                    )
                );
            }
        } elseif ((int) $user_is_admin !== 1) {
            // If not admin and no option enabled
            // then provide expected rights based upon user's roles
            foreach (explode(';', $user_roles) as $role) {
                if (empty($role) === false) {
                    DB::insert(
                        prefixTable('roles_values'),
                        array(
                            'role_id' => $role,
                            'folder_id' => $newId,
                            'type' => $access_rights,
                        )
                    );
                }
            }
        }

        // if parent folder has Custom Fields Categories then add to this child one too
        $rows = DB::query('SELECT id_category FROM ' . prefixTable('categories_folders') . ' WHERE id_folder = %i', $parent_id);
        foreach ($rows as $record) {
            //add CF Category to this subfolder
            DB::insert(
                prefixTable('categories_folders'),
                array(
                    'id_category' => $record['id_category'],
                    'id_folder' => $newId,
                )
            );
        }

        // clear cache cache for each user that have at least one similar role as the current user
        $usersWithSimilarRoles = empty($user_roles) === false  ? getUsersWithRoles(
            explode(";", $user_roles)
        ) : [];
        foreach ($usersWithSimilarRoles as $user) {
            // delete cache tree
            DB::delete(
                prefixTable('cache_tree'),
                'user_id = %i',
                $user
            );
        }
        return array(
            'error' => false,
            'message' => '',
            'newId' => $newId,
        );

    } else {
        return array(
            'error' => true,
            'message' => $lang->get('error_not_allowed_to'),
            'newId' => $newId."2",
        );
}