InputfieldFileS3.module

<?php namespace ProcessWire;
use Aws\S3\S3Client;
/**
 * An Inputfield for handling file uploads to AWS S3
 *
 */
class InputfieldFileS3 extends InputfieldFile implements Module  {

	public static function getModuleInfo() {
		return array(
			'title' => __('InputfieldFileS3', __FILE__), // Module Title
			'summary' => __('One or more file uploads (sortable)', __FILE__), // Module Summary
			'version' => 005,
			'autoload' => true,
			);
	}

	public function init() {
		parent::init();
		$this->addHook('Pagefile::s3url', $this, 's3url');
        if($this->cf){
            $this->addHookProperty('Pagefile::cfurl', $this, 'cloudFrontUrl');
        }
		$this->addHookProperty("Pagefile::s3url", $this, "s3url");
	}

	/**
	 * Render markup for a file item
	 *
	 * @param Pagefile $pagefile
	 * @param string $id
	 * @param int $n
	 * @return string
	 *
	 */
	protected function ___renderItem($pagefile, $id, $n) {

		$displayName = $this->getDisplayBasename($pagefile);
		$deleteLabel = $this->labels['delete'];
		$url = ($this->localStorage) ? $pagefile->url : $pagefile->s3url();
		$out =
			"<p class='InputfieldFileInfo InputfieldItemHeader ui-state-default ui-widget-header'>" .
			wireIconMarkupFile($pagefile->basename, "fa-fw HideIfEmpty") .
			"<a class='InputfieldFileName' title='$pagefile->basename' target='_blank' href='{$url}'>$displayName</a> " .
			"<span class='InputfieldFileStats'>" . str_replace(' ', '&nbsp;', wireBytesStr($pagefile->fSize)) . "</span> ";

		if(!$this->renderValueMode) $out .=
			"<label class='InputfieldFileDelete'>" .
				"<input type='checkbox' name='delete_$id' value='1' title='$deleteLabel' />" .
				"<i class='fa fa-fw fa-trash'></i></label>";

		$out .=
			"</p>" .
			"<div class='InputfieldFileData description ui-widget-content'>" .
			$this->renderItemDescriptionField($pagefile, $id, $n);

		if(!$this->renderValueMode) $out .=
			"<input class='InputfieldFileSort' type='text' name='sort_$id' value='$n' />";

		$out .=
			"</div>";

		return $out;
	}

	protected function ___fileAdded(Pagefile $pagefile) {
		if($this->noUpload) return;

		$isValid = $this->wire('sanitizer')->validateFile($pagefile->filename(), array(
			'pagefile' => $pagefile
		));

		if($isValid === false) {
			$errors = $this->wire('sanitizer')->errors('clear array');
			throw new WireException(
				$this->_('File failed validation') .
				(count($errors) ? ": " . implode(', ', $errors) : "")
			);
		} else if($isValid === null) {
			// there was no validator available for this file type
		}

		$message = $this->_('Added file:') . " {$pagefile->basename}"; // Label that precedes an added filename

		if($this->isAjax && !$this->noAjax) {
			if(!$this->localStorage) {
				$this->uploadFileToS3($pagefile, $this->input->get->id);
			}
			$pagefile->fSize = @filesize($pagefile->filename);
			$n = count($this->value);
			if($n) $n--; // for sorting
			$this->currentItem = $pagefile;
			$markup = $this->fileAddedGetMarkup($pagefile, $n);
			$this->ajaxResponse(false, $message, $pagefile->url, $pagefile->fSize, $markup);
		} else {
			$this->message($message);
		}
	}

