File classes\AsynFileUploader.php | PHPLucidFrame 3.4 API

1:	<?php
2:	/**
3:	* This file is part of the PHPLucidFrame library.
4:	* Helper for ajax-like file upload with instant preview if the preview placeholder is provided
5:	*
6:	* @package PHPLucidFrame\File
7:	* @since PHPLucidFrame v 1.3.0
8:	* @copyright Copyright (c), PHPLucidFrame.
9:	* @link http://phplucidframe.com
10:	* @license http://www.opensource.org/licenses/mit-license.php MIT License
11:	*
12:	* This source file is subject to the MIT license that is bundled
13:	* with this source code in the file LICENSE
14:	*/
15:
16:	namespace LucidFrame\Core;
17:
18:	/**
19:	* Helper for ajax-like file upload with instant preview if the preview placeholder is provided
20:	*/
21:	class AsynFileUploader
22:	{
23:	/** @var string The input name or the POST name */
24:	private $name;
25:	/** @var string The HTML id of the file browsing button */
26:	private $id;
27:	/** @var string The input label name that shown to the user */
28:	private $label;
29:	/** @var string The button caption */
30:	private $caption;
31:	/** @var string The uploaded file name */
32:	private $value;
33:	/** @var array The array of hidden values to be posted to the callbacks */
34:	private $hidden;
35:	/** @var string The directory path where the file to be uploaded permanently */
36:	private $uploadDir;
37:	/** @var array The allowed file extensions; defaults to jpg, jpeg, png, gif */
38:	private $extensions;
39:	/** @var int The maximum file size allowed to upload in MB */
40:	private $maxSize;
41:	/** @var array Image dimensions */
42:	private $dimensions;
43:	/** @var string URL that handles the file uploading process */
44:	private $uploadHandler;
45:	/** @var array Array of HTML ID of the buttons to be disabled while uploading */
46:	private $buttons;
47:	/** @var boolean Enable ajax file delete or not */
48:	private $isDeletable;
49:	/** @var boolean The uploaded file name is displayed or not */
50:	private $fileNameIsDisplayed;
51:	/** @var bool Flag to save the uploaded file with original file name */
52:	private $uploadAsOriginalFileName = false;
53:	/** @var string The hook name that handles file upload process interacting the database layer */
54:	private $onUpload;
55:	/** @var string The hook name that handles file deletion process interacting the database layer */
56:	private $onDelete;
57:
58:	/**
59:	* Constructor
60:	*
61:	* @param string/array anonymous The input file name or The array of property/value pairs
62:	*/
63:	public function __construct()
64:	{
65:	$this->name = 'file';
66:	$this->id = '';
67:	$this->label = _t('File');
68:	$this->caption = _t('Choose File');
69:	$this->value = array();
70:	$this->hidden = array();
71:	$this->maxSize = 10;
72:	$this->extensions = array();
73:	$this->uploadDir = FILE . 'tmp' . _DS_;
74:	$this->buttons = array();
75:	$this->dimensions = '';
76:	$this->uploadHandler = WEB_ROOT . 'lib/asyn-file-uploader.php';
77:	$this->isDeletable = true;
78:	$this->fileNameIsDisplayed = true;
79:	$this->onUpload = '';
80:	$this->onDelete = '';
81:
82:	if (func_num_args()) {
83:	$arg = func_get_arg(0);
84:	if (is_string($arg)) {
85:	$this->name = $arg;
86:	} elseif (is_array($arg)) {
87:	foreach ($arg as $key => $value) {
88:	if (isset($this->{$key})) {
89:	$this->{$key} = $value;
90:	}
91:	}
92:	}
93:	}
94:	}
95:	/**
96:	* Setter for the property `name`
97:	* @param string $name The unique name for the file input element
98:	*/
99:	public function setName($name)
100:	{
101:	$this->name = $name;
102:	}
103:	/**
104:	* Setter for the property `id`
105:	* @param string $id The unique HTML id for the file browsing button
106:	*/
107:	public function setId($id)
108:	{
109:	$this->id = $id;
110:	}
111:	/**
112:	* Setter for the property `label`
113:	* @param string $label The caption name for the file input to use in validation error
114:	*/
115:	public function setLabel($label)
116:	{
117:	$this->label = $label;
118:	}
119:	/**
120:	* Setter for the property `caption`
121:	* @param string $caption The caption for image uploaded
122:	*/
123:	public function setCaption($caption)
124:	{
125:	$this->caption = $caption;
126:	}
127:	/**
128:	* Setter for the property `value`
129:	* @param array $value The file name saved in the database
130:	* @param int $id The ID related to the file name saved in the database
131:	* @return void
132:	*/
133:	public function setValue($value, $id = 0)
134:	{
135:	$this->value = array(
136:	$id => $value
137:	);
138:	}
139:	/**
140:	* Getter for the property `value`
141:	*/
142:	public function getValue()
143:	{
144:	return is_array($this->value) ? current($this->value) : $this->value;
145:	}
146:	/**
147:	* Getter for the id saved in db related to the value
148:	*/
149:	public function getValueId()
150:	{
151:	if (is_array($this->value)) {
152:	return current(array_keys($this->value));
153:	}
154:	return 0;
155:	}
156:	/**
157:	* Setter for the property `hidden`
158:	* @param string $key The key - id, dimensions, fileName or uniqueId
159:	* @param mixed $value The value for the key
160:	* @return void
161:	*/
162:	public function setHidden($key, $value = '')
163:	{
164:	if (!in_array($key, array('id', 'dimensions', 'fileName', 'uniqueId'))) {
165:	# skip for reserved keys
166:	$this->hidden[$key] = $value;
167:	}
168:	}
169:	/**
170:	* Setter for the property `uploadDir`
171:	* @param string $dir The directory where the file will be uploaded. Default to /files/tmp/
172:	*/
173:	public function setUploadDir($dir)
174:	{
175:	$this->uploadDir = $dir;
176:	}
177:	/**
178:	* Setter for the property `maxSize`
179:	* @param int $size The maximum file size allowed in MB
180:	*/
181:	public function setMaxSize($size)
182:	{
183:	$this->maxSize = $size;
184:	}
185:	/**
186:	* Setter for the property `extensions`
187:	* @param array $extensions The array of extensions such as `array('jpg', 'png', 'gif')`
188:	*/
189:	public function setExtensions($extensions)
190:	{
191:	$this->extensions = $extensions;
192:	}
193:	/**
194:	* Setter for the property `dimensions`
195:	* @param array $dimensions The array of extensions such as `array('600x400', '300x200')`
196:	*/
197:	public function setDimensions($dimensions)
198:	{
199:	$this->dimensions = $dimensions;
200:	}
201:	/**
202:	* Setter for the property `buttons`
203:	* @param string $arg1[,$arg2,$arg3,...] The HTML element ID for each button
204:	*/
205:	public function setButtons()
206:	{
207:	$this->buttons = func_get_args();
208:	}
209:	/**
210:	* Setter for the property `isDeletable`
211:	* @param boolean $value If the delete button is provided or not
212:	*/
213:	public function isDeletable($value)
214:	{
215:	$this->isDeletable = $value;
216:	}
217:	/**
218:	* Setter for the property `fileNameIsDisplayed`
219:	* @param boolean $value If the uploaded file name is displayed next to the button or not
220:	*/
221:	public function isFileNameDisplayed($value)
222:	{
223:	$this->fileNameIsDisplayed = $value;
224:	}
225:
226:	/**
227:	* Setter for the property `uploadAsOriginalFileName`
228:	* @param boolean $value Use original file name on upload or not
229:	*/
230:	public function setUploadAsOriginalFileName($value)
231:	{
232:	$this->uploadAsOriginalFileName = $value;
233:	}
234:	/**
235:	* Setter for the `onUpload` hook
236:	* @param string $callable The callback PHP function name
237:	*/
238:	public function setOnUpload($callable)
239:	{
240:	$this->onUpload = $callable;
241:	}
242:	/**
243:	* Setter for the `onDelete` hook
244:	* @param string $callable The callback PHP function name
245:	*/
246:	public function setOnDelete($callable)
247:	{
248:	$this->onDelete = $callable;
249:	}
250:	/**
251:	* Setter for the property `uploadHandler`
252:	* @param string $url The URL where file upload will be handled
253:	*/
254:	public function setUploadHandler($url)
255:	{
256:	$this->uploadHandler = $url;
257:	}
258:	/**
259:	* Display file input HTML
260:	* @param array $attributes The HTML attribute option for the button
261:	*
262:	* array(
263:	* 'class' => '',
264:	* 'id' => '',
265:	* 'title' => ''
266:	* )
267:	*
268:	*/
269:	public function html($attributes = array())
270:	{
271:	$name = $this->name;
272:	$maxSize = $this->maxSize * 1024 * 1024; # convert to bytes
273:
274:	# HTML attribute preparation for the file browser button
275:	$attrHTML = array();
276:	$htmlIdForButton = false;
277:	$htmlClassForButton = false;
278:	foreach ($attributes as $attrName => $attrVal) {
279:	$attrName = strtolower($attrName);
280:	if ($attrName === 'class' && $attrVal) {
281:	$htmlClassForButton = true;
282:	$attrVal = 'asynfileuploader-button '.$attrVal;
283:	}
284:	if ($attrName === 'id' && $attrVal) {
285:	$this->id = $attrVal;
286:	$htmlIdForButton = true;
287:	}
288:	$attrHTML[] = $attrName.'="'.$attrVal.'"';
289:	}
290:	if ($htmlIdForButton === false) {
291:	$this->id = 'asynfileuploader-button-'.$name;
292:	$attrHTML[] = 'id="'.$this->id.'"';
293:	}
294:	if ($htmlClassForButton === false) {
295:	$attrHTML[] = 'class="asynfileuploader-button button"';
296:	}
297:	$buttonAttrHTML = implode(' ', $attrHTML);
298:
299:	$args = array();
300:	$args[] = 'name=' . $name;
301:	$args[] = 'id=' . $this->id;
302:	$args[] = 'label=' . $this->label;
303:	$args[] = 'dir=' . base64_encode($this->uploadDir);
304:	$args[] = 'buttons=' . implode(',', $this->buttons);
305:	$args[] = 'onUploadHook=' . $this->onUpload;
306:	$args[] = 'exts=' . implode(',', $this->extensions);
307:	$args[] = 'maxSize=' . $maxSize;
308:	$args[] = 'uploadAsOriginalFileName=' . (int) $this->uploadAsOriginalFileName;
309:	if ($this->dimensions) {
310:	$args[] = 'dimensions=' . implode(',', $this->dimensions);
311:	}
312:	$args[] = 'lc_namespace=' . LC_NAMESPACE;
313:	$handlerURL = $this->uploadHandler.'?'.implode('&', $args);
314:
315:	# If setValue(), the file information is pre-loaded
316:	$id = '';
317:	$value = '';
318:	$currentFile = '';
319:	$currentFileURL = '';
320:	$extension = '';
321:	$uniqueId = '';
322:	$dimensions = array();
323:	$webUploadDir = str_replace('\\', '/', str_replace(ROOT, WEB_ROOT, $this->uploadDir));
324:
325:	if ($this->value && file_exists($this->uploadDir . $value)) {
326:	$value = $this->getValue();
327:	$id = $this->getValueId();
328:	$currentFile = basename($this->uploadDir . $value);
329:	$currentFileURL = $webUploadDir . $value;
330:	$extension = pathinfo($this->uploadDir . $value, PATHINFO_EXTENSION);
331:	if (is_array($this->dimensions) && count($this->dimensions)) {
332:	$dimensions = $this->dimensions;
333:	}
334:	}
335:
336:	# If the generic form POST, the file information from POST is pre-loaded
337:	# by overwriting `$this->value`
338:	if (count($_POST) && isset($_POST[$name]) && $_POST[$name] &&
339:	isset($_POST[$name.'-fileName']) && $_POST[$name.'-fileName']) {
340:	$post = _post();
341:	$value = $post[$name];
342:	$id = isset($post[$name.'-id']) ? $post[$name.'-id'] : '';
343:
344:	if (file_exists($this->uploadDir . $value)) {
345:	$currentFile = $value;
346:	$currentFileURL = $webUploadDir . $value;
347:	$extension = pathinfo($this->uploadDir . $value, PATHINFO_EXTENSION);
348:	$uniqueId = $post[$name.'-uniqueId'];
349:	}
350:
351:	if (isset($post[$name.'-dimensions']) && is_array($post[$name.'-dimensions']) && count($post[$name.'-dimensions'])) {
352:	$dimensions = $post[$name.'-dimensions'];
353:	}
354:	}
355:
356:	$preview = $currentFile ? true : false;
357:	?>
358:	<div class="asynfileuploader" id="asynfileuploader-<?php echo $name; ?>">
359:	<div id="asynfileuploader-value-<?php echo $name; ?>">
360:	<input type="hidden" name="<?php echo $name; ?>" value="<?php if ($value) echo $value; ?>" />
361:	<input type="hidden" name="<?php echo $name; ?>-id" value="<?php if ($id) echo $id; ?>" />
362:	<?php foreach ($dimensions as $d) { ?>
363:	<input type="hidden" name="<?php echo $name; ?>-dimensions[]" value="<?php echo $d; ?>" />
364:	<?php } ?>
365:	</div>
366:	<div id="asynfileuploader-hiddens-<?php echo $name; ?>">
367:	<?php foreach ($this->hidden as $hiddenName => $hiddenValue) { ?>
368:	<input type="hidden" name="<?php echo $name; ?>-<?php echo $hiddenName; ?>" value="<?php echo $hiddenValue; ?>" />
369:	<?php } ?>
370:	</div>
371:	<input type="hidden" name="<?php echo $name; ?>-dir" value="<?php echo base64_encode($this->uploadDir); ?>" />
372:	<input type="hidden" name="<?php echo $name; ?>-fileName" id="asynfileuploader-fileName-<?php echo $name; ?>" value="<?php echo $currentFile; ?>" />
373:	<input type="hidden" name="<?php echo $name; ?>-uniqueId" id="asynfileuploader-uniqueId-<?php echo $name; ?>" value="<?php echo $uniqueId; ?>" />
374:	<div id="asynfileuploader-progress-<?php echo $name; ?>" class="asynfileuploader-progress">
375:	<div></div>
376:	</div>
377:	<div <?php echo $buttonAttrHTML; ?>>
378:	<span><?php echo $this->caption; ?></span>
379:	<iframe id="asynfileuploader-frame-<?php echo $name; ?>" src="<?php echo $handlerURL; ?>" frameborder="0" scrolling="no" style="overflow:hidden;"></iframe>
380:	</div>
381:	<div class="asynfileuploader-file-info">
382:	<?php if ($this->fileNameIsDisplayed) { ?>
383:	<span id="asynfileuploader-name-<?php echo $name; ?>">
384:	<?php if ($currentFile) { ?>
385:	<a href="<?php echo $currentFileURL; ?>" target="_blank" rel="nofollow"><?php echo $currentFile ?></a>
386:	<?php } ?>
387:	</span>
388:	<?php } ?>
389:	<span id="asynfileuploader-delete-<?php echo $name; ?>" class="asynfileuploader-delete" <?php if (!$currentFile) echo 'style="display:none"'; ?>>
390:	<?php if ($this->isDeletable) { ?>
391:	<a href="javascript:" rel="<?php echo $this->onDelete; ?>" title="Delete">
392:	<span>Delete</span>
393:	</a>
394:	<?php } ?>
395:	</span>
396:	</div>
397:	<span class="asynfileuploader-error" id="asynfileuploader-error-<?php echo $name; ?>"></span>
398:	<script type="text/javascript">
399:	LC.AsynFileUploader.init('<?php echo $name; ?>');
400:	<?php
401:	if ($preview) {
402:	$json = array(
403:	'name' => $name,
404:	'value' => $value,
405:	'fileName' => $currentFile,
406:	'url' => $currentFileURL,
407:	'extension' => $extension,
408:	'caption' => $this->label
409:	);
410:	echo 'LC.AsynFileUploader.preview(' . json_encode($json) . ');';
411:	}
412:	?>
413:	</script>
414:	</div>
415:	<?php
416:	}
417:	/**
418:	* Get the upload directory name from REQUEST
419:	* @param string $name The file element name
420:	* @return mixed
421:	*/
422:	public static function getDirFromRequest($name)
423:	{
424:	return isset($_REQUEST[$name.'-dir']) ? _sanitize(base64_decode($_REQUEST[$name.'-dir'])) : '';
425:	}
426:	}
427:

Namespaces

Classes