+global\FieldUpload::processRawFieldData()

Complexity

Conditions	25
Paths	64

Size

Total Lines	159
Code Lines	86

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

<?php
        public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)
        {
            $status = self::__OK__;

            // No file given, save empty data:
            if ($data === null) {
                return array(
                    'file' => null,
                    'mimetype' => null,
                    'size' => null,
                    'meta' => null
                );
            }

            // Its not an array, so just retain the current data and return:
            if (is_array($data) === false) {
                $file = $this->getFilePath(basename($data));

                $result = array(
                    'file' => $data,
                    'mimetype' => null,
                    'size' => null,
                    'meta' => null
                );

                // Grab the existing entry data to preserve the MIME type and size information
                if (isset($entry_id)) {
                    $row = Symphony::Database()->fetchRow(0, sprintf(
                        "SELECT `file`, `mimetype`, `size`, `meta` FROM `tbl_entries_data_%d` WHERE `entry_id` = ?",
                        $this->get('id')
                    ),
                        array($entry_id)
                    );

                    if (empty($row) === false) {
                        $result = $row;
                    }
                }

                // Found the file, add any missing meta information:
                if (file_exists($file) && is_readable($file)) {
                    if (empty($result['mimetype'])) {
                        $result['mimetype'] = General::getMimeType($file);
                    }

                    if (empty($result['size'])) {
                        $result['size'] = filesize($file);
                    }

                    if (empty($result['meta'])) {
                        $result['meta'] = serialize(static::getMetaInfo($file, $result['mimetype']));
                    }

                    // The file was not found, or is unreadable:
                } else {
                    $message = __('The file uploaded is no longer available. Please check that it exists, and is readable.');
                    $status = self::__INVALID_FIELDS__;
                }

                return $result;
            }

            if ($simulate && is_null($entry_id)) {
                return $data;
            }

            // Check to see if the entry already has a file associated with it:
            if (is_null($entry_id) === false) {
                $row = Symphony::Database()->fetchRow(0, sprintf(
                    "SELECT * FROM `tbl_entries_data_%s` WHERE `entry_id` = ? LIMIT 1",
                    $this->get('id')
                ),
                    array($entry_id)
                );

                $existing_file = isset($row['file']) ? $this->getFilePath($row['file']) : null;

                // File was removed:
                if (
                    $data['error'] === UPLOAD_ERR_NO_FILE
                    && !is_null($existing_file)
                    && is_file($existing_file)
                ) {
                    General::deleteFile($existing_file);
                }
            }

            // Do not continue on upload error:
            if ($data['error'] === UPLOAD_ERR_NO_FILE || $data['error'] !== UPLOAD_ERR_OK) {
                return false;
            }

            // Where to upload the new file?
            $abs_path = DOCROOT . '/' . trim($this->get('destination'), '/');
            $rel_path = str_replace('/workspace', '', $this->get('destination'));

            // Sanitize the filename
            $data['name'] = Lang::createFilename($data['name']);

            // If a file already exists, then rename the file being uploaded by
            // adding `_1` to the filename. If `_1` already exists, the logic
            // will keep adding 1 until a filename is available (#672)
            if (file_exists($abs_path . '/' . $data['name'])) {
                $extension = General::getExtension($data['name']);
                $new_file = substr($abs_path . '/' . $data['name'], 0, -1 - strlen($extension));
                $renamed_file = $new_file;

$renamed_file is not used, you could remove the assignment.

                $count = 1;

                do {
                    $renamed_file = $new_file . '_' . $count . '.' . $extension;
                    $count++;
                } while (file_exists($renamed_file));

                // Extract the name filename from `$renamed_file`.
                $data['name'] = str_replace($abs_path . '/', '', $renamed_file);
            }

            $file = $this->getFilePath($data['name']);

            // Attempt to upload the file:
            $uploaded = General::uploadFile(
                $abs_path,
                $data['name'],
                $data['tmp_name'],
                Symphony::Configuration()->get('write_mode', 'file')

\Symphony::Configuration()->get('write_mode', 'file') is of type array|string, but the function expects a integer.

            );

            if ($uploaded === false) {
                $message = __(
                    __('There was an error while trying to upload the file %1$s to the target directory %2$s.'),
                    array(
                        '<code>' . $data['name'] . '</code>',
                        '<code>workspace/' . ltrim($rel_path, '/') . '</code>'
                    )
                );
                $status = self::__ERROR_CUSTOM__;

                return false;
            }

            // File has been replaced:
            if (
                isset($existing_file)
                && $existing_file !== $file
                && is_file($existing_file)
            ) {
                General::deleteFile($existing_file);
            }

            // Get the mimetype, don't trust the browser. RE: #1609
            $data['type'] = General::getMimeType($file);

            return array(
                'file' => basename($file),
                'size' => $data['size'],
                'mimetype' => $data['type'],
                'meta' => serialize(static::getMetaInfo($file, $data['type']))
            );
        }