	/**
	 * @param string $filename
	 * @throws WireException
	 *
	 */
	protected function ___processInputAddFile($filename) {

		$total = count($this->value);
		$metadata = array();
		$rm = null;

		if($this->maxFiles > 1 && $total >= $this->maxFiles) return;

		// allow replacement of file if maxFiles is 1
		if($this->maxFiles == 1 && $total) {
			$pagefile = $this->value->first();
			$metadata = $this->extractMetadata($pagefile, $metadata);
			$rm = true;
			if($filename == $pagefile->basename) {
				// use overwrite mode rather than replace mode when single file and same filename
				if($this->overwrite) $rm = false;
			}
			if($rm) {
				if($this->overwrite) $this->processInputDeleteFile($pagefile);
				$this->singleFileReplacement = true;
			}
		}

		if($this->overwrite) {
			$pagefile = $this->value->get($filename);
			clearstatcache();
			if($pagefile) {
				// already have a file of the same name
				if($pagefile instanceof Pageimage) $pagefile->removeVariations();
				$metadata = $this->extractMetadata($pagefile, $metadata);
			} else {
				// we don't have a file with the same name as the one that was uploaded
				// file must be in another files field on the same page, that could be problematic
				$ul = $this->getWireUpload();
				// see if any files were overwritten that weren't part of our field
				// if so, we need to restore them and issue an error
				$err = false;
				foreach($ul->getOverwrittenFiles() as $bakFile => $newFile) {
					if(basename($newFile) != $filename) continue;
					unlink($newFile);
					rename($bakFile, $newFile); // restore
					$ul->error(sprintf($this->_('Refused file %s because it is already on the file system and owned by a different field.'), $filename));
					$err = true;
				}
				if($err) return;
			}
		}

		$this->value->add($filename);
		/** @var Pagefile $item */
		$item = $this->value->last();

		try {
			foreach($metadata as $key => $val) {
				if($val) $item->$key = $val;
			}
			// items saved in ajax or uploadOnly mode are temporary till saved in non-ajax/non-uploadOnly
			if($this->isAjax && !$this->overwrite && $this->localStorage) $item->isTemp(true);
			$this->fileAdded($item);
		} catch(\Exception $e) {
			$item->unlink();
			$this->value->remove($item);
			throw new WireException($e->getMessage());
		}
	}

	protected function ___processInputDeleteFile(Pagefile $pagefile) {
		$this->message($this->_("Deleted file:") . " $pagefile"); // Label that precedes a deleted filename
		$this->value->delete($pagefile);
		$this->trackChange('value');
		if(!$this->localStorage) {
			$this->deleteFileFromS3($pagefile, $this->input->get->id);
		}
	}

	public function ___processInput(WireInputData $input) {
		if(is_null($this->value)) $this->value = $this->wire(new Pagefiles($this->wire('page')));
		if(!$this->destinationPath) $this->destinationPath = $this->value->path();
		if(!$this->destinationPath || !is_dir($this->destinationPath)) return $this->error($this->_("destinationPath is empty or does not exist"));
		if(!is_writable($this->destinationPath)) return $this->error($this->_("destinationPath is not writable"));

		$changed = false;
		$total = count($this->value);

		if(!$this->noUpload) {

			if($this->maxFiles <= 1 || $total < $this->maxFiles) {
				$ul = $this->getWireUpload();
				$ul->setName($this->attr('name'));
				$ul->setDestinationPath($this->destinationPath);
				$ul->setOverwrite($this->overwrite);
				$ul->setAllowAjax($this->noAjax ? false : true);
				if($this->maxFilesize) $ul->setMaxFileSize($this->maxFilesize);

				if($this->maxFiles == 1) {
					$ul->setMaxFiles(1);

				} else if($this->maxFiles) {
					$maxFiles = $this->maxFiles - $total;
					$ul->setMaxFiles($maxFiles);

				} else if($this->unzip) {
					$ul->setExtractArchives(true);
				}

				$ul->setValidExtensions(explode(' ', trim($this->extensions)));

				foreach($ul->execute() as $filename) {
					$this->processInputAddFile($filename);
					$changed = true;
				}

				if($this->isAjax && !$this->noAjax) foreach($ul->getErrors() as $error) {
					$this->ajaxResponse(true, $error);
				}

			} else if($this->maxFiles) {
				// over the limit
				$this->ajaxResponse(true, $this->_("Max file upload limit reached"));
			}
		}

		$n = 0;

		foreach($this->value as $pagefile) {
			if($this->processInputFile($input, $pagefile, $n)) $changed = true;
			if(!$this->localStorage && !$this->isAjax){
				@unlink($pagefile->filename);
			}
			$n++;
		}
		if($changed) {
			$this->value->sort('sort');
			$this->trackChange('value');
		}
		if(count($this->ajaxResponses) && $this->isAjax) {
			echo json_encode($this->ajaxResponses);
		}

		return $this;
	}

