Fix: Concrete CMS File Upload Error With Empty Messages

Experiencing a file upload error in Concrete CMS can be frustrating, especially when accompanied by empty messages. This article dives deep into a specific issue encountered in Concrete CMS 9.x, where users with upload permissions face error popups with no content when attempting to upload files. We'll explore the cause of this problem, provide a step-by-step guide to reproduce it, offer a potential solution, and discuss additional context for a more robust fix. This issue specifically arises when a user belongs to a group with file upload permissions but has not yet uploaded any files.

Understanding the Concrete CMS File Upload Issue

The problem manifests as two error popups with empty content appearing when a user opens the "Choose File" dialog. This occurs because the request to /ccm/system/file/chooser/get_folder_files/1 returns an empty response instead of the expected JSON data. Digging deeper, the root cause lies in the \Concrete\Core\Controller\AbstractController::runAction method, which returns null instead of a JsonResponse for the \Concrete\Controller\Backend\File\Chooser controller. This unexpected behavior is triggered when \Concrete\Controller\Backend\File\Chooser::shouldRunControllerTask returns false because the user has no files uploaded yet. Consequently, the controller never reaches the getFolderFiles method, leading to the empty error messages. This situation highlights a specific edge case in Concrete CMS's file handling, where the system doesn't gracefully handle the scenario of a user with upload permissions attempting their first file upload.

How to Reproduce the Error

Reproducing this file upload error is crucial for understanding the issue and verifying the effectiveness of any proposed solutions. Here's a step-by-step guide to replicate the problem in your Concrete CMS 9.x installation:

1. Create a Group with Permissions: Begin by creating a new user group within Concrete CMS. This group should be granted the necessary permissions to upload files and create pages. These permissions are essential for simulating the scenario where a user should be able to upload files but encounters an error.
2. Create a Page Type with a File Attribute: Next, create a new Page Type. Within this Page Type, include a file attribute. A common example is a "Thumbnail" attribute, which allows users to upload an image associated with the page. This attribute will serve as the trigger for the file upload functionality.
3. Create a User and Log In: Now, create a new user and assign them to the group you created in Step 1. Log in to Concrete CMS as this newly created user. This ensures you're operating within the context of a user who has the specified permissions but has not yet uploaded any files.
4. Create a New Page: From the Concrete CMS toolbar, initiate the creation of a new page. Select the Page Type you created in Step 2. This will lead you to the page creation form, which includes the file attribute.
5. Open Choose File: Locate the file attribute field (e.g., "Thumbnail") and click the "Choose File" button. This action should open the file chooser dialog, which is where the error manifests.
6. Observe the Error: If the issue is present, two error windows will appear within the file chooser dialog. These windows will contain empty messages, indicating the error we're investigating. This confirms that you have successfully reproduced the file upload error.

By following these steps, you can reliably reproduce the error and test any potential fixes. This systematic approach is crucial for ensuring that the solution effectively addresses the problem.

Proposed Solution: Overriding the runAction Method

A potential solution to this file upload issue involves overriding the runAction method in the \Concrete\Controller\Backend\File\Chooser class. This approach allows us to intercept the controller's response and ensure that a JsonResponse is always returned, even when the user has no files yet.

Here's the code snippet that demonstrates the proposed solution:

public function runAction($action, $parameters = [])
{
    $result = parent::runAction($action, $parameters);
    if ($result instanceof JsonResponse) {
        return $result;
    }
    return new JsonResponse($result);
}

Explanation:

1. Call Parent Method: The overridden runAction method first calls the parent class's runAction method using parent::runAction($action, $parameters). This ensures that the original controller logic is executed.
2. Check for JsonResponse: The result of the parent method call is stored in the $result variable. The code then checks if $result is an instance of JsonResponse using if ($result instanceof JsonResponse). This step is crucial for maintaining the existing behavior of the controller when a JsonResponse is already being returned.
3. Return JsonResponse: If $result is a JsonResponse, it is returned directly. This ensures that existing functionality that relies on JsonResponse is not disrupted.
4. Create JsonResponse: If $result is not a JsonResponse (which is the case when the user has no files and shouldRunControllerTask returns false), a new JsonResponse is created using return new JsonResponse($result). This ensures that a JsonResponse is always returned, resolving the issue of the empty error messages.

By implementing this override, the controller will consistently return a JsonResponse, preventing the error popups with empty content. This approach provides a straightforward fix for the specific scenario where users encounter the error when attempting their first file upload.

Additional Context: Configuration Option for Empty Responses

While the proposed solution effectively addresses the immediate file upload error, it's essential to consider a more robust and configurable approach for handling similar situations in the future. One suggestion is to introduce a configuration option that controls whether empty responses are allowed in the file manager.

This configuration option could be implemented as follows:

concrete.file_manager.return_empty_response_on_no_access

This option would accept boolean values (true or false) to determine the behavior of the file manager when a user lacks access to specific files or folders. Here's how the values would be interpreted:

• true: An empty response is allowed. This would maintain the current behavior (without the fix) where an empty response is returned, potentially leading to errors like the one discussed in this article.
• false: An empty response is not allowed. In this case, the system would explicitly handle the scenario, potentially by returning a more informative error message or redirecting the user to a different page. This would provide a more user-friendly experience and prevent confusion.

By introducing this configuration option, Concrete CMS administrators would have greater control over how the file manager handles access restrictions and empty responses. This would allow them to tailor the system's behavior to their specific needs and preferences.

Furthermore, this configuration option could be extended to control the behavior for selected controller methods. This would provide even finer-grained control over how empty responses are handled in different parts of the file manager. For example, administrators might choose to allow empty responses for certain methods while disallowing them for others.

This additional context highlights the importance of considering long-term solutions and providing administrators with the tools they need to manage their Concrete CMS installations effectively. By introducing a configuration option for empty responses, Concrete CMS can become even more robust and user-friendly.

Conclusion

In conclusion, the file upload error in Concrete CMS 9.x with empty messages is a specific issue that arises when users with upload permissions attempt their first file upload. This article has provided a comprehensive analysis of the problem, including a step-by-step guide to reproduce it, a potential solution involving overriding the runAction method, and a discussion of a more robust approach using a configuration option. By understanding the root cause of this error and implementing the proposed solutions, Concrete CMS users can ensure a smoother and more user-friendly file upload experience.

For more information on Concrete CMS and its features, visit the official Concrete CMS website: Concrete CMS Documentation