PHP AssetsHelper::getTempFilePath方法代码示例

 /**
  * @inheritDoc BaseAssetSourceType::getLocalCopy()
  *
  * @param AssetFileModel $file
  *
  * @return mixed
  */
 public function getLocalCopy(AssetFileModel $file)
 {
     $location = AssetsHelper::getTempFilePath($file->getExtension());
     $this->_prepareForRequests();
     $this->_googleCloud->getObject($this->getSettings()->bucket, $this->_getGCPath($file), $location);
     return $location;
 }

 public function resize($sourceId, $path, $width, $height)
 {
     try {
         $settings = craft()->imageResizer->getSettings();
         $image = craft()->images->loadImage($path);
         $filename = basename($path);
         // We can have settings globally, or per asset source. Check!
         // Our maximum width/height for assets from plugin settings
         $imageWidth = craft()->imageResizer->getSettingForAssetSource($sourceId, 'imageWidth');
         $imageHeight = craft()->imageResizer->getSettingForAssetSource($sourceId, 'imageHeight');
         // Allow for overrides passed on-demand
         $imageWidth = $width ? $width : $imageWidth;
         $imageHeight = $height ? $height : $imageHeight;
         // Lets check to see if this image needs resizing. Split into two steps to ensure
         // proper aspect ratio is preserved and no upscaling occurs.
         $hasResized = false;
         if ($image->getWidth() > $imageWidth) {
             $hasResized = true;
             $this->_resizeImage($image, $imageWidth, null);
         }
         if ($image->getHeight() > $imageHeight) {
             $hasResized = true;
             $this->_resizeImage($image, null, $imageHeight);
         }
         if ($hasResized) {
             // Set image quality - but normalise (for PNG)!
             $image->setQuality(craft()->imageResizer->getImageQuality($filename));
             // If we're checking for larger images
             if ($settings->skipLarger) {
                 // Save this resized image in a temporary location - we need to test filesize difference
                 $tempPath = AssetsHelper::getTempFilePath($filename);
                 $image->saveAs($tempPath);
                 clearstatcache();
                 // Lets check to see if this resize resulted in a larger file - revert if so.
                 if (filesize($tempPath) < filesize($path)) {
                     $image->saveAs($path);
                     // Its a smaller file - properly save
                 } else {
                     ImageResizerPlugin::log('Did not resize ' . $filename . ' as it would result in a larger file.', LogLevel::Info, true);
                 }
                 // Delete our temp file we test filesize with
                 IOHelper::deleteFile($tempPath, true);
             } else {
                 $image->saveAs($path);
             }
         }
         return true;
     } catch (\Exception $e) {
         ImageResizerPlugin::log($e->getMessage(), LogLevel::Error, true);
         return false;
     }
 }

 /**
  * Upload file and process it for mapping.
  */
 public function actionUpload()
 {
     // Get import post
     $import = craft()->request->getRequiredPost('import');
     // Get file
     $file = \CUploadedFile::getInstanceByName('file');
     // Is file valid?
     if (!is_null($file)) {
         // Is asset source valid?
         if (isset($import['assetsource']) && !empty($import['assetsource'])) {
             // Get source
             $source = craft()->assetSources->getSourceTypeById($import['assetsource']);
             // Get folder to save to
             $folderId = craft()->assets->getRootFolderBySourceId($import['assetsource']);
             // Save file to Craft's temp folder for later use
             $fileName = AssetsHelper::cleanAssetName($file->name);
             $filePath = AssetsHelper::getTempFilePath($file->extensionName);
             $file->saveAs($filePath);
             // Move the file by source type implementation
             $response = $source->insertFileByPath($filePath, $folderId, $fileName, true);
             // Prevent sensitive information leak. Just in case.
             $response->deleteDataItem('filePath');
             // Get file id
             $fileId = $response->getDataItem('fileId');
             // Put vars in model
             $model = new ImportModel();
             $model->filetype = $file->getType();
             // Validate filetype
             if ($model->validate()) {
                 // Get columns
                 $columns = craft()->import->columns($fileId);
                 // Send variables to template and display
                 $this->renderTemplate('import/_map', array('import' => $import, 'file' => $fileId, 'columns' => $columns));
             } else {
                 // Not validated, show error
                 craft()->userSession->setError(Craft::t('This filetype is not valid') . ': ' . $model->filetype);
             }
         } else {
             // No asset source selected
             craft()->userSession->setError(Craft::t('Please select an asset source.'));
         }
     } else {
         // No file uploaded
         craft()->userSession->setError(Craft::t('Please upload a file.'));
     }
 }

 /**
  * Upload a file.
  *
  * @param AssetFolderModel $folder The assetFolderModel where the file should be uploaded to.
  *
  * @throws Exception
  * @return AssetOperationResponseModel
  */
 public function uploadFile(AssetFolderModel $folder)
 {
     // Upload the file and drop it in the temporary folder
     $file = $_FILES['assets-upload'];
     // Make sure a file was uploaded
     if (empty($file['name'])) {
         throw new Exception(Craft::t('No file was uploaded'));
     }
     $size = $file['size'];
     // Make sure the file isn't empty
     if (!$size) {
         throw new Exception(Craft::t('Uploaded file was empty'));
     }
     $fileName = AssetsHelper::cleanAssetName($file['name']);
     // Save the file to a temp location and pass this on to the source type implementation
     $filePath = AssetsHelper::getTempFilePath(IOHelper::getExtension($fileName));
     move_uploaded_file($file['tmp_name'], $filePath);
     $response = $this->insertFileByPath($filePath, $folder, $fileName);
     // Prevent sensitive information leak. Just in case.
     $response->deleteDataItem('filePath');
     return $response;
 }

 /**
  * Create a transform for the file by the transform index.
  *
  * @param AssetFileModel           $file
  * @param AssetTransformIndexModel $index
  *
  * @throws Exception if the AssetTransformIndexModel cannot be determined to have a transform
  * @return null
  */
 private function _createTransformForFile(AssetFileModel $file, AssetTransformIndexModel $index)
 {
     if (!ImageHelper::isImageManipulatable(IOHelper::getExtension($file->filename))) {
         return;
     }
     if (empty($index->transform)) {
         $transform = $this->normalizeTransform(mb_substr($index->location, 1));
         if (empty($transform)) {
             throw new Exception(Craft::t("Unable to recognize the transform for this transform index!"));
         }
     } else {
         $transform = $index->transform;
     }
     if (!isset($index->detectedFormat)) {
         $index->detectedFormat = !empty($index->format) ? $index->format : $this->detectAutoTransformFormat($file);
     }
     $sourceType = craft()->assetSources->populateSourceType($file->getSource());
     $imageSource = $file->getTransformSource();
     $quality = $transform->quality ? $transform->quality : craft()->config->get('defaultImageQuality');
     $image = craft()->images->loadImage($imageSource, $transform->width, $transform->height);
     $image->setQuality($quality);
     switch ($transform->mode) {
         case 'fit':
             $image->scaleToFit($transform->width, $transform->height);
             break;
         case 'stretch':
             $image->resize($transform->width, $transform->height);
             break;
         default:
             $image->scaleAndCrop($transform->width, $transform->height, true, $transform->position);
             break;
     }
     $createdTransform = AssetsHelper::getTempFilePath($index->detectedFormat);
     $image->saveAs($createdTransform);
     clearstatcache(true, $createdTransform);
     $sourceType->putImageTransform($file, $index, $createdTransform);
     IOHelper::deleteFile($createdTransform);
     if (craft()->assetSources->populateSourceType($file->getSource())->isRemote()) {
         $this->queueSourceForDeletingIfNecessary($imageSource);
     }
     return;
 }

 /**
  * @inheritDoc IFieldType::prepValueFromPost()
  *
  * @param mixed $value
  *
  * @return mixed
  */
 public function prepValueFromPost($value)
 {
     $dataFiles = array();
     // Grab data strings
     if (isset($value['data']) && is_array($value['data'])) {
         foreach ($value['data'] as $index => $dataString) {
             if (preg_match('/^data:(?<type>[a-z0-9]+\\/[a-z0-9]+);base64,(?<data>.+)/i', $dataString, $matches)) {
                 $type = $matches['type'];
                 $data = base64_decode($matches['data']);
                 if (!$data) {
                     continue;
                 }
                 if (!empty($value['filenames'][$index])) {
                     $filename = $value['filenames'][$index];
                 } else {
                     $extension = FileHelper::getExtensionByMimeType($type);
                     $filename = 'Uploaded file.' . $extension;
                 }
                 $dataFiles[] = array('filename' => $filename, 'data' => $data);
             }
         }
     }
     // Remove these so they don't interfere.
     if (isset($value['data']) && isset($value['filenames'])) {
         unset($value['data'], $value['filenames']);
     }
     $uploadedFiles = array();
     // See if we have uploaded file(s).
     $contentPostLocation = $this->getContentPostLocation();
     if ($contentPostLocation) {
         $files = UploadedFile::getInstancesByName($contentPostLocation);
         foreach ($files as $file) {
             $uploadedFiles[] = array('filename' => $file->getName(), 'location' => $file->getTempName());
         }
     }
     // See if we have to validate against fileKinds
     $settings = $this->getSettings();
     $allowedExtensions = false;
     if (isset($settings->restrictFiles) && !empty($settings->restrictFiles) && !empty($settings->allowedKinds)) {
         $allowedExtensions = static::_getAllowedExtensions($settings->allowedKinds);
     }
     if (is_array($allowedExtensions)) {
         foreach ($dataFiles as $file) {
             $extension = StringHelper::toLowerCase(IOHelper::getExtension($file['filename']));
             if (!in_array($extension, $allowedExtensions)) {
                 $this->_failedFiles[] = $file['filename'];
             }
         }
         foreach ($uploadedFiles as $file) {
             $extension = StringHelper::toLowerCase(IOHelper::getExtension($file['filename']));
             if (!in_array($extension, $allowedExtensions)) {
                 $this->_failedFiles[] = $file['filename'];
             }
         }
     }
     if (!empty($this->_failedFiles)) {
         return true;
     }
     // If we got here either there are no restrictions or all files are valid so let's turn them into Assets
     // Unless there are no files at all.
     if (empty($value) && empty($dataFiles) && empty($uploadedFiles)) {
         return array();
     }
     if (empty($value)) {
         $value = array();
     }
     $fileIds = array();
     if (!empty($dataFiles) || !empty($uploadedFiles)) {
         $targetFolderId = $this->_determineUploadFolderId($settings);
         foreach ($dataFiles as $file) {
             $tempPath = AssetsHelper::getTempFilePath($file['filename']);
             IOHelper::writeToFile($tempPath, $file['data']);
             $response = craft()->assets->insertFileByLocalPath($tempPath, $file['filename'], $targetFolderId);
             $fileIds[] = $response->getDataItem('fileId');
             IOHelper::deleteFile($tempPath, true);
         }
         foreach ($uploadedFiles as $file) {
             $tempPath = AssetsHelper::getTempFilePath($file['filename']);
             move_uploaded_file($file['location'], $tempPath);
             $response = craft()->assets->insertFileByLocalPath($tempPath, $file['filename'], $targetFolderId);
             $fileIds[] = $response->getDataItem('fileId');
             IOHelper::deleteFile($tempPath, true);
         }
     }
     $fileIds = array_merge($value, $fileIds);
     // Make it look like the actual POST data contained these file IDs as well,
     // so they make it into entry draft/version data
     $this->element->setRawPostContent($this->model->handle, $fileIds);
     return $fileIds;
 }

 /**
  * Upload a file.
  *
  * @param AssetFolderModel $folder
  * @return object
  * @throws Exception
  */
 public function uploadFile($folder)
 {
     // Upload the file and drop it in the temporary folder
     $uploader = new \qqFileUploader();
     // Make sure a file was uploaded
     if (!$uploader->file) {
         throw new Exception(Craft::t('No file was uploaded'));
     }
     $size = $uploader->file->getSize();
     // Make sure the file isn't empty
     if (!$size) {
         throw new Exception(Craft::t('Uploaded file was empty'));
     }
     $fileName = IOHelper::cleanFilename($uploader->file->getName());
     // Save the file to a temp location and pass this on to the source type implementation
     $filePath = AssetsHelper::getTempFilePath(IOHelper::getExtension($fileName));
     $uploader->file->save($filePath);
     // We hate Javascript and PHP in our image files.
     if (IOHelper::getFileKind(IOHelper::getExtension($filePath)) == 'image') {
         craft()->images->cleanImage($filePath);
     }
     $response = $this->_insertFileInFolder($folder, $filePath, $fileName);
     // Naming conflict. create a new file and ask the user what to do with it
     if ($response->isConflict()) {
         $newFileName = $this->_getNameReplacement($folder, $fileName);
         $conflictResponse = $response;
         $response = $this->_insertFileInFolder($folder, $filePath, $newFileName);
     }
     if ($response->isSuccess()) {
         $filename = IOHelper::getFileName($response->getDataItem('filePath'));
         $fileModel = new AssetFileModel();
         $fileModel->sourceId = $this->model->id;
         $fileModel->folderId = $folder->id;
         $fileModel->filename = IOHelper::getFileName($filename);
         $fileModel->kind = IOHelper::getFileKind(IOHelper::getExtension($filename));
         $fileModel->size = filesize($filePath);
         $fileModel->dateModified = IOHelper::getLastTimeModified($filePath);
         if ($fileModel->kind == 'image') {
             list($width, $height) = getimagesize($filePath);
             $fileModel->width = $width;
             $fileModel->height = $height;
         }
         craft()->assets->storeFile($fileModel);
         if (!$this->isSourceLocal() && $fileModel->kind == 'image') {
             // Store copy locally for all sorts of operations.
             IOHelper::copyFile($filePath, craft()->path->getAssetsImageSourcePath() . $fileModel->id . '.' . IOHelper::getExtension($fileModel->filename));
         }
         // Check if we stored a conflict response originally - send that back then.
         if (isset($conflictResponse)) {
             $response = $conflictResponse->setDataItem('additionalInfo', $folder->id . ':' . $fileModel->id)->setDataItem('newFileId', $fileModel->id);
         }
         $response->setDataItem('fileId', $fileModel->id);
     }
     IOHelper::deleteFile($filePath);
     // Prevent sensitive information leak. Just in case.
     $response->deleteDataItem('filePath');
     return $response;
 }

 /**
  * Upload a file.
  *
  * @param array $file
  * @param int   $folderId
  *
  * @return bool|int
  */
 private function _uploadFile($file, $folderId)
 {
     $fileName = AssetsHelper::cleanAssetName($file['name']);
     // Save the file to a temp location and pass this on to the source type implementation
     $filePath = AssetsHelper::getTempFilePath(IOHelper::getExtension($fileName));
     move_uploaded_file($file['tmp_name'], $filePath);
     $response = craft()->assets->insertFileByLocalPath($filePath, $fileName, $folderId);
     // Make sure the file is removed.
     IOHelper::deleteFile($filePath, true);
     // Prevent sensitive information leak. Just in case.
     $response->deleteDataItem('filePath');
     // Return file ID
     return $response->getDataItem('fileId');
 }

 /**
  * @inheritDoc IFieldType::prepValueFromPost()
  *
  * @param mixed $value
  *
  * @return mixed
  */
 public function prepValueFromPost($value)
 {
     // See if we have uploaded file(s).
     $contentPostLocation = $this->getContentPostLocation();
     if ($contentPostLocation) {
         $uploadedFiles = UploadedFile::getInstancesByName($contentPostLocation);
         if (!empty($uploadedFiles)) {
             // See if we have to validate against fileKinds
             $settings = $this->getSettings();
             if (isset($settings->restrictFiles) && !empty($settings->restrictFiles) && !empty($settings->allowedKinds)) {
                 $allowedExtensions = static::_getAllowedExtensions($settings->allowedKinds);
                 $failedFiles = array();
                 foreach ($uploadedFiles as $uploadedFile) {
                     $extension = mb_strtolower(IOHelper::getExtension($uploadedFile->getName()));
                     if (!in_array($extension, $allowedExtensions)) {
                         $failedFiles[] = $uploadedFile;
                     }
                 }
                 // If any files failed the validation, make a note of it.
                 if (!empty($failedFiles)) {
                     $this->_failedFiles = $failedFiles;
                     return true;
                 }
             }
             // If we got here either there are no restrictions or all files are valid so let's turn them into Assets
             $fileIds = array();
             $targetFolderId = $this->_determineUploadFolderId($settings);
             if (!empty($targetFolderId)) {
                 foreach ($uploadedFiles as $file) {
                     $tempPath = AssetsHelper::getTempFilePath($file->getName());
                     move_uploaded_file($file->getTempName(), $tempPath);
                     $response = craft()->assets->insertFileByLocalPath($tempPath, $file->getName(), $targetFolderId);
                     $fileIds[] = $response->getDataItem('fileId');
                     IOHelper::deleteFile($tempPath, true);
                 }
                 if (is_array($value) && is_array($fileIds)) {
                     $fileIds = array_merge($value, $fileIds);
                 }
                 // Make it look like the actual POST data contained these file IDs as well,
                 // so they make it into entry draft/version data
                 $this->element->setRawPostContent($this->model->handle, $fileIds);
                 return $fileIds;
             }
         }
     }
     return parent::prepValueFromPost($value);
 }

 /**
  * @inheritDoc BaseAssetSourceType::getLocalCopy()
  *
  * @param AssetFileModel $file
  *
  * @return mixed
  */
 public function getLocalCopy(AssetFileModel $file)
 {
     $location = AssetsHelper::getTempFilePath($file->getExtension());
     IOHelper::copyFile($this->_getFileSystemPath($file), $location);
     clearstatcache();
     return $location;
 }

 /**
  * @inheritDoc BaseAssetSourceType::getLocalCopy()
  *
  * @param AssetFileModel $file
  *
  * @return mixed
  */
 public function getLocalCopy(AssetFileModel $file)
 {
     $location = AssetsHelper::getTempFilePath($file->getExtension());
     $this->_downloadFile($this->_getRackspacePath($file), $location);
     return $location;
 }

 /**
  * Update the asset transforms for the FileModel.
  *
  * @param AssetFileModel $fileModel
  * @param array|object|string $transformsToUpdate
  * @return bool
  */
 public function updateTransforms(AssetFileModel $fileModel, $transformsToUpdate)
 {
     if (!in_array(IOHelper::getExtension($fileModel->filename), ImageHelper::getAcceptedExtensions())) {
         return true;
     }
     $sourceType = craft()->assetSources->getSourceTypeById($fileModel->sourceId);
     $imageSource = $sourceType->getImageSourcePath($fileModel);
     if (!IOHelper::fileExists($imageSource)) {
         return false;
     }
     if (!is_array($transformsToUpdate)) {
         $transformsToUpdate = array($transformsToUpdate);
     }
     foreach ($transformsToUpdate as $transform) {
         $transform = $this->normalizeTransform($transform);
         $transformLocation = $this->_getTransformLocation($transform);
         $timeModified = $sourceType->getTimeTransformModified($fileModel, $transformLocation);
         // Create the transform if the file doesn't exist, or if it was created before the image was last updated
         // or if the transform dimensions have changed since it was last created
         if (!$timeModified || $timeModified < $fileModel->dateModified || $timeModified < $transform->dimensionChangeTime) {
             $targetFile = AssetsHelper::getTempFilePath(IOHelper::getExtension($fileModel->filename));
             switch ($transform->mode) {
                 case 'fit':
                     craft()->images->loadImage($imageSource)->scaleToFit($transform->width, $transform->height)->saveAs($targetFile);
                     break;
                 case 'stretch':
                     craft()->images->loadImage($imageSource)->resize($transform->width, $transform->height)->saveAs($targetFile);
                     break;
                 default:
                     craft()->images->loadImage($imageSource)->scaleAndCrop($transform->width, $transform->height, true, $transform->position)->saveAs($targetFile);
                     break;
             }
             clearstatcache(true, $targetFile);
             $sourceType->putImageTransform($fileModel, $transformLocation, $targetFile);
             IOHelper::deleteFile($targetFile);
         }
     }
     return true;
 }

 /**
  * Uploads a file directly to a field for an entry.
  *
  * @throws Exception
  * @return null
  */
 public function actionExpressUpload()
 {
     $this->requireAjaxRequest();
     $fieldId = craft()->request->getPost('fieldId');
     $elementId = craft()->request->getPost('elementId');
     if (empty($_FILES['files']) || !isset($_FILES['files']['error'][0]) || $_FILES['files']['error'][0] != 0) {
         throw new Exception(Craft::t('The upload failed.'));
     }
     $field = craft()->fields->populateFieldType(craft()->fields->getFieldById($fieldId));
     if (!$field instanceof AssetsFieldType) {
         throw new Exception(Craft::t('That is not an Assets field.'));
     }
     if ($elementId) {
         $field->element = craft()->elements->getElementById($elementId);
     }
     $targetFolderId = $field->resolveSourcePath();
     try {
         $this->_checkUploadPermissions($targetFolderId);
     } catch (Exception $e) {
         $this->returnErrorJson($e->getMessage());
     }
     $fileName = $_FILES['files']['name'][0];
     $fileLocation = AssetsHelper::getTempFilePath(pathinfo($fileName, PATHINFO_EXTENSION));
     move_uploaded_file($_FILES['files']['tmp_name'][0], $fileLocation);
     $response = craft()->assets->insertFileByLocalPath($fileLocation, $fileName, $targetFolderId, AssetConflictResolution::KeepBoth);
     $fileId = $response->getDataItem('fileId');
     // Render and return
     $element = craft()->elements->getElementById($fileId);
     $html = craft()->templates->render('_elements/element', array('element' => $element));
     $css = craft()->templates->getHeadHtml();
     $this->returnJson(array('html' => $html, 'css' => $css));
 }

 /**
  * Replace a file
  *
  * @throws Exception
  * @return null
  */
 public function actionReplaceFile()
 {
     $this->requireAjaxRequest();
     $fileId = craft()->request->getPost('fileId');
     try {
         if (empty($_FILES['replaceFile']) || !isset($_FILES['replaceFile']['error']) || $_FILES['replaceFile']['error'] != 0) {
             throw new Exception(Craft::t('The upload failed.'));
         }
         $existingFile = craft()->assets->getFileById($fileId);
         if (!$existingFile) {
             throw new Exception(Craft::t('The file to be replaced cannot be found.'));
         }
         $targetFolderId = $existingFile->folderId;
         try {
             $this->_checkUploadPermissions($targetFolderId);
         } catch (Exception $e) {
             $this->returnErrorJson($e->getMessage());
         }
         // Fire an 'onBeforeReplaceFile' event
         $event = new Event($this, array('asset' => $existingFile));
         craft()->assets->onBeforeReplaceFile($event);
         // Is the event preventing this from happening?
         if (!$event->performAction) {
             throw new Exception(Craft::t('The file could not be replaced.'));
         }
         $fileName = AssetsHelper::cleanAssetName($_FILES['replaceFile']['name']);
         $fileLocation = AssetsHelper::getTempFilePath(pathinfo($fileName, PATHINFO_EXTENSION));
         move_uploaded_file($_FILES['replaceFile']['tmp_name'], $fileLocation);
         $response = craft()->assets->insertFileByLocalPath($fileLocation, $fileName, $targetFolderId, AssetConflictResolution::KeepBoth);
         $insertedFileId = $response->getDataItem('fileId');
         $newFile = craft()->assets->getFileById($insertedFileId);
         if ($newFile && $existingFile) {
             $source = craft()->assetSources->populateSourceType($newFile->getSource());
             if (StringHelper::toLowerCase($existingFile->filename) == StringHelper::toLowerCase($fileName)) {
                 $filenameToUse = $existingFile->filename;
             } else {
                 // If the file uploaded had to resolve a conflict, grab the final filename
                 if ($response->getDataItem('filename')) {
                     $filenameToUse = $response->getDataItem('filename');
                 } else {
                     $filenameToUse = $fileName;
                 }
             }
             $source->replaceFile($existingFile, $newFile, $filenameToUse);
             IOHelper::deleteFile($fileLocation, true);
         } else {
             throw new Exception(Craft::t('Something went wrong with the replace operation.'));
         }
     } catch (Exception $exception) {
         $this->returnErrorJson($exception->getMessage());
     }
     // Fire an 'onReplaceFile' event
     craft()->assets->onReplaceFile(new Event($this, array('asset' => $existingFile)));
     $this->returnJson(array('success' => true, 'fileId' => $fileId));
 }