	// File url
	protected function s3url($event) {
		if($this->localStorage) {
			$event->return = $event->object->url;
		}
		else {
			$ssl = ($this->useSSL) ? 'https' : 'http';
			$domain = $this->domain();
			$event->return = "{$ssl}://{$domain}/" . $event->object->page . "/" . $event->object->name;
		}
	}

     protected function cloudFrontUrl($event) {
		if($this->localStorage) {
			$event->return = $event->object->url;
		}
		else {
            $ssl = ($this->useSSL) ? 'https' : 'http';
            $domain = $this->domain();
            $event->return = "{$ssl}://". $this->cfurl  ."/" . $event->object->page . "/" . $event->object->name;
        }
     }

	protected function domain() {
		switch ($this->region) {
			case 'us-east-1':
				$endpoint = 's3.amazonaws.com';
				break;

			case 'us-east-2':
				$endpoint = 's3.us-east-2.amazonaws.com';
				break;

			case 'us-west-1':
				$endpoint = 's3-us-west-1.amazonaws.com';
				break;

			case 'us-west-2':
				$endpoint = 's3-us-west-2.amazonaws.com';
				break;

			case 'ca-central-1':
				$endpoint = 's3-ca-central-1.amazonaws.com';
				break;

			case 'eu-west-1':
				$endpoint = 's3-eu-west-1.amazonaws.com';
				break;

			case 'eu-west-2':
				$endpoint = 's3-eu-west-2.amazonaws.com';
				break;

			case 'eu-central-1':
				$endpoint = 's3-eu-central-1.amazonaws.com';
				break;

			case 'ap-south-1':
				$endpoint = 's3-ap-south-1.amazonaws.com';
				break;

			case 'ap-southeast-1':
				$endpoint = 's3-ap-southeast-1.amazonaws.com';
				break;

			case 'ap-southeast-2':
				$endpoint = 's3-ap-southeast-2.amazonaws.com';
				break;

			case 'ap-northeast-1':
				$endpoint = 's3-ap-northeast-1.amazonaws.com';
				break;

			case 'ap-northeast-2':
				$endpoint = 's3-ap-northeast-2.amazonaws.com';
				break;

			case 'sa-east-1':
				$endpoint = 's3-sa-east-1.amazonaws.com';
				break;

			default:
				$endpoint = 's3.amazonaws.com';
				break;
		}

		return ($this->useMyDomain) ? $this->bucket : "{$endpoint}/{$this->bucket}";
	}

	protected function uploadFileToS3($pagefile, $pageID) {
		$this->setS3Client();
        $s3args = [
			"ACL"         => $this->ACL,
			"Bucket"      => $this->bucket,
			"Key"         => "{$pageID}/{$pagefile->name}",
			"SourceFile"  => $pagefile->filename,
			"ContentType" => mime_content_type($pagefile->filename)
		];

        if($this->cacheHeader){
            $s3args['CacheControl'] = 'max-age=' . $this->cacheHeader;
        }
        
		$this->s3->PutObject($s3args);
	}

	protected function deleteFileFromS3($pagefile, $pageID) {
		$this->setS3Client();
		$this->s3->deleteObject([
			"Bucket"      => $this->bucket,
			"Key"         => "{$pageID}/{$pagefile->name}",
		]);
	}

	// Instantiate S3 client
	protected function setS3Client() {
		//require_once("aws-sdk/aws-autoloader.php");
		$this->s3 = new S3Client([
			"version"     => "latest",
			"region"      => $this->region,
			"credentials" => [
				"key"    => $this->key,
				"secret" => $this->secret
			]]);
	}

}