//.........这里部分代码省略.........
             } else {
                 $spamHoneypotMethod = false;
                 $submissionErrorMessage[] = Craft::t('You tried the honey, you are robot bear!');
             }
         } else {
             $spamHoneypotMethod = true;
         }
     } else {
         $spamHoneypotMethod = true;
     }
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // NEW FORM MODEL
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     $submissionEntry = new FormBuilder2_EntryModel();
     $submissionEntry->formId = $form->id;
     $submissionEntry->title = $form->name;
     $submissionEntry->submission = $submissionData;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // FAILED SUBMISSION REDIRECT W/MESSAGES (Spam Protection)
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     if ($submissionErrorMessage) {
         craft()->userSession->setFlash('error', $customErrorMessage);
         craft()->urlManager->setRouteVariables(array('errors' => $submissionErrorMessage));
     }
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // VALIDATE SUBMISSION DATA
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     $validation = craft()->formBuilder2_entry->validateEntry($form, $submissionData, $files);
     // if ($validation != '') {
     if (!empty($validation)) {
         if ($ajax) {
             $this->returnJson(['passedValidation' => false, 'validationErrors' => $validation, 'customErrorMessage' => $customErrorMessage]);
         } else {
             craft()->userSession->setFlash('error', $customErrorMessage);
             $passedValidation = false;
             return craft()->urlManager->setRouteVariables(['value' => $submissionData, 'errors' => $validation]);
         }
     }
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // PROCESS SUBMISSION ENTRY
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     if (!$submissionErrorMessage && $passedValidation && $spamTimedMethod && $spamHoneypotMethod) {
         // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         // FILE UPLOADS
         // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         $fileIds = [];
         $fileCollection = [];
         $tempPath = [];
         if ($files) {
             foreach ($files as $key => $file) {
                 $tempPath = AssetsHelper::getTempFilePath($file['filename']);
                 move_uploaded_file($file['location'], $tempPath);
                 $response = craft()->assets->insertFileByLocalPath($tempPath, $file['filename'], $file['folderId'], AssetConflictResolution::KeepBoth);
                 $fileIds[] = $response->getDataItem('fileId');
                 $fileCollection[] = ['tempPath' => $tempPath, 'filename' => $file['filename'], 'type' => $file['type']];
             }
             $submissionEntry->files = $fileIds;
         }
         $submissionResponseId = craft()->formBuilder2_entry->processSubmissionEntry($submissionEntry);
         if ($submissionResponseId) {
             // Notify Admin of Submission
             if (isset($notificationSettings['notifySubmission'])) {
                 if ($notificationSettings['notifySubmission'] == '1') {
                     $this->notifyAdminOfSubmission($submissionResponseId, $fileCollection, $form);
                 }
             }
             // Notify Submitter of Submission
             if (isset($notificationSettings['notifySubmitter'])) {
                 if ($notificationSettings['notifySubmitter'] == '1') {
                     $this->notifySubmitterOfSubmission($submissionResponseId, $form);
                 }
             }
             foreach ($fileCollection as $file) {
                 IOHelper::deleteFile($file['tempPath'], true);
             }
             // Successful Submission Messages
             if ($ajax) {
                 $this->returnJson(['success' => true, 'customSuccessMessage' => $customSuccessMessage]);
             } else {
                 craft()->userSession->setFlash('success', $customSuccessMessage);
                 $cookie = new HttpCookie('formBuilder2SubmissionId', $submissionEntry->attributes['id']);
                 craft()->request->getCookies()->add($cookie->name, $cookie);
                 $this->redirectToPostedUrl();
             }
         } else {
             // Submission Error Messages
             if ($ajax) {
                 $this->returnJson(['error' => true, 'customErrorMessage' => $customErrorMessage]);
             } else {
                 craft()->userSession->setFlash('error', $customErrorMessage);
                 return craft()->urlManager->setRouteVariables(['value' => $submissionData, 'errors' => $validation]);
             }
         }
     }
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 }