merge sanjiangyuan-sub r5137 - r5191 into sjy-emc

This commit is contained in:
wlx 2015-01-30 15:16:20 +00:00
parent 836caaf556
commit e8b8e1fdb4
83 changed files with 8797 additions and 11 deletions

View File

@ -2838,6 +2838,168 @@ class Admin_DataController extends Zend_Controller_Action
}
}//end if
}
/**
* 数据导入
*/
public function dataimportAction()
{
$this->view->ac = $ac = $this->_getParam('ac');
//文件上传
if($ac == "upload") {
$upload = new Westdc\Dataimport\File;
$file = $upload->upload($_FILES['FileData']);
$this->_helper->json($file);
return true;
}
//文件列表
if($ac == "files"){
$file = new Westdc\Dataimport\File;
$this->_helper->json($file->getUploadFiles());
return true;
}
//刪除上传的文件
if($ac == "delete"){
$file = $this->_getParam('file');
$fileHandle = new Westdc\Dataimport\File;
$this->_helper->json(['success'=>$fileHandle->deleteFile($file)]);
return true;
}
//预处理
//判断文件类型,初步识别文件內容
if($ac == "prepare"){
$this->_helper->viewRenderer('dataimport-preprocess');
$file = $this->_getParam('file');
if(empty($file))
{
view::Post($this,"参数错误",-1);
return true;
}
$fileHandle = new Westdc\Dataimport\File;
$realfile = $fileHandle->getRealName($file);
if(!file_exists($realfile))
$this->view->error = "要导入的文件已不存在,请返回上一步重新上传";
if(isset($this->view->error))
return;
$this->view->file = $file;
$fileExt = $fileHandle->getFileTextExt($realfile);
$processing = Westdc\Dataimport\ProcessFactory::Bootstrap($fileExt);
/** @var \Westdc\Dataimport\Processing\Csv $processing */
$processing->init($realfile);
//文件行數
$this->view->Count = $processing->getLineCount();
//文件大小
$this->view->Size = $processing->getSize();
//文件類型>view->error
$this->view->Type = $processing->getType();
return true;
}
//檢查文件是否規則
if($ac == "check"){
$file = $this->_getParam('file');
if(empty($file)){
$this->_helper->json(['error'=>'参数错误']);
return true;
}
$fileHandle = new Westdc\Dataimport\File;
$realFile = $fileHandle->getRealName($file);
$processing = Westdc\Dataimport\ProcessFactory::Bootstrap($fileHandle->getFileTextExt($file));
/** @var \Westdc\Dataimport\Processing\Csv $processing */
$processing->init($realFile);
$status = $processing->checkRegularity();
$this->_helper->json(['status'=>$status]);
return true;
}
//選擇導入目標
if($ac == "target")
{
$this->_helper->viewRenderer('dataimport-target');
$this->view->file = $file = $this->_getParam('file');
if(empty($file)){
view::Post($this,"参数错误",-1);
return true;
}
$tableControl = new Westdc\Visual\DataTableControl;
$this->view->schema = $this->view->config->sub->schema;//$tableControl->readSchema();
}
//获得数据表
if($ac == "gettables")
{
$schema = $this->_getParam('schema');
if(empty($schema)){
$this->_helper->json(['error'=>'参数错误']);
return true;
}
$tableControl = new Westdc\Visual\DataTableControl;
$this->_helper->json($tableControl->readTables($schema));
return true;
}
//检查能否写入数据表 和 导入数据
if($ac == "checktables" || $ac == "import"){
$this->_helper->layout->disableLayout();
$this->_helper->viewRenderer->setNoRender();
$table = $this->_getParam('table');
$schema = $this->_getParam('schema');
$file = $this->_getParam('file');
if(empty($table) || empty($schema) || empty($file)){
$this->_helper->json(['error'=>'参数错误']);
return true;
}
$fileHandle = new Westdc\Dataimport\File;
$realFile = $fileHandle->getRealName($file);
$processing = Westdc\Dataimport\ProcessFactory::Bootstrap($fileHandle->getFileTextExt($file));
/** @var \Westdc\Dataimport\Processing\Csv $processing */
$processing->init($realFile);
if($ac == "checktables")
{
$tableControl = new Westdc\Visual\DataTableControl;
$fields = $tableControl->readFields($schema . "." .$table);
$status = $processing->checkTableField($fields);
$this->_helper->json($status);
return true;
}
elseif($ac == "import"){
$status = $processing->import($schema . "." .$table);
$this->_helper->json($status);
return true;
}
return true;
}
return true;
}//dataimportAction()
/*
获得单个文件的信息

View File

@ -0,0 +1,72 @@
<?php
$this->headTitle($this->config->title->site);
$this->headTitle('后台管理');
$this->headTitle()->setSeparator(' - ');
?>
<div class="row-fluid">
<div class="span2">
<?= $this->partial('data/left.phtml'); ?>
</div>
<div class="span10">
<h3>数据导入<small>文件预处理</small></h3>
<hr />
处理文件:<?= $this->file ?>...
<h5>文件信息</h5>
<ul>
<li>文件行數:<?= $this->Count ?></li>
<li>文件大小:<?= $this->Size ?></li>
<li>文件类型:<?= $this->Type ?></li>
</ul>
<hr />
<h5 class="error-alerts" style="display: none;">错误消息</h5>
<ul id="errors" class="error-alerts" style="display: none;">
</ul>
<h6 id="error-loading"></h6>
<a href="javascript:void(0);" id="clt-next" class="btn btn-success disabled">下一步</a>
</div>
</div>
<script>
$(document).ready(function(){
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/check',
'data':'file=<?= $this->file ?>',
'success':function(data){
if (data!=null)
{
if(data.status == true)
{
$('#clt-next').removeClass('disabled');
$('#clt-next').attr('href','/admin/data/dataimport/ac/target?file=<?= $this->file ?>');
alert("數據完整性檢查成功,可以進行下一步");
return true;
}
$('.error-alerts').show();
$.each(data.status,function(index,value){
$('#errors').append("<li>"+value+"</li>");
});
}else{
alert('处理中出现错误');
}
},
'timeout': 30000,
'beforeSend' : function(){
$('#error-loading').html("正在對文件進行初始化檢查......");
$('#error-loading').show();
},
'complete' : function(){
$('#error-loading').hide();
}
});
});
</script>

View File

@ -0,0 +1,197 @@
<?php
$this->headTitle($this->config->title->site);
$this->headTitle('后台管理');
$this->headTitle()->setSeparator(' - ');
?>
<div class="row-fluid">
<div class="span2">
<?= $this->partial('data/left.phtml'); ?>
</div>
<div class="span10">
<h3>数据导入<small>选择导入目标</small></h3>
<hr />
导入文件:<?= $this->file ?>
<div class="row-fluid">
<div class="span3">
<h5>数据库:</h5>
<label class="radio">
<input type="radio" class="ctl-schema-btn" value="<?= $this->schema ?>" name="schema" selected readonly> <?= $this->schema ?>
</label>
</div>
<div class="span3" id="table-list">
</div>
</div>
<hr class="clear" />
<h5 class="error-alerts" style="display: none;">消息</h5>
<ul id="errors" class="error-alerts" style="display: none;">
</ul>
<h6 id="error-loading"></h6>
<form action="/admin/data/dataimport/ac/checktables" id="schema-form">
<input type="hidden" name="file" value="<?= $this->file ?>">
<input type="hidden" name="schema" value="">
<input type="hidden" name="table" value="" id="input-table">
<button type="button" id="ctl-next" class="btn btn-success disabled" disabled>下一步</button>
<button type="button" id="ctl-show-table" class="btn btn-info hidden" disabled>查看数据表结构</button>
<button type="button" id="ctl-import" class="btn btn-info" disabled="disabled" style="display: none;">导入数据表</button>
</form>
</div>
</div>
<script>
$(document).ready(function(){
$('#ctl-next').click(function(){
ctl.checkTable();
});
$("#ctl-show-table").click(function(){
});
$("#ctl-import").click(function(){
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/import',
'data':$('#schema-form').serialize(),
'success':function(data){
if (data!=true)
{
if(!$.isEmptyObject(data))
$(".error-alerts").show();
$("#errors").html(data.join("<br />"));
return true;
}else{
$('#ctl-import').remove();
$("#errors").html("数据导入成功!页面将自动跳转到数据可视化管理页面");
setTimeout("top.location = '/admin/data/visual';",3000);
}
},
'timeout': 30000,
'beforeSend' : function(){
$('#error-loading').html("正在进行数据导入......");
$('#error-loading').show();
$('#ctl-import').attr('disabled','disabled');
},
'complete' : function(){
$('#error-loading').hide();
},
'error' : function(){
$('#ctl-import').removeAttr('disabled');
}
});
});
$('.ctl-schema-btn').click(function(){
$('#schema-form input[name=schema]').val($(this).val());
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/gettables',
'data':'schema=' + $(this).val(),
'success':function(data){
if (data!=null)
{
if($.isEmptyObject(data))
{
ctl.disableNext();
alert("此数据库中尚无数据表");
return true;
}
$('#table-list').html('<h5>选择数据表</h5>');
$.each(data,function(index,value){
$('#table-list').append('<label class="radio">'
+ '<input type="radio" value="'+value.tablename+'" name="table" class="ctl-table-name">'
+ value.tablename
+"</label>"
);
});
$('.ctl-table-name').click(function(){
$('#schema-form input[name=table]').val($(this).val());
if($('#schema-form input[name=schema]').val() != '' && $('#schema-form input[name=table]').val() != '')
{
ctl.enableNext();
}
});
$('#clt-next').removeClass('disabled');
$('#clt-next').attr('href','/admin/data/dataimport/ac/target?file=<?= $this->file ?>');
return true;
}else{
alert('处理中出现错误');
}
},
'timeout': 30000,
'beforeSend' : function(){
$('#error-loading').html("正在加载数据表......");
$('#error-loading').show();
$('#table-list').html('');
$('.ctl-table-name').unbind();
},
'complete' : function(){
$('#error-loading').hide();
}
});
});
});
var ctl = {
enableNext : function(){
$('#ctl-next').removeClass("disabled");
$('#ctl-next').removeAttr("disabled");
},
disableNext : function(){
$('#ctl-next').addClass("disabled");
$('#ctl-next').attr("disabled","disabled");
},
checkTable : function(){
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/checktables',
'data':$('#schema-form').serialize(),
'success':function(data){
if (data!=true)
{
if(!$.isEmptyObject(data))
$(".error-alerts").show();
$("#errors").html(data.join("<br />"));
return true;
}else{
$(".error-alerts").show();
$('#errors').html('数据准备完成,可以进行导入操作');
$('.ctl-schema-btn').attr("disabled","disabled");
$('.ctl-table-name').attr("disabled","disabled");
$('#ctl-next').hide();
$('#ctl-show-table').hide();
$('#ctl-import').show();
$('#ctl-import').removeAttr("disabled");
}
},
'timeout': 30000,
'beforeSend' : function(){
$('#error-loading').html("正在校验数据是否可以导入......");
$('#error-loading').show();
},
'complete' : function(){
$('#error-loading').hide();
}
});
}
}
</script>

View File

@ -0,0 +1,151 @@
<?php
$this->headTitle($this->config->title->site);
$this->headTitle('后台管理');
$this->headTitle()->setSeparator(' - ');
$this->theme->AppendPlus($this,"jquery-fileupload");
?>
<div class="row-fluid">
<div class="span2">
<?= $this->partial('data/left.phtml'); ?>
</div>
<div class="span10">
<h3>数据导入</h3>
<hr />
<label>上传文件,请选择CSV文件进行上传</label>
<span class="btn btn-success fileinput-button file-upload-ctls">上传文件<input id="fileupload" type="file" name="FileData"></span>
<a href="javascript:void(0);" class="btn btn-info" id="ctl-show-files">查看已上传的文件</a>
<div class="progress" id="pdf-upload-progress" style="display: none;">
<div class="progress-bar progress-bar-striped active" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100" style="width: 0%">
</div>
</div>
<div id="uploadedFile"></div>
</div>
</div>
<script>
$(function () {
'use strict';
var jqXHR = $('#fileupload').fileupload({
url: '/admin/data/dataimport/ac/upload',
dataType: 'json',
done: function (e, data) {
if(typeof(data.result.error) != 'undefined' && data.result.error != 0)
{
alert(data.result.error);
return false;
}
if($('#uploadedFile').html() == "")
$('#uploadedFile').html(upload.makeFileHtml(data.result));
else
$('#uploadedFile').append(upload.makeFileHtml(data.result));
return true;
},
stop : function (e) {
$('#pdf-upload-progress').hide();
$('.file-upload-ctls').show();
},//stop
start : function (e) {
$('.file-upload-ctls').hide();
$('#pdf-upload-progress .progress-bar').css('width', 0 + '%');
$('#pdf-upload-progress').show();
},//start
progressall: function (e, data) {
var progress = parseInt(data.loaded / data.total * 100, 10);
$('#pdf-upload-progress .progress-bar').css(
'width',
progress + '%'
);
},//progressall
add: function (e, data) {
if($('input[name=attid]').length >= 1)
{
upload.deleteFile($('input[name=attid]').val());
$('file-alert').alert('close')
}
data.process().done(function () {
data.submit();
});
}//add
}).prop('disabled', !$.support.fileInput)
.parent().addClass($.support.fileInput ? undefined : 'disabled');
//file upload end
$('#ctl-show-files').click(function(){
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/files',
'data':'',
'success':function(data){
if (data!=null)
{
if($.isEmptyObject(data))
{
alert("目前沒有文件");
return;
}
if($('#uploadedFile').html() == "")
$('#uploadedFile').html(upload.makeFileList(data));
else
$('#uploadedFile').append(upload.makeFileList(data));
$('#ctl-show-files').attr('disabled','disabled');
$("#ctl-show-files").unbind( "click" );
}else{
alert('处理中出现错误');
}
},
'timeout': 30000
});
});//show files
});
var upload = {
makeFileHtml : function(data){
return '<div class="alert alert-success">'
+ '<span class="ctl-files">'+data.file+'</span>'
+ ' <a href="/admin/data/dataimport/ac/prepare/?file='+ encodeURI(data.file) +'">导入数据</a>'
+ '<a href="javascript:void(0)" onclick="upload.delete(this,\''+data.file+'\')" class="pull-right">删除</a>'
+ "</div>";
},
makeFileList : function(data){
var li = [];
$.each(data,function(k,v){
li.push('<div class="alert alert-success ctl-files">'
+ '<span class="ctl-files">'+v+'</span>'
+ ' <a href="/admin/data/dataimport/ac/prepare/?file='+ encodeURI(v) +'">导入数据</a>'
+ '<a href="javascript:void(0);" onclick="upload.delete(this,\''+v+'\')" class="pull-right">删除</a>'
+ "</div>");
});
return li.join("");
},
delete : function(dom,file){
$.ajax({
'type':"POST",
'url':'/admin/data/dataimport/ac/delete',
'data':'file='+file,
'success':function(data){
if(data.success == true)
$(dom).parent('div').remove();
else
alert("failed");
},
'timeout': 30000
});
}
};
</script>

View File

@ -7,6 +7,7 @@
<li><a href="/admin/data/version">数据版本管理</a></li>
<li><a href="/admin/data/comment">数据反馈管理</a></li>
<li><a href="/admin/data/attachments">数据附件管理</a></li>
<li><a href="/admin/data/visual">可视化数据</a></li>
<li><a href="/admin/data/visual">数据可视化管理</a></li>
<li><a href="/admin/data/dataimport">数据入库处理</a></li>
</ul>
</div>

View File

@ -27,6 +27,8 @@ auth.domain = .sanjiangyuan.org.cn
sub.metadata = emcmd
sub.news = qhemc
sub.search = emcmd
sub.schema = emc
dataimport.path = ../data/dbupload/
google.maps.api=ABQIAAAACD-MqkkoOm60o_dvwdcKVhRBSKpgcP88GYi6r2Of16IkMX_4YhSBQsywCi4J2_fh4nBuWmK7gyRjLg
bing.api=4BC90E1E9ED351ECE0D9FB71509BC3CC1264340C

View File

@ -16,11 +16,14 @@ class IndexController extends Zend_Controller_Action
function indexAction()
{
//统计数据
$sql="select (select count(*) from users) as usernum,(select count(*) from {$this->submd}) as metanum,(select count(*) from offlineapp where ts_approved is not null ) as offlinenum";
$sql="select (select count(*) from users) as usernum,(select count(*) from {$this->submd}) as metanum,
(select count(distinct d.uuid) from dataorder d left join offlineapp f on d.offlineappid=f.id where d.uuid in (select uuid from meteorologymd) and d.ts_approved is not null and d.status in (0,5) ) as offlinenum,
(select count(*) from datavisual where uuid in (select uuid from {$this->submd}) and status=1) as visualnum";
$row=$this->db->fetchRow($sql);
$this->view->usernum=$row['usernum'];
$this->view->metanum=$row['metanum'];
$this->view->offlinenum=$row['offlinenum'];
$this->view->visualnum=$row['visualnum'];
/*$sql='select count(*) from metadata';
$row=$this->db->fetchRow($sql);
$this->view->metanum=$row['count'];*/

View File

@ -143,6 +143,17 @@ class Theme
'/js/lib/highcharts/highcharts-more.js'
)
),
'jquery-fileupload' => array(
$this->ScriptKey => array(
'/js/lib/jquery.fileupload/vendor/jquery.ui.widget.js',
'/js/lib/jquery.fileupload/jquery.iframe-transport.js',
'/js/lib/jquery.fileupload/jquery.fileupload.js',
),
$this->CSSKey => array(
'/js/lib/jquery.fileupload/css/jquery.fileupload.css',
)
),
/*********谷歌地图*********/

View File

@ -0,0 +1,10 @@
<?php
namespace Goodby\CSV\Export\Protocol\Exception;
/**
* Throws if it is unable to write CSV file
*/
class IOException extends \RuntimeException
{
}

View File

@ -0,0 +1,22 @@
<?php
namespace Goodby\CSV\Export\Protocol;
use Traversable;
use Goodby\CSV\Export\Protocol\Exception\IOException;
/**
* Interface of the Exporter
*/
interface ExporterInterface
{
/**
* Export data as CSV file
*
* @param string $filename
* @param array|Traversable $rows
* @throws IOException
* @return void
*/
public function export($filename, $rows);
}

View File

@ -0,0 +1,88 @@
<?php
namespace Goodby\CSV\Export\Standard\Collection;
use Iterator;
use IteratorAggregate;
class CallbackCollection implements Iterator
{
private $callable;
private $data;
public function __construct($data, $callable)
{
$this->callable = $callable;
if (!is_callable($callable)) {
throw new \InvalidArgumentException('the second argument must be callable');
}
if (is_array($data)) {
$ao = new \ArrayObject($data);
$this->data = $ao->getIterator();
} elseif ($data instanceof Iterator) {
$this->data = $data;
} elseif ($data instanceof IteratorAggregate) {
$this->data = $data->getIterator();
} else {
throw new \InvalidArgumentException('data must be an array or an Iterator/IteratorAggregate');
}
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Return the current element
* @link http://php.net/manual/en/iterator.current.php
* @return mixed Can return any type.
*/
public function current()
{
return call_user_func($this->callable, $this->data->current());
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Move forward to next element
* @link http://php.net/manual/en/iterator.next.php
* @return void Any returned value is ignored.
*/
public function next()
{
$this->data->next();
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Return the key of the current element
* @link http://php.net/manual/en/iterator.key.php
* @return mixed scalar on success, or null on failure.
*/
public function key()
{
return $this->data->key();
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Checks if current position is valid
* @link http://php.net/manual/en/iterator.valid.php
* @return boolean The return value will be casted to boolean and then evaluated.
* Returns true on success or false on failure.
*/
public function valid()
{
return $this->data->valid();
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Rewind the Iterator to the first element
* @link http://php.net/manual/en/iterator.rewind.php
* @return void Any returned value is ignored.
*/
public function rewind()
{
$this->data->rewind();
}
}

View File

@ -0,0 +1,82 @@
<?php
namespace Goodby\CSV\Export\Standard\Collection;
use Iterator;
use PDO;
class PdoCollection implements Iterator
{
/**
* @var \PDOStatement
*/
private $stmt;
private $rowCount;
private $current = 0;
public function __construct(\PDOStatement $stmt)
{
$this->stmt = $stmt;
$this->rowCount = $this->stmt->rowCount();
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Return the current element
* @link http://php.net/manual/en/iterator.current.php
* @return mixed Can return any type.
*/
public function current()
{
return $this->stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Move forward to next element
* @link http://php.net/manual/en/iterator.next.php
* @return void Any returned value is ignored.
*/
public function next()
{
$this->current++;
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Return the key of the current element
* @link http://php.net/manual/en/iterator.key.php
* @return mixed scalar on success, or null on failure.
*/
public function key()
{
$this->current;
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Checks if current position is valid
* @link http://php.net/manual/en/iterator.valid.php
* @return boolean The return value will be casted to boolean and then evaluated.
* Returns true on success or false on failure.
*/
public function valid()
{
return ($this->rowCount > $this->current);
}
/**
* (PHP 5 &gt;= 5.0.0)<br/>
* Rewind the Iterator to the first element
* @link http://php.net/manual/en/iterator.rewind.php
* @return void Any returned value is ignored.
*/
public function rewind()
{
$this->stmt->execute();
$this->current = 0;
}
}

View File

@ -0,0 +1,84 @@
<?php
namespace Goodby\CSV\Export\Standard;
use SplFileObject;
class CsvFileObject extends SplFileObject
{
const FILE_MODE_WRITE = 'w';
const FILE_MODE_APPEND = 'a';
/**
* newline character
* @var string
*/
private $newline = "\n";
/**
* CSV filter
* @var callable
*/
private $csvFilter;
/**
* @param string $newline
* @return void
*/
public function setNewline($newline)
{
$this->newline = $newline;
}
/**
* Set csv filter
* @param callable $filter
*/
public function setCsvFilter($filter)
{
$this->csvFilter = $filter;
}
/**
* Write a field array as a CSV line
* @param array $fields
* @param string $delimiter
* @param string $enclosure
* @return int|void
*/
public function fputcsv($fields, $delimiter = null, $enclosure = null)
{
// Temporary output a line to memory to get line as string
$fp = fopen('php://temp', 'w+');
$arguments = func_get_args();
array_unshift($arguments, $fp);
call_user_func_array('fputcsv', $arguments);
rewind($fp);
$line = '';
while ( feof($fp) === false ) {
$line .= fgets($fp);
}
fclose($fp);
/**
* Because the php_fputcsv() implementation in PHP´s source code
* has a hardcoded "\n", this method replaces the last LF code
* with what the client code wishes.
*/
$line = rtrim($line, "\n"). $this->newline;
// if the enclosure was '' | false
if (empty($enclosure)) {
$line = str_replace("\0", '', $line);
}
if ( is_callable($this->csvFilter) ) {
$line = call_user_func($this->csvFilter, $line);
}
return $this->fwrite($line);
}
}

View File

@ -0,0 +1,7 @@
<?php
namespace Goodby\CSV\Export\Standard\Exception;
class StrictViolationException extends \RuntimeException
{
}

View File

@ -0,0 +1,110 @@
<?php
namespace Goodby\CSV\Export\Standard;
use Goodby\CSV\Export\Protocol\ExporterInterface;
use Goodby\CSV\Export\Protocol\Exception\IOException;
use Goodby\CSV\Export\Standard\Exception\StrictViolationException;
/**
* Standard exporter class
*/
class Exporter implements ExporterInterface
{
/**
* @var ExporterConfig
*/
private $config;
/**
* @var int
*/
private $rowConsistency = null;
/**
* @var bool
*/
private $strict = true;
/**
* Return new Exporter object
* @param ExporterConfig $config
*/
public function __construct(ExporterConfig $config)
{
$this->config = $config;
}
/**
* Disable strict mode
*/
public function unstrict()
{
$this->strict = false;
}
/**
* {@inherit}
* @throws StrictViolationException
*/
public function export($filename, $rows)
{
$delimiter = $this->config->getDelimiter();
$enclosure = $this->config->getEnclosure();
$enclosure = empty($enclosure) ? "\0" : $enclosure;
$newline = $this->config->getNewline();
$fromCharset = $this->config->getFromCharset();
$toCharset = $this->config->getToCharset();
$fileMode = $this->config->getFileMode();
$columnHeaders = $this->config->getColumnHeaders();
try {
$csv = new CsvFileObject($filename, $fileMode);
} catch ( \Exception $e ) {
throw new IOException($e->getMessage(), null, $e);
}
$csv->setNewline($newline);
if ( $toCharset ) {
$csv->setCsvFilter(function($line) use($toCharset, $fromCharset) {
return mb_convert_encoding($line, $toCharset, $fromCharset);
});
}
if (count($columnHeaders) > 0) {
$this->checkRowConsistency($columnHeaders);
$csv->fputcsv($columnHeaders, $delimiter, $enclosure);
}
foreach ( $rows as $row ) {
$this->checkRowConsistency($row);
$csv->fputcsv($row, $delimiter, $enclosure);
}
$csv->fflush();
}
/**
* Check if the column count is consistent with comparing other rows
* @param array|\Countable $row
* @throws Exception\StrictViolationException
*/
private function checkRowConsistency($row)
{
if ( $this->strict === false ) {
return;
}
$current = count($row);
if ( $this->rowConsistency === null ) {
$this->rowConsistency = $current;
}
if ( $current !== $this->rowConsistency ) {
throw new StrictViolationException();
}
$this->rowConsistency = $current;
}
}

View File

@ -0,0 +1,218 @@
<?php
namespace Goodby\CSV\Export\Standard;
/**
* Config for Exporter object
*/
class ExporterConfig
{
/**
* Delimiter
* @var string
*/
private $delimiter = ',';
/**
* Enclosure
* @var string
*/
private $enclosure = '"';
/**
* Escape
* @var string
*/
private $escape = '\\';
/**
* Newline code
* @var string
*/
private $newline = "\r\n";
/**
* From charset
* @var string
*/
private $fromCharset = 'auto';
/**
* To charset
* @var string
*/
private $toCharset = null;
/**
* File mode
* @var string
*/
private $fileMode = CsvFileObject::FILE_MODE_WRITE;
/**
* The column headers.
* @var array
*/
private $columnHeaders = array();
/**
* Set delimiter
* @param string $delimiter
* @return ExporterConfig
*/
public function setDelimiter($delimiter)
{
$this->delimiter = $delimiter;
return $this;
}
/**
* Return delimiter
* @return string
*/
public function getDelimiter()
{
return $this->delimiter;
}
/**
* Set enclosure
* @param string $enclosure
* @return ExporterConfig
*/
public function setEnclosure($enclosure)
{
$this->enclosure = $enclosure;
return $this;
}
/**
* Return enclosure
* @return string
*/
public function getEnclosure()
{
return $this->enclosure;
}
/**
* Set escape
* @param string $escape
* @return ExporterConfig
*/
public function setEscape($escape)
{
$this->escape = $escape;
return $this;
}
/**
* Return escape
* @return string
*/
public function getEscape()
{
return $this->escape;
}
/**
* Set newline
* @param string $newline
* @return ExporterConfig
*/
public function setNewline($newline)
{
$this->newline = $newline;
return $this;
}
/**
* Return newline
* @return string
*/
public function getNewline()
{
return $this->newline;
}
/**
* Set from-character set
* @param string $fromCharset
* @return ExporterConfig
*/
public function setFromCharset($fromCharset)
{
$this->fromCharset = $fromCharset;
return $this;
}
/**
* Return from-character set
* @return string
*/
public function getFromCharset()
{
return $this->fromCharset;
}
/**
* Set to-character set
* @param string $toCharset
* @return ExporterConfig
*/
public function setToCharset($toCharset)
{
$this->toCharset = $toCharset;
return $this;
}
/**
* Return to-character set
* @return string
*/
public function getToCharset()
{
return $this->toCharset;
}
/**
* Set file mode
* @param string $fileMode
* @return ExporterConfig
*/
public function setFileMode($fileMode)
{
$this->fileMode = $fileMode;
return $this;
}
/**
* Return file mode
* @return string
*/
public function getFileMode()
{
return $this->fileMode;
}
/**
* Set the column headers.
* @param array $columnHeaders
* @return ExporterConfig
*/
public function setColumnHeaders(array $columnHeaders)
{
$this->columnHeaders = $columnHeaders;
return $this;
}
/**
* Get the column headers.
* @return array
*/
public function getColumnHeaders()
{
return $this->columnHeaders;
}
}

View File

@ -0,0 +1,39 @@
<?php
namespace Goodby\CSV\Export\Tests\Protocol;
use Goodby\CSV\Export\Protocol\Exception\IOException;
class ExporterInterfaceTest extends \PHPUnit_Framework_TestCase
{
public function testExport()
{
$exporter = $this->getMock('Goodby\CSV\Export\Protocol\ExporterInterface');
$exporter->expects($this->once())->method('export');
$exporter->export('filename', array(
array('ID', 'name', 'email'),
array('1', 'alice', 'alice@example.com'),
array('2', 'bob', 'bob@example.com'),
));
}
/**
* @expectedException \Goodby\CSV\Export\Protocol\Exception\IOException
*/
public function testExportsThrowsIOException()
{
$exporter = $this->getMock('Goodby\CSV\Export\Protocol\ExporterInterface');
$exporter
->expects($this->once())
->method('export')
->will($this->throwException(new IOException('Unable to write')));
$exporter->export('/path/to/file.csv', array(
array('ID', 'name', 'email'),
array('1', 'alice', 'alice@example.com'),
array('2', 'bob', 'bob@example.com'),
));
}
}

View File

@ -0,0 +1,68 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Join\Collection;
use Goodby\CSV\Export\Standard\Collection\PdoCollection;
use Goodby\CSV\TestHelper\DbManager;
use Goodby\CSV\Export\Standard\Collection\CallbackCollection;
class PdoCollectionTest extends \PHPUnit_Framework_TestCase
{
/**
* @var \Goodby\CSV\TestHelper\DbManager
*/
private $manager = null;
public function setUp()
{
$this->manager = new DbManager();
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("CREATE TABLE collection_test ( id INT, name VARCHAR(32) )");
$stmt->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(1, 'name')")->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(2, 'name')")->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(3, 'name')")->execute();
}
public function tearDown()
{
unset($this->manager);
}
public function testUsage()
{
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("SELECT * FROM collection_test");
$stmt->execute();
$pdoCollection = new PdoCollection($stmt);
foreach ($pdoCollection as $line) {
$this->assertEquals("name", $line["name"]);
}
}
public function testUsageWithCallbackCollection()
{
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("SELECT * FROM collection_test");
$stmt->execute();
$pdoCollection = new PdoCollection($stmt);
$callbackCollection = new CallbackCollection($pdoCollection, function($row) {
$row['test'] = 'test';
return $row;
});
foreach ($callbackCollection as $line) {
$this->assertEquals('test', $line['test']);
}
}
}

View File

@ -0,0 +1,188 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Join;
use Goodby\CSV\Export\Standard\Exporter;
use Goodby\CSV\Export\Standard\ExporterConfig;
use Goodby\CSV\Export\Standard\Exception\StrictViolationException;
use Goodby\CSV\Export\Protocol\Exception\IOException;
use org\bovigo\vfs\vfsStreamDirectory;
use org\bovigo\vfs\vfsStream;
class ExporterTest extends \PHPUnit_Framework_TestCase
{
/**
* @var vfsStreamDirectory
*/
private $root;
/**
* set up test environment
*/
public function setUp()
{
$this->root = vfsStream::setup('output');
}
public function testExport()
{
$config = new ExporterConfig();
$exporter = new Exporter($config);
$this->assertFileNotExists('vfs://output/data.csv');
$exporter->export('vfs://output/data.csv', array(
array('ID', 'name', 'email'),
array('1', 'alice', 'alice@example.com'),
array('2', 'bob', 'bob@example.com'),
));
$this->assertFileExists('vfs://output/data.csv');
$expectedContents = "ID,name,email\r\n";
$expectedContents .= "1,alice,alice@example.com\r\n";
$expectedContents .= "2,bob,bob@example.com\r\n";
$this->assertSame($expectedContents, file_get_contents('vfs://output/data.csv'));
}
public function test_export_with_carriage_return()
{
$config = new ExporterConfig();
$config->setNewline("\r");
$exporter = new Exporter($config);
$exporter->unstrict();
$this->assertFileNotExists('vfs://output/data.csv');
$exporter->export('vfs://output/data.csv', array(
array('aaa', 'bbb', 'ccc', 'dddd'),
array('123', '456', '789'),
array('"aaa"', '"bbb"', '', ''),
));
$this->assertFileExists('vfs://output/data.csv');
$expectedContents = "aaa,bbb,ccc,dddd\r";
$expectedContents .= "123,456,789\r";
$expectedContents .= '"""aaa""","""bbb""",,'."\r";
$this->assertSame($expectedContents, file_get_contents('vfs://output/data.csv'));
}
public function testUnstrict()
{
$config = new ExporterConfig();
$exporter = new Exporter($config);
$this->assertAttributeSame(true, 'strict', $exporter);
$exporter->unstrict();
$this->assertAttributeSame(false, 'strict', $exporter);
}
/**
* @expectedException \Goodby\CSV\Export\Standard\Exception\StrictViolationException
*/
public function testStrict()
{
$config = new ExporterConfig();
$exporter = new Exporter($config);
$exporter->export('vfs://output/data.csv', array(
array('a', 'b', 'c'),
array('a', 'b', 'c'),
array('a', 'b'),
));
}
/**
* @requires PHP 5.4
*/
public function test_throwing_IOException_when_failed_to_write_file()
{
$noWritableCsv = 'vfs://output/no-writable.csv';
touch($noWritableCsv);
chmod($noWritableCsv, 0444);
$this->assertFalse(is_writable($noWritableCsv));
$config = new ExporterConfig();
$exporter = new Exporter($config);
$e = null;
try {
$exporter->export($noWritableCsv, array(
array('a', 'b', 'c'),
));
} catch ( IOException $e ) {
}
$this->assertTrue($e instanceof IOException);
$this->assertContains('failed to open', $e->getMessage());
}
public function test_encoding()
{
$csv = 'vfs://output/euc.csv';
$this->assertFileNotExists($csv);
$config = new ExporterConfig();
$config->setToCharset('EUC-JP');
$config->setNewline("\n");
$exporter = new Exporter($config);
$exporter->export($csv, array(
array('あ', 'い', 'う', 'え', 'お'),
));
$this->assertFileEquals(__DIR__.'/csv_files/euc-jp.csv', $csv);
}
public function test_without_encoding()
{
$csv = 'vfs://output/utf-8.csv';
$this->assertFileNotExists($csv);
$config = new ExporterConfig();
$config->setNewline("\n");
$exporter = new Exporter($config);
$exporter->export($csv, array(
array('✔', '✔', '✔'),
array('★', '★', '★'),
));
$this->assertFileEquals(__DIR__.'/csv_files/utf-8.csv', $csv);
}
public function test_unseekable_wrapper_and_custom_newline_code()
{
$config = new ExporterConfig();
$config->setNewline("\r\n");
$exporter = new Exporter($config);
ob_start();
$exporter->export('php://output', array(
array('a', 'b', 'c'),
array('1', '2', '3'),
));
$output = ob_get_clean();
$expectedCount = "a,b,c\r\n1,2,3\r\n";
$this->assertSame($expectedCount, $output);
}
public function test_multiple_line_columns()
{
$csv = 'vfs://output/multiple-lines.csv';
$this->assertFileNotExists($csv);
$config = new ExporterConfig();
$config->setNewline("\r\n");
$exporter = new Exporter($config);
$exporter->export($csv, array(
array("line1\r\nline2\r\nline3", "single-line"),
array("line1\r\nline2\r\nline3", "single-line"),
array("line1\r\nline2\r\nline3", "single-line"),
));
$this->assertFileEquals(__DIR__.'/csv_files/multiple-lines.csv', $csv);
}
}

View File

@ -0,0 +1,95 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Join;
use Goodby\CSV\Export\Standard\Exporter;
use Goodby\CSV\Export\Standard\ExporterConfig;
use Goodby\CSV\Export\Standard\Collection\PdoCollection;
use Goodby\CSV\TestHelper\DbManager;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamDirectory;
use Goodby\CSV\Export\Standard\Collection\CallbackCollection;
class UsageTest extends \PHPUnit_Framework_TestCase
{
/**
* @var \Goodby\CSV\TestHelper\DbManager
*/
private $manager = null;
/**
* @var vfsStreamDirectory
*/
private $root;
public function setUp()
{
$this->root = vfsStream::setup('output');
$this->manager = new DbManager();
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("CREATE TABLE collection_test ( id INT, name VARCHAR(32) )");
$stmt->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(1, 'name')")->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(2, 'name')")->execute();
$pdo->prepare("INSERT INTO collection_test VALUES(3, 'name')")->execute();
}
public function tearDown()
{
unset($this->manager);
}
public function testUsage()
{
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("SELECT * FROM collection_test");
$stmt->execute();
$this->assertFileNotExists('vfs://output/data.csv');
$collection = new PdoCollection($stmt);
$config = new ExporterConfig();
$exporter = new Exporter($config);
$exporter->export('vfs://output/data.csv', $collection);
$expectedContents = "1,name\r\n";
$expectedContents .= "2,name\r\n";
$expectedContents .= "3,name\r\n";
$this->assertSame($expectedContents, file_get_contents('vfs://output/data.csv'));
}
public function testUsageWithCallbackCollection()
{
$this->assertFileNotExists('vfs://output/data.csv');
$data = array();
$data[] = array(1, 'name1');
$data[] = array(2, 'name2');
$data[] = array(3, 'name3');
$collection = new CallbackCollection($data, function($row) {
$row[1] = $row[1] . '!';
return $row;
});
$config = new ExporterConfig();
$exporter = new Exporter($config);
$exporter->export('vfs://output/data.csv', $collection);
$expectedContents = "1,name1!\r\n";
$expectedContents .= "2,name2!\r\n";
$expectedContents .= "3,name3!\r\n";
$this->assertSame($expectedContents, file_get_contents('vfs://output/data.csv'));
}
}

View File

@ -0,0 +1 @@
あ,い,う,え,お
1

View File

@ -0,0 +1,9 @@
"line1
line2
line3",single-line
"line1
line2
line3",single-line
"line1
line2
line3",single-line
1 line1 line2 line3 single-line
2 line1 line2 line3 single-line
3 line1 line2 line3 single-line

View File

@ -0,0 +1,2 @@
✔,✔,✔
★,★,★
1
2

View File

@ -0,0 +1,50 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Unit\Collection;
use Goodby\CSV\Export\Standard\Collection\CallbackCollection;
use Goodby\CSV\Export\Tests\Standard\Unit\Collection\SampleAggIterator;
class CallbackCollectionTest extends \PHPUnit_Framework_TestCase
{
public function testSample()
{
$data = array();
$data[] = array('user', 'name1');
$data[] = array('user', 'name2');
$data[] = array('user', 'name3');
$collection = new CallbackCollection($data, function($mixed) {
return $mixed;
});
$index = 1;
foreach ($collection as $each) {
$this->assertEquals($each[0], 'user');
$this->assertEquals($each[1], 'name' . $index);
$index++;
}
}
public function testIteratorAggregate()
{
$data = array();
$data[] = array('user', 'name1');
$data[] = array('user', 'name2');
$data[] = array('user', 'name3');
$iterator = new SampleAggIterator($data);
$collection = new CallbackCollection($iterator, function($mixed) {
return $mixed;
});
$index = 1;
foreach ($collection as $each) {
$this->assertEquals($each[0], 'user');
$this->assertEquals($each[1], 'name' . $index);
$index++;
}
}
}

View File

@ -0,0 +1,19 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Unit\Collection;
use \ArrayIterator;
class SampleAggIterator implements \IteratorAggregate
{
protected $data;
public function __construct($data)
{
$this->data = $data;
}
public function getIterator()
{
return new ArrayIterator($this->data);
}
}

View File

@ -0,0 +1,63 @@
<?php
namespace Goodby\CSV\Export\Tests\Standard\Unit;
use Goodby\CSV\Export\Standard\ExporterConfig;
class ExporterConfigTest extends \PHPUnit_Framework_TestCase
{
public function testDelimiter()
{
$config = new ExporterConfig();
$this->assertSame(',', $config->getDelimiter());
$this->assertSame('del', $config->setDelimiter('del')->getDelimiter());
}
public function testEnclosure()
{
$config = new ExporterConfig();
$this->assertSame('"', $config->getEnclosure());
$this->assertSame('enc', $config->setEnclosure('enc')->getEnclosure());
}
public function testEscape()
{
$config = new ExporterConfig();
$this->assertSame('\\', $config->getEscape());
$this->assertSame('esc', $config->setEscape('esc')->getEscape());
}
public function testNewline()
{
$config = new ExporterConfig();
$this->assertSame("\r\n", $config->getNewline());
$this->assertSame("\r", $config->setNewline("\r")->getNewline());
}
public function testFromCharset()
{
$config = new ExporterConfig();
$this->assertSame('auto', $config->getFromCharset());
$this->assertSame('UTF-8', $config->setFromCharset('UTF-8')->getFromCharset());
}
public function testToCharset()
{
$config = new ExporterConfig();
$this->assertSame(null, $config->getToCharset());
$this->assertSame('UTF-8', $config->setToCharset('UTF-8')->getToCharset());
}
public function testColumnHeaders()
{
$columnHeaders = array(
'Header 1',
'Header 2',
'Header 3',
);
$config = new ExporterConfig();
$this->assertSame(array(), $config->getColumnHeaders());
$this->assertSame($columnHeaders, $config->setColumnHeaders($columnHeaders)->getColumnHeaders());
}
}

View File

@ -0,0 +1,10 @@
<?php
namespace Goodby\CSV\Import\Protocol\Exception;
/**
* Throws if csv file not found
*/
class CsvFileNotFoundException extends \RuntimeException
{
}

View File

@ -0,0 +1,10 @@
<?php
namespace Goodby\CSV\Import\Protocol\Exception;
/**
* Invalid lexical Exception
*/
class InvalidLexicalException extends \RuntimeException
{
}

View File

@ -0,0 +1,15 @@
<?php
namespace Goodby\CSV\Import\Protocol;
/**
* Interface of the Interpreter
*/
interface InterpreterInterface
{
/**
* @param $line
* @return void
*/
public function interpret($line);
}

View File

@ -0,0 +1,20 @@
<?php
namespace Goodby\CSV\Import\Protocol;
use Goodby\CSV\Import\Protocol\Exception\CsvFileNotFoundException;
/**
* Interface of Lexer
*/
interface LexerInterface
{
/**
* Parse csv file
* @param string $filename
* @param InterpreterInterface $interpreter
* @return boolean
* @throws CsvFileNotFoundException
*/
public function parse($filename, InterpreterInterface $interpreter);
}

View File

@ -0,0 +1,7 @@
<?php
namespace Goodby\CSV\Import\Standard\Exception;
class StrictViolationException extends \RuntimeException
{
}

View File

@ -0,0 +1,120 @@
<?php
namespace Goodby\CSV\Import\Standard;
use Goodby\CSV\Import\Protocol\InterpreterInterface;
use Goodby\CSV\Import\Protocol\Exception\InvalidLexicalException;
use Goodby\CSV\Import\Standard\Exception\StrictViolationException;
/**
* standard interpreter
*/
class Interpreter implements InterpreterInterface
{
/**
* @var array
*/
private $observers = array();
/**
* @var int
*/
private $rowConsistency = null;
/**
* @var bool
*/
private $strict = true;
/**
* interpret line
*
* @param $line
* @return void
* @throws \Goodby\CSV\Import\Protocol\Exception\InvalidLexicalException
*/
public function interpret($line)
{
$this->checkRowConsistency($line);
if (!is_array($line)) {
throw new InvalidLexicalException('line is must be array');
}
$this->notify($line);
}
public function unstrict()
{
$this->strict = false;
}
/**
* add observer
*
* @param callable $observer
*/
public function addObserver($observer)
{
$this->checkCallable($observer);
$this->observers[] = $observer;
}
/**
* notify to observers
*
* @param $line
*/
private function notify($line)
{
$observers = $this->observers;
foreach ($observers as $observer) {
$this->delegate($observer, $line);
}
}
/**
* delegate to observer
*
* @param $observer
* @param $line
*/
private function delegate($observer, $line)
{
call_user_func($observer, $line);
}
/**
* check observer is callable
*
* @param $observer
* @throws \InvalidArgumentException
*/
private function checkCallable($observer)
{
if (!is_callable($observer)) {
throw new \InvalidArgumentException('observer must be callable');
}
}
private function checkRowConsistency($line)
{
if (!$this->strict) {
return;
}
$current = count($line);
if ($this->rowConsistency === null) {
$this->rowConsistency = $current;
}
if ($current !== $this->rowConsistency) {
throw new StrictViolationException(sprintf('Column size should be %u, but %u columns given', $this->rowConsistency, $current));
}
$this->rowConsistency = $current;
}
}

View File

@ -0,0 +1,69 @@
<?php
namespace Goodby\CSV\Import\Standard;
use Goodby\CSV\Import\Protocol\LexerInterface;
use Goodby\CSV\Import\Protocol\InterpreterInterface;
use Goodby\CSV\Import\Standard\StreamFilter\ConvertMbstringEncoding;
use SplFileObject;
class Lexer implements LexerInterface
{
/**
* @var LexerConfig
*/
private $config;
/**
* Return new Lexer object
* @param LexerConfig $config
*/
public function __construct(LexerConfig $config = null)
{
if (!$config) {
$config = new LexerConfig();
}
$this->config = $config;
ConvertMbstringEncoding::register();
}
/**
* {@inherit}
*/
public function parse($filename, InterpreterInterface $interpreter)
{
ini_set('auto_detect_line_endings', true); // For mac's office excel csv
$delimiter = $this->config->getDelimiter();
$enclosure = $this->config->getEnclosure();
$escape = $this->config->getEscape();
$fromCharset = $this->config->getFromCharset();
$toCharset = $this->config->getToCharset();
$flags = $this->config->getFlags();
$ignoreHeader = $this->config->getIgnoreHeaderLine();
if ( $fromCharset === null ) {
$url = $filename;
} else {
$url = ConvertMbstringEncoding::getFilterURL($filename, $fromCharset, $toCharset);
}
$csv = new SplFileObject($url);
$csv->setCsvControl($delimiter, $enclosure, $escape);
$csv->setFlags($flags);
$originalLocale = setlocale(LC_ALL, '0'); // Backup current locale
setlocale(LC_ALL, 'en_US.UTF-8');
foreach ( $csv as $lineNumber => $line ) {
if ($ignoreHeader && $lineNumber == 0 || (count($line) === 1 && empty($line[0]))) {
continue;
}
$interpreter->interpret($line);
}
parse_str(str_replace(';', '&', $originalLocale), $locale_array);
setlocale(LC_ALL, $locale_array); // Reset locale
}
}

View File

@ -0,0 +1,185 @@
<?php
namespace Goodby\CSV\Import\Standard;
use SplFileObject;
/**
* Config for Lexer object
*/
class LexerConfig
{
/**
* @var string
*/
private $delimiter = ',';
/**
* @var string
*/
private $enclosure = '"';
/**
* @var string
*/
private $escape = '\\';
/**
* @var string
*/
private $fromCharset;
/**
* @var string
*/
private $toCharset;
/**
* @var integer
*/
private $flags = SplFileObject::READ_CSV;
/**
* @var bool
*/
private $ignoreHeaderLine = false;
/**
* Set delimiter
* @param string $delimiter
* @return LexerConfig
*/
public function setDelimiter($delimiter)
{
$this->delimiter = $delimiter;
return $this;
}
/**
* Return delimiter
* @return string
*/
public function getDelimiter()
{
return $this->delimiter;
}
/**
* Set enclosure
* @param string $enclosure
* @return LexerConfig
*/
public function setEnclosure($enclosure)
{
$this->enclosure = $enclosure;
return $this;
}
/**
* Return enclosure
* @return string
*/
public function getEnclosure()
{
return $this->enclosure;
}
/**
* Set escape
* @param string $escape
* @return LexerConfig
*/
public function setEscape($escape)
{
$this->escape = $escape;
return $this;
}
/**
* Return escape
* @return string
*/
public function getEscape()
{
return $this->escape;
}
/**
* Set from-character set
* @param string $fromCharset
* @return LexerConfig
*/
public function setFromCharset($fromCharset)
{
$this->fromCharset = $fromCharset;
return $this;
}
/**
* Return from-character set
* @return string
*/
public function getFromCharset()
{
return $this->fromCharset;
}
/**
* Set to-character set
* @param string $toCharset
* @return LexerConfig
*/
public function setToCharset($toCharset)
{
$this->toCharset = $toCharset;
return $this;
}
/**
* Return to-character set
* @return string
*/
public function getToCharset()
{
return $this->toCharset;
}
/**
* Set flags
* @param integer $flags Bit mask of the flags to set. See SplFileObject constants for the available flags.
* @return LexerConfig
* @see http://php.net/manual/en/class.splfileobject.php#splfileobject.constants
*/
public function setFlags($flags)
{
$this->flags = $flags;
return $this;
}
/**
* Return flags
* @return integer
*/
public function getFlags()
{
return $this->flags;
}
/**
* @param $ignoreHeaderLine
* @return $this
*/
public function setIgnoreHeaderLine($ignoreHeaderLine)
{
$this->ignoreHeaderLine = $ignoreHeaderLine;
return $this;
}
/**
* @return boolean
*/
public function getIgnoreHeaderLine()
{
return $this->ignoreHeaderLine;
}
}

View File

@ -0,0 +1,71 @@
<?php
namespace Goodby\CSV\Import\Standard\Observer;
class PdoObserver
{
private $table;
private $columns;
private $dsn;
private $options = null;
private $pdo = null;
public function __construct($table, $columns, $dsn, $options)
{
$this->table = $table;
$this->columns = $columns;
$this->dsn = $dsn;
$this->options = $options;
}
public function notify($line)
{
if ($this->pdo === null) {
$this->pdo = new \PDO($this->dsn, $this->options['user'], $this->options['password']);
}
$this->execute($line);
}
private function execute($line)
{
$line = array_map(function($value) {
$number = filter_var($value, FILTER_VALIDATE_INT);
if ($number !== false) {
return $number;
}
if (is_string($value)) {
if (strtolower($value) === 'null') {
return 'NULL';
}
if (strtolower($value) === 'true') {
return 1;
}
if (strtolower($value) === 'false') {
return 0;
}
return $value;
}
throw new \InvalidArgumentException('value is invalid: ' . var_export($value, 1));
}, $line);
$prepare = array_map(function() {
return '?';
}, $line);
$sql = 'INSERT INTO ' . $this->table . '(' . join(', ', $this->columns) . ')' .
' VALUES(' . join(',', $prepare) . ')';
$stmt = $this->pdo->prepare($sql);
$stmt->execute($line);
}
}

View File

@ -0,0 +1,62 @@
<?php
namespace Goodby\CSV\Import\Standard\Observer;
class SqlObserver
{
private $table;
private $columns;
private $path;
private $file = null;
public function __construct($table, $columns, $path)
{
$this->table = $table;
$this->columns = $columns;
$this->path = $path;
}
public function notify($line)
{
$sql = $this->buildSql($line);
if ($this->file === null) {
$this->file = new \SplFileObject($this->path, 'a');
}
$this->file->fwrite($sql);
}
private function buildSql($line)
{
$line = array_map(function($value) {
$number = filter_var($value, FILTER_VALIDATE_INT);
if ($number !== false) {
return $number;
}
if (is_string($value)) {
if (strtolower($value) === 'null') {
return 'NULL';
}
if (strtolower($value) === 'true') {
return 'true';
}
if (strtolower($value) === 'false') {
return 'false';
}
return '"' . addslashes($value) . '"';
}
throw new \InvalidArgumentException('value is invalid: ' . var_export($value, 1));
}, $line);
return 'INSERT INTO ' . $this->table . '(' . join(', ', $this->columns) . ')' .
' VALUES(' . join(', ', $line) . ');';
}
}

View File

@ -0,0 +1,110 @@
<?php
namespace Goodby\CSV\Import\Standard\StreamFilter;
use php_user_filter;
use RuntimeException;
class ConvertMbstringEncoding extends php_user_filter
{
/**
* @var string
*/
const FILTER_NAMESPACE = 'convert.mbstring.encoding.';
/**
* @var bool
*/
private static $hasBeenRegistered = false;
/**
* @var string
*/
private $fromCharset;
/**
* @var string
*/
private $toCharset;
/**
* Return filter name
* @return string
*/
public static function getFilterName()
{
return self::FILTER_NAMESPACE.'*';
}
/**
* Register this class as a stream filter
* @throws \RuntimeException
*/
public static function register()
{
if ( self::$hasBeenRegistered === true ) {
return;
}
if ( stream_filter_register(self::getFilterName(), __CLASS__) === false ) {
throw new RuntimeException('Failed to register stream filter: '.self::getFilterName());
}
self::$hasBeenRegistered = true;
}
/**
* Return filter URL
* @param string $filename
* @param string $fromCharset
* @param string $toCharset
* @return string
*/
public static function getFilterURL($filename, $fromCharset, $toCharset = null)
{
if ( $toCharset === null ) {
return sprintf('php://filter/convert.mbstring.encoding.%s/resource=%s', $fromCharset, $filename);
} else {
return sprintf('php://filter/convert.mbstring.encoding.%s:%s/resource=%s', $fromCharset, $toCharset, $filename);
}
}
/**
* @return bool
*/
public function onCreate()
{
if ( strpos($this->filtername, self::FILTER_NAMESPACE) !== 0 ) {
return false;
}
$parameterString = substr($this->filtername, strlen(self::FILTER_NAMESPACE));
if ( ! preg_match('/^(?P<from>[-\w]+)(:(?P<to>[-\w]+))?$/', $parameterString, $matches) ) {
return false;
}
$this->fromCharset = isset($matches['from']) ? $matches['from'] : 'auto';
$this->toCharset = isset($matches['to']) ? $matches['to'] : mb_internal_encoding();
return true;
}
/**
* @param string $in
* @param string $out
* @param string $consumed
* @param $closing
* @return int
*/
public function filter($in, $out, &$consumed, $closing)
{
while ( $bucket = stream_bucket_make_writeable($in) ) {
$bucket->data = mb_convert_encoding($bucket->data, $this->toCharset, $this->fromCharset);
$consumed += $bucket->datalen;
stream_bucket_append($out, $bucket);
}
return PSFS_PASS_ON;
}
}

View File

@ -0,0 +1,42 @@
<?php
namespace Goodby\CSV\Import\Tests\Protocol;
use Goodby\CSV\Import\Protocol\Exception\InvalidLexicalException;
/**
* unit test for Interface of the Interpreter
*/
class InterpreterTest extends \PHPUnit_Framework_TestCase
{
public function testInterpreterInterface()
{
$line = array();
$interpreter = $this->getMock('\Goodby\CSV\Import\Protocol\InterpreterInterface');
$interpreter->expects($this->once())
->method('interpret')
->with($this->identicalTo($line))
;
$interpreter->interpret($line);
}
/**
* @expectedException \Goodby\CSV\Import\Protocol\Exception\InvalidLexicalException
*/
public function testInterpreterInterfaceWillThrownInvalidLexicalException()
{
$interpreter = $this->getMock('\Goodby\CSV\Import\Protocol\InterpreterInterface');
$interpreter->expects($this->once())
->method('interpret')
->will($this->throwException(new InvalidLexicalException()))
;
$line = "INVALID LEXICAL";
$interpreter->interpret($line);
}
}

View File

@ -0,0 +1,41 @@
<?php
namespace Goodby\CSV\Import\Tests\Protocol;
use Mockery as m;
/**
* unit test for CSV Lexer
*/
class LexerTest extends \PHPUnit_Framework_TestCase
{
public function testInterface()
{
$lexer = m::mock('\Goodby\CSV\Import\Protocol\LexerInterface');
$interpreter = m::mock('\Goodby\CSV\Import\Protocol\InterpreterInterface');
$path = 'dummy.csv';
$lexer->shouldReceive('parse')->with($path, $interpreter);
$lexer->parse($path, $interpreter);
}
/**
* @expectedException \Goodby\CSV\Import\Protocol\Exception\CsvFileNotFoundException
*/
public function testCsvFileNotFound()
{
$lexer = m::mock('\Goodby\CSV\Import\Protocol\LexerInterface');
$interpreter = m::mock('\Goodby\CSV\Import\Protocol\InterpreterInterface');
$path = 'invalid_dummy.csv';
$lexer->shouldReceive('parse')
->with($path, $interpreter)
->andThrow('Goodby\CSV\Import\Protocol\Exception\CsvFileNotFoundException')
;
$lexer->parse($path, $interpreter);
}
}

View File

@ -0,0 +1,69 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Join;
class CSVFiles
{
public static function getShiftJisCsv()
{
return __DIR__.'/csv_files/sjis.csv';
}
public static function getMacExcelCsv()
{
return __DIR__.'/csv_files/mac-excel.csv';
}
public static function getMacExcelLines()
{
return array(
array('a', 'b', 'c'),
array('d', 'e', 'f'),
);
}
public static function getTabSeparatedCsv()
{
return __DIR__.'/csv_files/tab-separated.csv';
}
public static function getTabSeparatedLines()
{
return array(
array('value1', 'value2', 'value3'),
array('value4', 'value5', 'value6'),
);
}
public static function getColonSeparatedCsv()
{
return __DIR__.'/csv_files/colon-separated.csv';
}
public static function getColonSeparatedLines()
{
return array(
array('value1', 'value2', 'value3'),
array('value4', 'value5', 'value6'),
);
}
public static function getUtf8Csv()
{
return __DIR__.'/csv_files/utf-8.csv';
}
public static function getUtf8Lines()
{
return array(
array('✔', '✔', '✔', '✔'),
array('★', '★', '★', '★'),
array('유', '니', '코', '드'),
);
}
public static function getIssue5CSV()
{
return __DIR__.'/csv_files/issue-5.csv';
}
}

View File

@ -0,0 +1,156 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Join;
use Mockery as m;
use Goodby\CSV\Import\Standard\Lexer;
use Goodby\CSV\Import\Standard\Interpreter;
use Goodby\CSV\Import\Standard\LexerConfig;
class LexerTest extends \PHPUnit_Framework_TestCase
{
public function test_shift_jis_CSV()
{
$shiftJisCsv = CSVFiles::getShiftJisCsv();
$lines = array(
array('あ', 'い', 'う', 'え', 'お'),
array('日本語', '日本語', '日本語', '日本語', '日本語'),
array('ぱ', 'ぴ', 'ぷ', 'ぺ', 'ぽ'),
array('"quoted"', "a'quote'", 'a, b and c', '', ''),
);
$interpreter = $this->getMock('Goodby\CSV\Import\Standard\Interpreter', array('interpret'));
$interpreter->expects($this->at(0))->method('interpret')->with($lines[0]);
$interpreter->expects($this->at(1))->method('interpret')->with($lines[1]);
$interpreter->expects($this->at(2))->method('interpret')->with($lines[2]);
$interpreter->expects($this->at(3))->method('interpret')->with($lines[3]);
$config = new LexerConfig();
$config->setToCharset('UTF-8')->setFromCharset('SJIS-win');
$lexer = new Lexer($config);
$lexer->parse($shiftJisCsv, $interpreter);
}
public function test_mac_excel_csv()
{
$csv = CSVFiles::getMacExcelCsv();
$lines = CSVFiles::getMacExcelLines();
$interpreter = $this->getMock('Goodby\CSV\Import\Standard\Interpreter', array('interpret'));
$interpreter->expects($this->at(0))->method('interpret')->with($lines[0]);
$interpreter->expects($this->at(1))->method('interpret')->with($lines[1]);
$config = new LexerConfig();
$lexer = new Lexer($config);
$lexer->parse($csv, $interpreter);
}
public function test_tab_separated_csv()
{
$csv = CSVFiles::getTabSeparatedCsv();
$lines = CSVFiles::getTabSeparatedLines();
$interpreter = $this->getMock('Goodby\CSV\Import\Standard\Interpreter', array('interpret'));
$interpreter->expects($this->at(0))->method('interpret')->with($lines[0]);
$interpreter->expects($this->at(1))->method('interpret')->with($lines[1]);
$config = new LexerConfig();
$config->setDelimiter("\t");
$lexer = new Lexer($config);
$lexer->parse($csv, $interpreter);
}
public function test_colon_separated_csv()
{
$csv = CSVFiles::getColonSeparatedCsv();
$lines = CSVFiles::getColonSeparatedLines();
$interpreter = $this->getMock('Goodby\CSV\Import\Standard\Interpreter', array('interpret'));
$interpreter->expects($this->at(0))->method('interpret')->with($lines[0]);
$interpreter->expects($this->at(1))->method('interpret')->with($lines[1]);
$config = new LexerConfig();
$config->setDelimiter(':');
$lexer = new Lexer($config);
$lexer->parse($csv, $interpreter);
}
public function test_utf8_csv()
{
$csv = CSVFiles::getUtf8Csv();
$lines = CSVFiles::getUtf8Lines();
$interpreter = $this->getMock('Goodby\CSV\Import\Standard\Interpreter', array('interpret'));
$interpreter->expects($this->at(0))->method('interpret')->with($lines[0]);
$interpreter->expects($this->at(1))->method('interpret')->with($lines[1]);
$config = new LexerConfig();
$lexer = new Lexer($config);
$lexer->parse($csv, $interpreter);
}
/**
* When import CSV file with data in Japanese (2 bytes character),
* data imported to database with error encoding
* @link https://github.com/goodby/csv/issues/5
*/
public function test_issue_5()
{
$csvFilename = CSVFiles::getIssue5CSV();
$csvContents = array();
$config = new LexerConfig();
$config
->setToCharset('UTF-8')
->setFromCharset('UTF-8');
$lexer = new Lexer($config);
$interpreter = new Interpreter();
$interpreter->addObserver(function(array $columns) use (&$csvContents) {
$csvContents[] = $columns;
});
$lexer->parse($csvFilename, $interpreter);
$this->assertSame(array(
array("ID", "NAME", "MAKER"),
array("1", "スティック型クリーナ", "alice_updated@example.com"),
array("2", "bob", "bob@example.com"),
array("14", "スティック型クリーナ", "tho@eample.com"),
array("16", "スティック型", "carot@eample.com"),
), $csvContents);
}
public function test_ignore_header()
{
$csvFilename = CSVFiles::getIssue5CSV();
$config = new LexerConfig();
$config
->setIgnoreHeaderLine(true)
->setToCharset('UTF-8')
->setFromCharset('UTF-8');
$lexer = new Lexer($config);
$interpreter = new Interpreter();
$interpreter->addObserver(function(array $columns) use (&$csvContents) {
$csvContents[] = $columns;
});
$lexer->parse($csvFilename, $interpreter);
$this->assertSame(array(
array("1", "スティック型クリーナ", "alice_updated@example.com"),
array("2", "bob", "bob@example.com"),
array("14", "スティック型クリーナ", "tho@eample.com"),
array("16", "スティック型", "carot@eample.com"),
), $csvContents);
}
public function test_instantiation_without_config()
{
$lexer = new Lexer();
$this->assertInstanceOf('Goodby\CSV\Import\Standard\Lexer', $lexer);
}
}

View File

@ -0,0 +1,86 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Join\Observer;
use Mockery as m;
use Goodby\CSV\Import\Standard\Interpreter;
use Goodby\CSV\Import\Standard\Observer\PdoObserver;
use Goodby\CSV\TestHelper\DbManager;
/**
* unit test for pdo observer
*/
class PdoObserverTest extends \PHPUnit_Framework_TestCase
{
/**
* @var \Goodby\CSV\TestHelper\DbManager
*/
private $manager = null;
public function setUp()
{
$this->manager = new DbManager();
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("CREATE TABLE test (id INT, name VARCHAR(32), age INT, flag TINYINT, flag2 TINYINT, status VARCHAR(32), contents TEXT)");
$stmt->execute();
}
public function tearDown()
{
unset($this->manager);
}
public function testUsage()
{
$interpreter = new Interpreter();
$table = 'test';
$dsn = $this->manager->getDsn();
$options = array('user' => $this->manager->getUser(), 'password' => $this->manager->getPassword());
$sqlObserver = new PdoObserver($table, array('id', 'name', 'age', 'flag', 'flag2', 'status', 'contents'), $dsn, $options);
$interpreter->addObserver(array($sqlObserver, 'notify'));
$interpreter->interpret(array('123', 'test', '28', 'true', 'false', 'null', 'test"test'));
$pdo = $this->manager->getPdo();
$stmt = $pdo->prepare("SELECT * FROM " . $table);
$stmt->execute();
$result = $stmt->fetch();
$this->assertEquals(123, $result[0]);
$this->assertEquals('test', $result[1]);
$this->assertEquals(28, $result[2]);
$this->assertEquals(1, $result[3]);
$this->assertEquals(0, $result[4]);
$this->assertEquals('NULL', $result[5]);
$this->assertEquals('test"test', $result[6]);
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage value is invalid: array
*/
public function testInvalidLine()
{
$interpreter = new Interpreter();
$table = 'test';
$options = array('user' => $this->manager->getUser(), 'password' => $this->manager->getPassword());
$sqlObserver = new PdoObserver($table, array('id', 'name'), $this->manager->getDsn(), $options);
$interpreter->addObserver(array($sqlObserver, 'notify'));
$interpreter->interpret(array('123', array('test', 'test')));
}
}

View File

@ -0,0 +1,2 @@
value1:value2:value3
value4:value5:value6
1 value1:value2:value3
2 value4:value5:value6

View File

@ -0,0 +1,5 @@
ID,NAME,MAKER
1,スティック型クリーナ,alice_updated@example.com
2,bob,bob@example.com
14,スティック型クリーナ,tho@eample.com
16,スティック型,carot@eample.com
1 ID NAME MAKER
2 1 スティック型クリーナ alice_updated@example.com
3 2 bob bob@example.com
4 14 スティック型クリーナ tho@eample.com
5 16 スティック型 carot@eample.com

View File

@ -0,0 +1 @@
a,b,c d,e,f
1 a b c d e f

View File

@ -0,0 +1,4 @@
あ,い,う,え,お
日本語,日本語,日本語,日本語,日本語
ぱ,ぴ,ぷ,ぺ,ぽ
"""quoted""",a'quote',"a, b and c",,
1
2 日本語 日本語 日本語 日本語 日本語
3
4 "quoted" a'quote' a, b and c

View File

@ -0,0 +1,7 @@
value1 value2 value3
value4 value5 value6
1 value1 value2 value3
2 value4 value5 value6

View File

@ -0,0 +1,3 @@
✔,✔,✔,✔
★,★,★,★
유,니,코,드
1
2
3

View File

@ -0,0 +1,45 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard;
/**
* Managing sandbox directory to use when joining with the file system for tests
*/
class SandboxDirectoryManager
{
/**
* Return sandbox directory
* @return string
*/
public static function getSandboxDirectory()
{
return sys_get_temp_dir().'/goodby/csv';
}
/**
* Reset sandbox directory
*/
public static function resetSandboxDirectory()
{
$sandboxDir = self::getSandboxDirectory();
if ( file_exists($sandboxDir) ) {
exec(sprintf('rm -rf %s', $sandboxDir));
}
if ( file_exists($sandboxDir) ) {
throw new \RuntimeException(
sprintf('Cannot continue test: sandbox directory already exists: %s', $sandboxDir)
);
}
mkdir($sandboxDir, 0777, true);
if ( file_exists($sandboxDir) === false ) {
throw new \RuntimeException(
sprintf('Cannot continue test: sandbox directory does not exist: %s', $sandboxDir)
);
}
}
}

View File

@ -0,0 +1,132 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Unit;
use Mockery as m;
use Goodby\CSV\Import\Standard\Interpreter;
/**
* unit test for Standard Implementation of the Interpreter
*
*/
class InterpreterTest extends \PHPUnit_Framework_TestCase
{
private $expectedLine;
public function setUp()
{
$this->expectedLine = null;
}
/**
* @requires PHP 5.4
*/
public function testStandardInterpreterWithClosure()
{
$this->expectedLine = array('test', 'test', 'test');
$interpreter = new Interpreter();
$interpreter->addObserver(function($line) {
$this->assertEquals($this->expectedLine, $line);
});
$interpreter->interpret($this->expectedLine);
}
public function testStandardInterpreterWithObject()
{
$this->expectedLine = array('test', 'test', 'test');
$object = m::mock('stdClass');
$object->shouldReceive('callback')->with($this->expectedLine)->once();
$interpreter = new Interpreter();
$interpreter->addObserver(array($object, 'callback'));
$interpreter->interpret($this->expectedLine);
}
/**
* @expectedException \Goodby\CSV\Import\Standard\Exception\StrictViolationException
*/
public function testInconsistentColumns()
{
$lines[] = array('test', 'test', 'test');
$lines[] = array('test', 'test');
$interpreter = new Interpreter();
foreach ($lines as $line) {
$interpreter->interpret($line);
}
}
/**
* @expectedException \Goodby\CSV\Import\Standard\Exception\StrictViolationException
*/
public function testInconsistentColumnsLowToHigh()
{
$lines[] = array('test', 'test');
$lines[] = array('test', 'test', 'test');
$interpreter = new Interpreter();
foreach ($lines as $line) {
$interpreter->interpret($line);
}
}
public function testConsistentColumns()
{
$lines[] = array('test', 'test', 'test');
$lines[] = array('test', 'test', 'test');
$interpreter = new Interpreter();
foreach ($lines as $line) {
$interpreter->interpret($line);
}
}
/**
* use un-strict won't throw exception with inconsistent columns
*
*/
public function testInconsistentColumnsWithUnStrict()
{
$lines[] = array('test', 'test', 'test');
$lines[] = array('test', 'test');
$interpreter = new Interpreter();
$interpreter->unstrict();
foreach ($lines as $line) {
$interpreter->interpret($line);
}
}
/**
* @expectedException \Goodby\CSV\Import\Protocol\Exception\InvalidLexicalException
*/
public function testStandardInterpreterWithInvalidLexical()
{
$this->expectedLine = '';
$interpreter = new Interpreter();
$interpreter->interpret($this->expectedLine);
}
/**
* @expectedException \InvalidArgumentException
*/
public function testInvalidCallable()
{
$interpreter = new Interpreter();
$interpreter->addObserver('dummy');
$interpreter->interpret($this->expectedLine);
}
}

View File

@ -0,0 +1,61 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Unit;
use SplFileObject;
use Goodby\CSV\Import\Standard\LexerConfig;
class LexerConfigTest extends \PHPUnit_Framework_TestCase
{
public function testDelimiter()
{
$config = new LexerConfig();
$this->assertSame(',', $config->getDelimiter());
$config->setDelimiter('del');
$this->assertSame('del', $config->getDelimiter());
}
public function testEnclosure()
{
$config = new LexerConfig();
$this->assertSame('"', $config->getEnclosure());
$this->assertSame('enc', $config->setEnclosure('enc')->getEnclosure());
}
public function testEscape()
{
$config = new LexerConfig();
$this->assertSame('\\', $config->getEscape());
$this->assertSame('esc', $config->setEscape('esc')->getEscape());
}
public function testFromCharset()
{
$config = new LexerConfig();
$this->assertSame(null, $config->getFromCharset());
$this->assertSame('UTF-8', $config->setFromCharset('UTF-8')->getFromCharset());
}
public function testToCharset()
{
$config = new LexerConfig();
$this->assertSame(null, $config->getToCharset());
$this->assertSame('UTF-8', $config->setToCharset('UTF-8')->getToCharset());
}
public function testFlags()
{
$config = new LexerConfig();
$this->assertSame(SplFileObject::READ_CSV, $config->getFlags());
$config->setFlags(SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY | SplFileObject::READ_CSV);
$flags = (SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY | SplFileObject::READ_CSV);
$this->assertSame($flags, $config->getFlags());
}
public function testIgnoreHeaderLine()
{
$config = new LexerConfig();
$this->assertSame(false, $config->getIgnoreHeaderLine());
$this->assertSame(true, $config->setIgnoreHeaderLine(true)->getIgnoreHeaderLine());
}
}

View File

@ -0,0 +1,51 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Unit\Observer;
use Mockery as m;
use Goodby\CSV\Import\Standard\Interpreter;
use Goodby\CSV\Import\Standard\Observer\SqlObserver;
/**
* unit test for sql observer
*/
class SqlObserverTest extends \PHPUnit_Framework_TestCase
{
public function testUsage()
{
$interpreter = new Interpreter();
$tempDir = sys_get_temp_dir();
$path = $tempDir . DIRECTORY_SEPARATOR . 'test.sql';
if (file_exists($path)) {
unlink($path);
}
$sqlObserver = new SqlObserver('test', array('id', 'name', 'age', 'flag', 'flag2', 'status', 'contents'), $path);
$interpreter->addObserver(array($sqlObserver, 'notify'));
$interpreter->interpret(array('123', 'test', '28', 'true', 'false', 'null', 'test"test'));
$expectedSql = 'INSERT INTO test(id, name, age, flag, flag2, status, contents) VALUES(123, "test", 28, true, false, NULL, "test\"test");';
$this->assertEquals($expectedSql, file_get_contents($path));
}
/**
* @expectedException \InvalidArgumentException
*/
public function testInvalidLine()
{
$interpreter = new Interpreter();
$sqlObserver = new SqlObserver('test', array('id', 'name'), 'dummy');
$interpreter->addObserver(array($sqlObserver, 'notify'));
$interpreter->interpret(array('123', array('test')));
}
}

View File

@ -0,0 +1,64 @@
<?php
namespace Goodby\CSV\Import\Tests\Standard\Unit\StreamFilter;
use Expose\Expose as e;
use Goodby\CSV\Import\Standard\StreamFilter\ConvertMbstringEncoding;
class ConvertMbstringEncodingTest extends \PHPUnit_Framework_TestCase
{
private $internalEncodingBackup;
public function setUp()
{
$this->internalEncodingBackup = mb_internal_encoding();
}
public function tearDown()
{
mb_internal_encoding($this->internalEncodingBackup);
}
public function testGetFilterName()
{
$this->assertSame('convert.mbstring.encoding.*', ConvertMbstringEncoding::getFilterName());
}
public function testOneParameter()
{
$filterString = 'convert.mbstring.encoding.EUC-JP';
mb_internal_encoding('UTF-7');
$filter = new ConvertMbstringEncoding();
$filter->filtername = $filterString;
$filter->onCreate();
$this->assertAttributeSame('EUC-JP', 'fromCharset', $filter);
$this->assertAttributeSame('UTF-7', 'toCharset', $filter);
}
public function testTwoParameters()
{
$filterString = 'convert.mbstring.encoding.SJIS-win:UTF-8';
mb_internal_encoding('UTF-7');
$filter = new ConvertMbstringEncoding();
$filter->filtername = $filterString;
$filter->onCreate();
$this->assertAttributeSame('SJIS-win', 'fromCharset', $filter);
$this->assertAttributeSame('UTF-8', 'toCharset', $filter);
}
public function test_when_invalid_parameter_given_it_returns_false()
{
$filterString = 'convert.mbstring.encoding.@#$#!%^^';
$filter = new ConvertMbstringEncoding();
$filter->filtername = $filterString;
$this->assertFalse($filter->onCreate());
}
public function test_register_filter()
{
ConvertMbstringEncoding::register();
$filterName = ConvertMbstringEncoding::getFilterName();
$registeredFilters = stream_get_filters();
$this->assertTrue(in_array($filterName, $registeredFilters));
}
}

View File

@ -0,0 +1,54 @@
<?php
namespace Goodby\CSV\TestHelper;
class DbManager
{
private $pdo;
private $host;
private $db;
private $user;
private $pass;
public function __construct()
{
$this->host = $_SERVER['GOODBY_CSV_TEST_DB_HOST'];
$this->db = $_SERVER['GOODBY_CSV_TEST_DB_NAME_DEFAULT'];
$this->user = $_SERVER['GOODBY_CSV_TEST_DB_USER'];
$this->pass = $_SERVER['GOODBY_CSV_TEST_DB_PASS'];
$dsn = 'mysql:host=' . $this->host;
$this->pdo = new \PDO($dsn, $this->user, $this->pass);
$stmt = $this->pdo->prepare("CREATE DATABASE " . $this->db);
$stmt->execute();
}
public function __destruct()
{
$stmt = $this->pdo->prepare("DROP DATABASE " . $this->db);
$stmt->execute();
}
public function getPdo()
{
return new \PDO($this->getDsn(), $this->user, $this->pass);
}
public function getDsn()
{
return 'mysql:dbname=' . $this->db . ';host=' . $this->host;
}
public function getUser()
{
return $this->user;
}
public function getPassword()
{
return $this->pass;
}
}

View File

@ -14,7 +14,7 @@ class PDO extends \PDO
if(empty($DSN))
{
$config_local = new Zend_Config(include $this->config_local_path);
$config_local = \Zend_Registry::get('config');
$dsn = "pgsql:host={$config_local->db->hostname};"
."port=5432;"
."dbname={$config_local->db->database};"

View File

@ -0,0 +1,40 @@
<?php
/**
* Created by PhpStorm.
* User: liujin834
* Date: 15-1-27
* Time: 下午2:37
*/
namespace Westdc\Dataimport;
abstract class AbstractProcessing {
/**
* 获取判断数据类型的函数
* @param $pgsql_data_type
* @param $data
* @return null|string
*/
public function checkFieldsDataType($pgsql_data_type,$data){
switch ($pgsql_data_type){
case "integer":
case "bigint":
case "int2vector":
case "real":
case "double precision":
return is_int($data) || is_float($data);
case "date":
case "char":
case "character varying":
return is_string($data);
default:
return FALSE;
}
}
}

View File

@ -0,0 +1,179 @@
<?php
namespace Westdc\Dataimport;
class File{
private $config;
function __construct($db = NULL)
{
$this->config = \Zend_Registry::get('config');
}
/**
* 獲取文件存儲目錄
* @return string
*/
private function getSavePath()
{
if(!preg_match("/(\\/|\\\)$/",$this->config->dataimport->path))
return $this->config->dataimport->path . DIRECTORY_SEPARATOR;
else
return $this->config->dataimport->path;
}
/**
* 上傳文件
* @param $file
* @return array
*/
public function upload($file)
{
try{
if (empty($file) !== false) {
return array("error"=>"请选择要上传的文件");
}
if (@is_uploaded_file($file['tmp_name']) === false) {
return array("error"=>"文件上传失败,请重新上传");
}
if($file['size'] > 20 * 1024 * 1024)
{
return array('error'=>"文件大小超出限制");
}
$ext = $this->getFileTextExt($file['name']);
$filename = $file['name']."_".$this->gen_uuid().".".$ext;
$new_filepath = $this->getSavePath().$filename;
if (move_uploaded_file($file['tmp_name'], $new_filepath) === false) {
return array("error"=>"上传失败,请重试");
}
return array(
"success" => 1,
"file"=>$filename
);
}catch(Exception $e)
{
return array("error"=>$e->getMessage());
}
}//upload()
/**
* 获取文件扩展名
* @param $file_name
* @return mixed|string
*/
public function getFileTextExt($file_name)
{
$temp_arr = explode(".", $file_name);
$file_ext = array_pop($temp_arr);
$file_ext = trim($file_ext);
$file_ext = strtolower($file_ext);
return $file_ext;
}
/**
* 獲取文件Mime
* @param $file_name
* @return mixed
*/
public function getFileMime($file_name)
{
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$filetype = finfo_file($finfo, $file_name) ; //文件mime类型
finfo_close($finfo);
return $filetype;
}
/**
* 生成文件名UUID
* @return string
*/
public function gen_uuid() {
return sprintf( '%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
// 32 bits for "time_low"
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ),
// 16 bits for "time_mid"
mt_rand( 0, 0xffff ),
// 16 bits for "time_hi_and_version",
// four most significant bits holds version number 4
mt_rand( 0, 0x0fff ) | 0x4000,
// 16 bits, 8 bits for "clk_seq_hi_res",
// 8 bits for "clk_seq_low",
// two most significant bits holds zero and one for variant DCE1.1
mt_rand( 0, 0x3fff ) | 0x8000,
// 48 bits for "node"
mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff ), mt_rand( 0, 0xffff )
);
}
/**
* 獲得已經上傳的文件
* @return array
*/
public function getUploadFiles()
{
return $this->fetchDir($this->getSavePath());
}
/**
* 掃描文件夾
* @param $directory
* @return array
*/
public function fetchDir($directory){
$mydir = dir($directory);
$files = [];
while($file = $mydir->read())
{
if($file == '.' || $file == "..")
continue;
if((is_dir("$directory/$file")) AND ($file!=".") AND ($file!=".."))
{
$files = array_merge($files,$this->fetchDir("$directory/$file"));
}
else
$files[] = $file;
}
$mydir->close();
return $files;
}
/**
* 刪除文件
* @param $file
* @return bool
*/
public function deleteFile($file)
{
if(empty($file))
return false;
return unlink($this->getSavePath() . $file);
}
/**
* 獲取文件真實路徑
* @param $file
* @return string
*/
public function getRealName($file)
{
return $this->getSavePath().$file;
}
}

View File

@ -0,0 +1,39 @@
<?php
/**
* Created by PhpStorm.
* User: liujin834
* Date: 15-1-27
* Time: 下午2:37
*/
namespace Westdc\Dataimport;
final class ProcessFactory {
protected static $instance = null;
private function __construct()
{
}
public static function Bootstrap($fileExt)
{
$namespace_root = "\\Westdc\\Dataimport\\Processing\\";
$recordType = ucfirst(strtolower($fileExt));
$_class = $namespace_root . $recordType;
if(!class_exists($_class))
throw new \RuntimeException("未知的数据文件");
if (self::$instance === null) {
self::$instance = new $_class;
}
return self::$instance;
}
}

View File

@ -0,0 +1,219 @@
<?php
/**
* Created by PhpStorm.
* User: liujin834
* Date: 15-1-27
* Time: 下午3:12
*/
namespace Westdc\Dataimport\Processing;
use Westdc\Dataimport\ProcessingInterface;
use Westdc\Dataimport\AbstractProcessing;
use Goodby\CSV as CSVOBJ;
use Helpers\PDO;
class Csv extends AbstractProcessing implements ProcessingInterface{
private $source_file;
private $csv_object;
private $csv_line_data;
const ERROR_INDEX_NOT_MATCHED = "值的个数于其它行不匹配";
const ERROR_INDEX_TYPE_DIFFERENT = "值的类型于上一行不同";
const ERROR_EMPTY_FILE = "文件是空的";
const ERROR_LINE_TITLE = "行:";
const ERROR_COLUMN_TITLE = "列:";
const ERROR_DATA_TYPE_NOT_MATCHED = "数据与数据库中的类型不匹配,不能进行导入";
/**
* 初始化
* @param $file
*/
public function init($file)
{
$this->source_file = $file;
$interpreter = new CSVOBJ\Import\Standard\Interpreter;
$interpreter->addObserver(function($columns){
foreach($columns as $k=>$v){
if(is_numeric($v))
$columns[$k] = $v+0;
}
$this->csv_line_data[] = $columns;
});
$lexer = new CSVOBJ\Import\Standard\Lexer(new CSVOBJ\Import\Standard\LexerConfig);
$lexer->parse($file,$interpreter);
$this->csv_object = $lexer;
}
/**
* 獲取總行數
* @return int
*/
public function getLineCount(){
return count($this->csv_line_data);
}//getLineCount()
/**
* 獲取文件大小
* @return int
*/
public function getSize(){
$size = filesize($this->source_file);
$type = array('Bytes','KB','MB','GB','TB');
for($i = 0; $size >= 1024; $i++)//单位每增大1024则单位数组向后移动一位表示相应的单位
{
$size/=1024;
}
return (floor($size*100)/100).$type[$i];//floor是取整函数为了防止出现一串的小数这里取了两位小数
}//getSize(){
/**
* 獲取文件類型
* @return mixed
*/
public function getType(){
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$filetype = finfo_file($finfo, $this->source_file) ; //文件mime类型
finfo_close($finfo);
return $filetype;
}//getType()
/**
* 獲取內容
* @return mixed
*/
public function getLines()
{
return $this->csv_line_data;
}//getLines()
/**
* @return mixed
*/
public function getHtmlTable()
{
return $this->csv_object->toHTML('table-csv-data with-header');
}//getTable()
/**
* 獲取CSV對象
* @return mixed
*/
public function getCsvObject()
{
return $this->csv_object;
}
/**
* 檢查文件內容是否規則
* @return array|bool
*/
public function checkRegularity()
{
$lines = $this->getLines();
$error_stack = [];
if(!is_array($lines) || count($lines) < 1)
return [self::ERROR_EMPTY_FILE];
foreach($lines as $k=>$v){
if($k < 1 || empty($v))
continue;
if(count($v) != count($lines[$k-1]))
{
$error_stack[] = self::ERROR_LINE_TITLE . ($k + 1) .":".self::ERROR_INDEX_NOT_MATCHED;
continue;
}
foreach($v as $vIndex => $item){
if(gettype($item) != gettype($lines[$k-1][$vIndex]))
{
$error_stack[] = self::ERROR_LINE_TITLE . ($k + 1) .":".self::ERROR_INDEX_TYPE_DIFFERENT;
}
}
}
if(count($error_stack) < 1)
return true;
else
return $error_stack;
}//checkRegularity()
/**
* 检查字段是否对应
* @param $fields
* @return array|bool
*/
public function checkTableField(array $fields)
{
$error_stack = [];
$first_line = $this->getLines()[0];
foreach($fields as $index => $field)
{
$func = $this->checkFieldsDataType($field['data_type'],$first_line[$index]);
if($func)
continue;
else
$error_stack[] = self::ERROR_COLUMN_TITLE . $index .":" . self::ERROR_DATA_TYPE_NOT_MATCHED;
}
if(count($error_stack) < 1)
return true;
else
return $error_stack;
}
public function import($table)
{
$config = \Zend_Registry::get('config');
$db = new PDO([
'host' => $config->visual_db->hostname,
'port' => $config->visual_db->port,
'db' => $config->visual_db->database,
'user' => $config->visual_db->username,
'pwd' => $config->visual_db->password
]);
$db->setAttribute(\PDO::ATTR_PERSISTENT,true);
$error_stack = [];
try{
$db->setAttribute(\PDO::ATTR_ERRMODE , \PDO::ERRMODE_EXCEPTION);
$db->beginTransaction();
$place_holder=[];
foreach($this->getLines()[0] as $v)
{
$place_holder[] = "?";
}
$sth = $db->prepare("INSERT INTO $table VALUES (".join(",",$place_holder).")");
foreach($this->getLines() as $line)
{
$sth->execute($line);
}
$db->commit();
}catch(\Exception $e){
$db->rollBack();
$error_stack[] = $e->getMessage();
return $error_stack;
}
return true;
}
}

View File

@ -0,0 +1,32 @@
<?php
/**
* Created by PhpStorm.
* User: liujin834
* Date: 15-1-27
* Time: 下午3:10
*/
namespace Westdc\Dataimport;
interface ProcessingInterface {
/**
* 初始化
* @param $file
*/
public function init($file);
/**
* 检查数据文件是否规整
* @return mixed
*/
public function checkRegularity();
/**
* 检查字段是否对应
* @param array $fields
* @return mixed
*/
public function checkTableField(array $fields);
}

View File

@ -16,21 +16,40 @@ class DataTableControl extends Database{
parent::__construct();
}
public function readTables()
{
$sql = "SELECT schemaname||'.'||tablename as tablename FROM pg_tables WHERE tableowner='gis' ORDER BY tablename ";
public function readSchema(){
$sql = "SELECT distinct(schemaname) FROM pg_tables WHERE tableowner='gis'";
$rs = $this->db->query($sql);
$row = $rs->fetchAll(\PDO::FETCH_COLUMN);
return $row;
$rows = $rs->fetchAll(\PDO::FETCH_ASSOC);
foreach($rows as $k=>$v)
{
yield $v['schemaname'];
}
}
public function readFields($tablename)
public function readTables($schema = NULL)
{
if(empty($schema))
{
$sql = "SELECT schemaname||'.'||tablename as tablename FROM pg_tables WHERE tableowner='gis' ORDER BY tablename ";
$rs = $this->db->query($sql);
$row = $rs->fetchAll(\PDO::FETCH_COLUMN);
return $row;
}
$sql = "SELECT tablename as tablename FROM pg_tables WHERE tableowner='gis' AND schemaname='".$schema."' ORDER BY tablename";
$rs = $this->db->query($sql);
return $rs->fetchAll(\PDO::FETCH_ASSOC);
}
public function readFields($tablename,$identity = "")
{
$st=explode('.',$tablename);
$sql = "select COLUMN_NAME from INFORMATION_SCHEMA.COLUMNS where table_schema='".$st[0]."' and TABLE_NAME='".$st[1]."'";
$sql = "select * from INFORMATION_SCHEMA.COLUMNS where table_schema='".$st[0]."' and TABLE_NAME='".$st[1]."'";
$rs = $this->db->query($sql);
return $rs->fetchAll(\PDO::FETCH_COLUMN);
return $rs->fetchAll(\PDO::FETCH_ASSOC);
}
}

View File

@ -0,0 +1,101 @@
/*
* jQuery File Upload Plugin Angular JS Example 1.2.1
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global window, angular */
(function () {
'use strict';
var isOnGitHub = window.location.hostname === 'blueimp.github.io',
url = isOnGitHub ? '//jquery-file-upload.appspot.com/' : 'server/php/';
angular.module('demo', [
'blueimp.fileupload'
])
.config([
'$httpProvider', 'fileUploadProvider',
function ($httpProvider, fileUploadProvider) {
delete $httpProvider.defaults.headers.common['X-Requested-With'];
fileUploadProvider.defaults.redirect = window.location.href.replace(
/\/[^\/]*$/,
'/cors/result.html?%s'
);
if (isOnGitHub) {
// Demo settings:
angular.extend(fileUploadProvider.defaults, {
// Enable image resizing, except for Android and Opera,
// which actually support image resizing, but fail to
// send Blob objects via XHR requests:
disableImageResize: /Android(?!.*Chrome)|Opera/
.test(window.navigator.userAgent),
maxFileSize: 5000000,
acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i
});
}
}
])
.controller('DemoFileUploadController', [
'$scope', '$http', '$filter', '$window',
function ($scope, $http) {
$scope.options = {
url: url
};
if (!isOnGitHub) {
$scope.loadingFiles = true;
$http.get(url)
.then(
function (response) {
$scope.loadingFiles = false;
$scope.queue = response.data.files || [];
},
function () {
$scope.loadingFiles = false;
}
);
}
}
])
.controller('FileDestroyController', [
'$scope', '$http',
function ($scope, $http) {
var file = $scope.file,
state;
if (file.url) {
file.$state = function () {
return state;
};
file.$destroy = function () {
state = 'pending';
return $http({
url: file.deleteUrl,
method: file.deleteType
}).then(
function () {
state = 'resolved';
$scope.clear(file);
},
function () {
state = 'rejected';
}
);
};
} else if (!file.$cancel && !file._index) {
file.$cancel = function () {
$scope.clear(file);
};
}
}
]);
}());

View File

@ -0,0 +1,120 @@
/*
* jQuery postMessage Transport Plugin 1.1.2
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2011, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* global define, require, window, document */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define(['jquery'], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(window.jQuery);
}
}(function ($) {
'use strict';
var counter = 0,
names = [
'accepts',
'cache',
'contents',
'contentType',
'crossDomain',
'data',
'dataType',
'headers',
'ifModified',
'mimeType',
'password',
'processData',
'timeout',
'traditional',
'type',
'url',
'username'
],
convert = function (p) {
return p;
};
$.ajaxSetup({
converters: {
'postmessage text': convert,
'postmessage json': convert,
'postmessage html': convert
}
});
$.ajaxTransport('postmessage', function (options) {
if (options.postMessage && window.postMessage) {
var iframe,
loc = $('<a>').prop('href', options.postMessage)[0],
target = loc.protocol + '//' + loc.host,
xhrUpload = options.xhr().upload;
return {
send: function (_, completeCallback) {
counter += 1;
var message = {
id: 'postmessage-transport-' + counter
},
eventName = 'message.' + message.id;
iframe = $(
'<iframe style="display:none;" src="' +
options.postMessage + '" name="' +
message.id + '"></iframe>'
).bind('load', function () {
$.each(names, function (i, name) {
message[name] = options[name];
});
message.dataType = message.dataType.replace('postmessage ', '');
$(window).bind(eventName, function (e) {
e = e.originalEvent;
var data = e.data,
ev;
if (e.origin === target && data.id === message.id) {
if (data.type === 'progress') {
ev = document.createEvent('Event');
ev.initEvent(data.type, false, true);
$.extend(ev, data);
xhrUpload.dispatchEvent(ev);
} else {
completeCallback(
data.status,
data.statusText,
{postmessage: data.result},
data.headers
);
iframe.remove();
$(window).unbind(eventName);
}
}
});
iframe[0].contentWindow.postMessage(
message,
target
);
}).appendTo(document.body);
},
abort: function () {
if (iframe) {
iframe.remove();
}
}
};
}
});
}));

View File

@ -0,0 +1,89 @@
/*
* jQuery XDomainRequest Transport Plugin 1.1.4
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2011, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*
* Based on Julian Aubourg's ajaxHooks xdr.js:
* https://github.com/jaubourg/ajaxHooks/
*/
/* global define, require, window, XDomainRequest */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define(['jquery'], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(window.jQuery);
}
}(function ($) {
'use strict';
if (window.XDomainRequest && !$.support.cors) {
$.ajaxTransport(function (s) {
if (s.crossDomain && s.async) {
if (s.timeout) {
s.xdrTimeout = s.timeout;
delete s.timeout;
}
var xdr;
return {
send: function (headers, completeCallback) {
var addParamChar = /\?/.test(s.url) ? '&' : '?';
function callback(status, statusText, responses, responseHeaders) {
xdr.onload = xdr.onerror = xdr.ontimeout = $.noop;
xdr = null;
completeCallback(status, statusText, responses, responseHeaders);
}
xdr = new XDomainRequest();
// XDomainRequest only supports GET and POST:
if (s.type === 'DELETE') {
s.url = s.url + addParamChar + '_method=DELETE';
s.type = 'POST';
} else if (s.type === 'PUT') {
s.url = s.url + addParamChar + '_method=PUT';
s.type = 'POST';
} else if (s.type === 'PATCH') {
s.url = s.url + addParamChar + '_method=PATCH';
s.type = 'POST';
}
xdr.open(s.type, s.url);
xdr.onload = function () {
callback(
200,
'OK',
{text: xdr.responseText},
'Content-Type: ' + xdr.contentType
);
};
xdr.onerror = function () {
callback(404, 'Not Found');
};
if (s.xdrTimeout) {
xdr.ontimeout = function () {
callback(0, 'timeout');
};
xdr.timeout = s.xdrTimeout;
}
xdr.send((s.hasContent && s.data) || null);
},
abort: function () {
if (xdr) {
xdr.onerror = $.noop();
xdr.abort();
}
}
};
}
});
}
}));

View File

@ -0,0 +1,21 @@
@charset "UTF-8";
/*
* jQuery File Upload Demo CSS Fixes for IE<9 1.0.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
.navigation {
list-style: none;
padding: 0;
margin: 1em 0;
}
.navigation li {
display: inline;
margin-right: 10px;
}

View File

@ -0,0 +1,67 @@
@charset "UTF-8";
/*
* jQuery File Upload Demo CSS 1.1.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
body {
max-width: 750px;
margin: 0 auto;
padding: 1em;
font-family: "Lucida Grande", "Lucida Sans Unicode", Arial, sans-serif;
font-size: 1em;
line-height: 1.4em;
background: #222;
color: #fff;
-webkit-text-size-adjust: 100%;
-ms-text-size-adjust: 100%;
}
a {
color: orange;
text-decoration: none;
}
img {
border: 0;
vertical-align: middle;
}
h1 {
line-height: 1em;
}
blockquote {
padding: 0 0 0 15px;
margin: 0 0 20px;
border-left: 5px solid #eee;
}
table {
width: 100%;
margin: 10px 0;
}
.fileupload-progress {
margin: 10px 0;
}
.fileupload-progress .progress-extended {
margin-top: 5px;
}
.error {
color: red;
}
@media (min-width: 481px) {
.navigation {
list-style: none;
padding: 0;
}
.navigation li {
display: inline-block;
}
.navigation li:not(:first-child):before {
content: "| ";
}
}

View File

@ -0,0 +1,22 @@
@charset "UTF-8";
/*
* jQuery File Upload Plugin NoScript CSS 1.2.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
.fileinput-button input {
position: static;
opacity: 1;
filter: none;
font-size: inherit;
direction: inherit;
}
.fileinput-button span {
display: none;
}

View File

@ -0,0 +1,17 @@
@charset "UTF-8";
/*
* jQuery File Upload UI Plugin NoScript CSS 8.8.5
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2012, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
.fileinput-button i,
.fileupload-buttonbar .delete,
.fileupload-buttonbar .toggle {
display: none;
}

View File

@ -0,0 +1,57 @@
@charset "UTF-8";
/*
* jQuery File Upload UI Plugin CSS 9.0.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2010, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
.fileupload-buttonbar .btn,
.fileupload-buttonbar .toggle {
margin-bottom: 5px;
}
.progress-animated .progress-bar,
.progress-animated .bar {
background: url("../img/progressbar.gif") !important;
filter: none;
}
.fileupload-process {
float: right;
display: none;
}
.fileupload-processing .fileupload-process,
.files .processing .preview {
display: block;
width: 32px;
height: 32px;
background: url("../img/loading.gif") center no-repeat;
background-size: contain;
}
.files audio,
.files video {
max-width: 300px;
}
@media (max-width: 767px) {
.fileupload-buttonbar .toggle,
.files .toggle,
.files .btn span {
display: none;
}
.files .name {
width: 80px;
word-wrap: break-word;
}
.files audio,
.files video {
max-width: 80px;
}
.files img,
.files canvas {
max-width: 100%;
}
}

View File

@ -0,0 +1,36 @@
@charset "UTF-8";
/*
* jQuery File Upload Plugin CSS 1.3.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
.fileinput-button {
position: relative;
overflow: hidden;
}
.fileinput-button input {
position: absolute;
top: 0;
right: 0;
margin: 0;
opacity: 0;
-ms-filter: 'alpha(opacity=0)';
font-size: 200px;
direction: ltr;
cursor: pointer;
}
/* Fixes for IE < 8 */
@media screen\9 {
.fileinput-button input {
filter: alpha(opacity=0);
font-size: 100%;
height: 100%;
}
}

View File

@ -0,0 +1,15 @@
@charset "UTF-8";
/*
* jQuery File Upload Plugin CSS Example 8.8.2
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
body {
padding-top: 60px;
}

View File

@ -0,0 +1,429 @@
/*
* jQuery File Upload AngularJS Plugin 2.2.0
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, angular */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'angular',
'./jquery.fileupload-image',
'./jquery.fileupload-audio',
'./jquery.fileupload-video',
'./jquery.fileupload-validate'
], factory);
} else {
factory();
}
}(function () {
'use strict';
angular.module('blueimp.fileupload', [])
// The fileUpload service provides configuration options
// for the fileUpload directive and default handlers for
// File Upload events:
.provider('fileUpload', function () {
var scopeEvalAsync = function (expression) {
var scope = angular.element(this)
.fileupload('option', 'scope');
// Schedule a new $digest cycle if not already inside of one
// and evaluate the given expression:
scope.$evalAsync(expression);
},
addFileMethods = function (scope, data) {
var files = data.files,
file = files[0];
angular.forEach(files, function (file, index) {
file._index = index;
file.$state = function () {
return data.state();
};
file.$processing = function () {
return data.processing();
};
file.$progress = function () {
return data.progress();
};
file.$response = function () {
return data.response();
};
});
file.$submit = function () {
if (!file.error) {
return data.submit();
}
};
file.$cancel = function () {
return data.abort();
};
},
$config;
$config = this.defaults = {
handleResponse: function (e, data) {
var files = data.result && data.result.files;
if (files) {
data.scope.replace(data.files, files);
} else if (data.errorThrown ||
data.textStatus === 'error') {
data.files[0].error = data.errorThrown ||
data.textStatus;
}
},
add: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var scope = data.scope,
filesCopy = [];
angular.forEach(data.files, function (file) {
filesCopy.push(file);
});
scope.$apply(function () {
addFileMethods(scope, data);
var method = scope.option('prependFiles') ?
'unshift' : 'push';
Array.prototype[method].apply(scope.queue, data.files);
});
data.process(function () {
return scope.process(data);
}).always(function () {
scope.$apply(function () {
addFileMethods(scope, data);
scope.replace(filesCopy, data.files);
});
}).then(function () {
if ((scope.option('autoUpload') ||
data.autoUpload) &&
data.autoUpload !== false) {
data.submit();
}
});
},
progress: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
data.scope.$apply();
},
done: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = this;
data.scope.$apply(function () {
data.handleResponse.call(that, e, data);
});
},
fail: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = this,
scope = data.scope;
if (data.errorThrown === 'abort') {
scope.clear(data.files);
return;
}
scope.$apply(function () {
data.handleResponse.call(that, e, data);
});
},
stop: scopeEvalAsync,
processstart: scopeEvalAsync,
processstop: scopeEvalAsync,
getNumberOfFiles: function () {
var scope = this.scope;
return scope.queue.length - scope.processing();
},
dataType: 'json',
autoUpload: false
};
this.$get = [
function () {
return {
defaults: $config
};
}
];
})
// Format byte numbers to readable presentations:
.provider('formatFileSizeFilter', function () {
var $config = {
// Byte units following the IEC format
// http://en.wikipedia.org/wiki/Kilobyte
units: [
{size: 1000000000, suffix: ' GB'},
{size: 1000000, suffix: ' MB'},
{size: 1000, suffix: ' KB'}
]
};
this.defaults = $config;
this.$get = function () {
return function (bytes) {
if (!angular.isNumber(bytes)) {
return '';
}
var unit = true,
i = 0,
prefix,
suffix;
while (unit) {
unit = $config.units[i];
prefix = unit.prefix || '';
suffix = unit.suffix || '';
if (i === $config.units.length - 1 || bytes >= unit.size) {
return prefix + (bytes / unit.size).toFixed(2) + suffix;
}
i += 1;
}
};
};
})
// The FileUploadController initializes the fileupload widget and
// provides scope methods to control the File Upload functionality:
.controller('FileUploadController', [
'$scope', '$element', '$attrs', '$window', 'fileUpload',
function ($scope, $element, $attrs, $window, fileUpload) {
var uploadMethods = {
progress: function () {
return $element.fileupload('progress');
},
active: function () {
return $element.fileupload('active');
},
option: function (option, data) {
if (arguments.length === 1) {
return $element.fileupload('option', option);
}
$element.fileupload('option', option, data);
},
add: function (data) {
return $element.fileupload('add', data);
},
send: function (data) {
return $element.fileupload('send', data);
},
process: function (data) {
return $element.fileupload('process', data);
},
processing: function (data) {
return $element.fileupload('processing', data);
}
};
$scope.disabled = !$window.jQuery.support.fileInput;
$scope.queue = $scope.queue || [];
$scope.clear = function (files) {
var queue = this.queue,
i = queue.length,
file = files,
length = 1;
if (angular.isArray(files)) {
file = files[0];
length = files.length;
}
while (i) {
i -= 1;
if (queue[i] === file) {
return queue.splice(i, length);
}
}
};
$scope.replace = function (oldFiles, newFiles) {
var queue = this.queue,
file = oldFiles[0],
i,
j;
for (i = 0; i < queue.length; i += 1) {
if (queue[i] === file) {
for (j = 0; j < newFiles.length; j += 1) {
queue[i + j] = newFiles[j];
}
return;
}
}
};
$scope.applyOnQueue = function (method) {
var list = this.queue.slice(0),
i,
file;
for (i = 0; i < list.length; i += 1) {
file = list[i];
if (file[method]) {
file[method]();
}
}
};
$scope.submit = function () {
this.applyOnQueue('$submit');
};
$scope.cancel = function () {
this.applyOnQueue('$cancel');
};
// Add upload methods to the scope:
angular.extend($scope, uploadMethods);
// The fileupload widget will initialize with
// the options provided via "data-"-parameters,
// as well as those given via options object:
$element.fileupload(angular.extend(
{scope: $scope},
fileUpload.defaults
)).on('fileuploadadd', function (e, data) {
data.scope = $scope;
}).on('fileuploadfail', function (e, data) {
if (data.errorThrown === 'abort') {
return;
}
if (data.dataType &&
data.dataType.indexOf('json') === data.dataType.length - 4) {
try {
data.result = angular.fromJson(data.jqXHR.responseText);
} catch (ignore) {}
}
}).on([
'fileuploadadd',
'fileuploadsubmit',
'fileuploadsend',
'fileuploaddone',
'fileuploadfail',
'fileuploadalways',
'fileuploadprogress',
'fileuploadprogressall',
'fileuploadstart',
'fileuploadstop',
'fileuploadchange',
'fileuploadpaste',
'fileuploaddrop',
'fileuploaddragover',
'fileuploadchunksend',
'fileuploadchunkdone',
'fileuploadchunkfail',
'fileuploadchunkalways',
'fileuploadprocessstart',
'fileuploadprocess',
'fileuploadprocessdone',
'fileuploadprocessfail',
'fileuploadprocessalways',
'fileuploadprocessstop'
].join(' '), function (e, data) {
if ($scope.$emit(e.type, data).defaultPrevented) {
e.preventDefault();
}
}).on('remove', function () {
// Remove upload methods from the scope,
// when the widget is removed:
var method;
for (method in uploadMethods) {
if (uploadMethods.hasOwnProperty(method)) {
delete $scope[method];
}
}
});
// Observe option changes:
$scope.$watch(
$attrs.fileUpload,
function (newOptions) {
if (newOptions) {
$element.fileupload('option', newOptions);
}
}
);
}
])
// Provide File Upload progress feedback:
.controller('FileUploadProgressController', [
'$scope', '$attrs', '$parse',
function ($scope, $attrs, $parse) {
var fn = $parse($attrs.fileUploadProgress),
update = function () {
var progress = fn($scope);
if (!progress || !progress.total) {
return;
}
$scope.num = Math.floor(
progress.loaded / progress.total * 100
);
};
update();
$scope.$watch(
$attrs.fileUploadProgress + '.loaded',
function (newValue, oldValue) {
if (newValue !== oldValue) {
update();
}
}
);
}
])
// Display File Upload previews:
.controller('FileUploadPreviewController', [
'$scope', '$element', '$attrs',
function ($scope, $element, $attrs) {
$scope.$watch(
$attrs.fileUploadPreview + '.preview',
function (preview) {
$element.empty();
if (preview) {
$element.append(preview);
}
}
);
}
])
.directive('fileUpload', function () {
return {
controller: 'FileUploadController',
scope: true
};
})
.directive('fileUploadProgress', function () {
return {
controller: 'FileUploadProgressController',
scope: true
};
})
.directive('fileUploadPreview', function () {
return {
controller: 'FileUploadPreviewController'
};
})
// Enhance the HTML5 download attribute to
// allow drag&drop of files to the desktop:
.directive('download', function () {
return function (scope, elm) {
elm.on('dragstart', function (e) {
try {
e.originalEvent.dataTransfer.setData(
'DownloadURL',
[
'application/octet-stream',
elm.prop('download'),
elm.prop('href')
].join(':')
);
} catch (ignore) {}
});
};
});
}));

View File

@ -0,0 +1,112 @@
/*
* jQuery File Upload Audio Preview Plugin 1.0.4
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window, document */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'load-image',
'./jquery.fileupload-process'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(
require('jquery'),
require('load-image')
);
} else {
// Browser globals:
factory(
window.jQuery,
window.loadImage
);
}
}(function ($, loadImage) {
'use strict';
// Prepend to the default processQueue:
$.blueimp.fileupload.prototype.options.processQueue.unshift(
{
action: 'loadAudio',
// Use the action as prefix for the "@" options:
prefix: true,
fileTypes: '@',
maxFileSize: '@',
disabled: '@disableAudioPreview'
},
{
action: 'setAudio',
name: '@audioPreviewName',
disabled: '@disableAudioPreview'
}
);
// The File Upload Audio Preview plugin extends the fileupload widget
// with audio preview functionality:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
// The regular expression for the types of audio files to load,
// matched against the file type:
loadAudioFileTypes: /^audio\/.*$/
},
_audioElement: document.createElement('audio'),
processActions: {
// Loads the audio file given via data.files and data.index
// as audio element if the browser supports playing it.
// Accepts the options fileTypes (regular expression)
// and maxFileSize (integer) to limit the files to load:
loadAudio: function (data, options) {
if (options.disabled) {
return data;
}
var file = data.files[data.index],
url,
audio;
if (this._audioElement.canPlayType &&
this._audioElement.canPlayType(file.type) &&
($.type(options.maxFileSize) !== 'number' ||
file.size <= options.maxFileSize) &&
(!options.fileTypes ||
options.fileTypes.test(file.type))) {
url = loadImage.createObjectURL(file);
if (url) {
audio = this._audioElement.cloneNode(false);
audio.src = url;
audio.controls = true;
data.audio = audio;
return data;
}
}
return data;
},
// Sets the audio element as a property of the file object:
setAudio: function (data, options) {
if (data.audio && !options.disabled) {
data.files[data.index][options.name || 'preview'] = data.audio;
}
return data;
}
}
});
}));

View File

@ -0,0 +1,321 @@
/*
* jQuery File Upload Image Preview & Resize Plugin 1.7.3
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window, Blob */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'load-image',
'load-image-meta',
'load-image-exif',
'load-image-ios',
'canvas-to-blob',
'./jquery.fileupload-process'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(
require('jquery'),
require('load-image')
);
} else {
// Browser globals:
factory(
window.jQuery,
window.loadImage
);
}
}(function ($, loadImage) {
'use strict';
// Prepend to the default processQueue:
$.blueimp.fileupload.prototype.options.processQueue.unshift(
{
action: 'loadImageMetaData',
disableImageHead: '@',
disableExif: '@',
disableExifThumbnail: '@',
disableExifSub: '@',
disableExifGps: '@',
disabled: '@disableImageMetaDataLoad'
},
{
action: 'loadImage',
// Use the action as prefix for the "@" options:
prefix: true,
fileTypes: '@',
maxFileSize: '@',
noRevoke: '@',
disabled: '@disableImageLoad'
},
{
action: 'resizeImage',
// Use "image" as prefix for the "@" options:
prefix: 'image',
maxWidth: '@',
maxHeight: '@',
minWidth: '@',
minHeight: '@',
crop: '@',
orientation: '@',
forceResize: '@',
disabled: '@disableImageResize'
},
{
action: 'saveImage',
quality: '@imageQuality',
type: '@imageType',
disabled: '@disableImageResize'
},
{
action: 'saveImageMetaData',
disabled: '@disableImageMetaDataSave'
},
{
action: 'resizeImage',
// Use "preview" as prefix for the "@" options:
prefix: 'preview',
maxWidth: '@',
maxHeight: '@',
minWidth: '@',
minHeight: '@',
crop: '@',
orientation: '@',
thumbnail: '@',
canvas: '@',
disabled: '@disableImagePreview'
},
{
action: 'setImage',
name: '@imagePreviewName',
disabled: '@disableImagePreview'
},
{
action: 'deleteImageReferences',
disabled: '@disableImageReferencesDeletion'
}
);
// The File Upload Resize plugin extends the fileupload widget
// with image resize functionality:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
// The regular expression for the types of images to load:
// matched against the file type:
loadImageFileTypes: /^image\/(gif|jpeg|png|svg\+xml)$/,
// The maximum file size of images to load:
loadImageMaxFileSize: 10000000, // 10MB
// The maximum width of resized images:
imageMaxWidth: 1920,
// The maximum height of resized images:
imageMaxHeight: 1080,
// Defines the image orientation (1-8) or takes the orientation
// value from Exif data if set to true:
imageOrientation: false,
// Define if resized images should be cropped or only scaled:
imageCrop: false,
// Disable the resize image functionality by default:
disableImageResize: true,
// The maximum width of the preview images:
previewMaxWidth: 80,
// The maximum height of the preview images:
previewMaxHeight: 80,
// Defines the preview orientation (1-8) or takes the orientation
// value from Exif data if set to true:
previewOrientation: true,
// Create the preview using the Exif data thumbnail:
previewThumbnail: true,
// Define if preview images should be cropped or only scaled:
previewCrop: false,
// Define if preview images should be resized as canvas elements:
previewCanvas: true
},
processActions: {
// Loads the image given via data.files and data.index
// as img element, if the browser supports the File API.
// Accepts the options fileTypes (regular expression)
// and maxFileSize (integer) to limit the files to load:
loadImage: function (data, options) {
if (options.disabled) {
return data;
}
var that = this,
file = data.files[data.index],
dfd = $.Deferred();
if (($.type(options.maxFileSize) === 'number' &&
file.size > options.maxFileSize) ||
(options.fileTypes &&
!options.fileTypes.test(file.type)) ||
!loadImage(
file,
function (img) {
if (img.src) {
data.img = img;
}
dfd.resolveWith(that, [data]);
},
options
)) {
return data;
}
return dfd.promise();
},
// Resizes the image given as data.canvas or data.img
// and updates data.canvas or data.img with the resized image.
// Also stores the resized image as preview property.
// Accepts the options maxWidth, maxHeight, minWidth,
// minHeight, canvas and crop:
resizeImage: function (data, options) {
if (options.disabled || !(data.canvas || data.img)) {
return data;
}
options = $.extend({canvas: true}, options);
var that = this,
dfd = $.Deferred(),
img = (options.canvas && data.canvas) || data.img,
resolve = function (newImg) {
if (newImg && (newImg.width !== img.width ||
newImg.height !== img.height ||
options.forceResize)) {
data[newImg.getContext ? 'canvas' : 'img'] = newImg;
}
data.preview = newImg;
dfd.resolveWith(that, [data]);
},
thumbnail;
if (data.exif) {
if (options.orientation === true) {
options.orientation = data.exif.get('Orientation');
}
if (options.thumbnail) {
thumbnail = data.exif.get('Thumbnail');
if (thumbnail) {
loadImage(thumbnail, resolve, options);
return dfd.promise();
}
}
// Prevent orienting the same image twice:
if (data.orientation) {
delete options.orientation;
} else {
data.orientation = options.orientation;
}
}
if (img) {
resolve(loadImage.scale(img, options));
return dfd.promise();
}
return data;
},
// Saves the processed image given as data.canvas
// inplace at data.index of data.files:
saveImage: function (data, options) {
if (!data.canvas || options.disabled) {
return data;
}
var that = this,
file = data.files[data.index],
dfd = $.Deferred();
if (data.canvas.toBlob) {
data.canvas.toBlob(
function (blob) {
if (!blob.name) {
if (file.type === blob.type) {
blob.name = file.name;
} else if (file.name) {
blob.name = file.name.replace(
/\..+$/,
'.' + blob.type.substr(6)
);
}
}
// Don't restore invalid meta data:
if (file.type !== blob.type) {
delete data.imageHead;
}
// Store the created blob at the position
// of the original file in the files list:
data.files[data.index] = blob;
dfd.resolveWith(that, [data]);
},
options.type || file.type,
options.quality
);
} else {
return data;
}
return dfd.promise();
},
loadImageMetaData: function (data, options) {
if (options.disabled) {
return data;
}
var that = this,
dfd = $.Deferred();
loadImage.parseMetaData(data.files[data.index], function (result) {
$.extend(data, result);
dfd.resolveWith(that, [data]);
}, options);
return dfd.promise();
},
saveImageMetaData: function (data, options) {
if (!(data.imageHead && data.canvas &&
data.canvas.toBlob && !options.disabled)) {
return data;
}
var file = data.files[data.index],
blob = new Blob([
data.imageHead,
// Resized images always have a head size of 20 bytes,
// including the JPEG marker and a minimal JFIF header:
this._blobSlice.call(file, 20)
], {type: file.type});
blob.name = file.name;
data.files[data.index] = blob;
return data;
},
// Sets the resized version of the image as a property of the
// file object, must be called after "saveImage":
setImage: function (data, options) {
if (data.preview && !options.disabled) {
data.files[data.index][options.name || 'preview'] = data.preview;
}
return data;
},
deleteImageReferences: function (data, options) {
if (!options.disabled) {
delete data.img;
delete data.canvas;
delete data.preview;
delete data.imageHead;
}
return data;
}
}
});
}));

View File

@ -0,0 +1,155 @@
/*
* jQuery File Upload jQuery UI Plugin 8.7.2
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define(['jquery', './jquery.fileupload-ui'], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(window.jQuery);
}
}(function ($) {
'use strict';
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
processdone: function (e, data) {
data.context.find('.start').button('enable');
},
progress: function (e, data) {
if (data.context) {
data.context.find('.progress').progressbar(
'option',
'value',
parseInt(data.loaded / data.total * 100, 10)
);
}
},
progressall: function (e, data) {
var $this = $(this);
$this.find('.fileupload-progress')
.find('.progress').progressbar(
'option',
'value',
parseInt(data.loaded / data.total * 100, 10)
).end()
.find('.progress-extended').each(function () {
$(this).html(
($this.data('blueimp-fileupload') ||
$this.data('fileupload'))
._renderExtendedProgress(data)
);
});
}
},
_renderUpload: function (func, files) {
var node = this._super(func, files),
showIconText = $(window).width() > 480;
node.find('.progress').empty().progressbar();
node.find('.start').button({
icons: {primary: 'ui-icon-circle-arrow-e'},
text: showIconText
});
node.find('.cancel').button({
icons: {primary: 'ui-icon-cancel'},
text: showIconText
});
if (node.hasClass('fade')) {
node.hide();
}
return node;
},
_renderDownload: function (func, files) {
var node = this._super(func, files),
showIconText = $(window).width() > 480;
node.find('.delete').button({
icons: {primary: 'ui-icon-trash'},
text: showIconText
});
if (node.hasClass('fade')) {
node.hide();
}
return node;
},
_startHandler: function (e) {
$(e.currentTarget).button('disable');
this._super(e);
},
_transition: function (node) {
var deferred = $.Deferred();
if (node.hasClass('fade')) {
node.fadeToggle(
this.options.transitionDuration,
this.options.transitionEasing,
function () {
deferred.resolveWith(node);
}
);
} else {
deferred.resolveWith(node);
}
return deferred;
},
_create: function () {
this._super();
this.element
.find('.fileupload-buttonbar')
.find('.fileinput-button').each(function () {
var input = $(this).find('input:file').detach();
$(this)
.button({icons: {primary: 'ui-icon-plusthick'}})
.append(input);
})
.end().find('.start')
.button({icons: {primary: 'ui-icon-circle-arrow-e'}})
.end().find('.cancel')
.button({icons: {primary: 'ui-icon-cancel'}})
.end().find('.delete')
.button({icons: {primary: 'ui-icon-trash'}})
.end().find('.progress').progressbar();
},
_destroy: function () {
this.element
.find('.fileupload-buttonbar')
.find('.fileinput-button').each(function () {
var input = $(this).find('input:file').detach();
$(this)
.button('destroy')
.append(input);
})
.end().find('.start')
.button('destroy')
.end().find('.cancel')
.button('destroy')
.end().find('.delete')
.button('destroy')
.end().find('.progress').progressbar('destroy');
this._super();
}
});
}));

View File

@ -0,0 +1,175 @@
/*
* jQuery File Upload Processing Plugin 1.3.1
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2012, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'./jquery.fileupload'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(
window.jQuery
);
}
}(function ($) {
'use strict';
var originalAdd = $.blueimp.fileupload.prototype.options.add;
// The File Upload Processing plugin extends the fileupload widget
// with file processing functionality:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
// The list of processing actions:
processQueue: [
/*
{
action: 'log',
type: 'debug'
}
*/
],
add: function (e, data) {
var $this = $(this);
data.process(function () {
return $this.fileupload('process', data);
});
originalAdd.call(this, e, data);
}
},
processActions: {
/*
log: function (data, options) {
console[options.type](
'Processing "' + data.files[data.index].name + '"'
);
}
*/
},
_processFile: function (data, originalData) {
var that = this,
dfd = $.Deferred().resolveWith(that, [data]),
chain = dfd.promise();
this._trigger('process', null, data);
$.each(data.processQueue, function (i, settings) {
var func = function (data) {
if (originalData.errorThrown) {
return $.Deferred()
.rejectWith(that, [originalData]).promise();
}
return that.processActions[settings.action].call(
that,
data,
settings
);
};
chain = chain.pipe(func, settings.always && func);
});
chain
.done(function () {
that._trigger('processdone', null, data);
that._trigger('processalways', null, data);
})
.fail(function () {
that._trigger('processfail', null, data);
that._trigger('processalways', null, data);
});
return chain;
},
// Replaces the settings of each processQueue item that
// are strings starting with an "@", using the remaining
// substring as key for the option map,
// e.g. "@autoUpload" is replaced with options.autoUpload:
_transformProcessQueue: function (options) {
var processQueue = [];
$.each(options.processQueue, function () {
var settings = {},
action = this.action,
prefix = this.prefix === true ? action : this.prefix;
$.each(this, function (key, value) {
if ($.type(value) === 'string' &&
value.charAt(0) === '@') {
settings[key] = options[
value.slice(1) || (prefix ? prefix +
key.charAt(0).toUpperCase() + key.slice(1) : key)
];
} else {
settings[key] = value;
}
});
processQueue.push(settings);
});
options.processQueue = processQueue;
},
// Returns the number of files currently in the processsing queue:
processing: function () {
return this._processing;
},
// Processes the files given as files property of the data parameter,
// returns a Promise object that allows to bind callbacks:
process: function (data) {
var that = this,
options = $.extend({}, this.options, data);
if (options.processQueue && options.processQueue.length) {
this._transformProcessQueue(options);
if (this._processing === 0) {
this._trigger('processstart');
}
$.each(data.files, function (index) {
var opts = index ? $.extend({}, options) : options,
func = function () {
if (data.errorThrown) {
return $.Deferred()
.rejectWith(that, [data]).promise();
}
return that._processFile(opts, data);
};
opts.index = index;
that._processing += 1;
that._processingQueue = that._processingQueue.pipe(func, func)
.always(function () {
that._processing -= 1;
if (that._processing === 0) {
that._trigger('processstop');
}
});
});
}
return this._processingQueue;
},
_create: function () {
this._super();
this._processing = 0;
this._processingQueue = $.Deferred().resolveWith(this)
.promise();
}
});
}));

View File

@ -0,0 +1,710 @@
/*
* jQuery File Upload User Interface Plugin 9.6.1
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2010, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'tmpl',
'./jquery.fileupload-image',
'./jquery.fileupload-audio',
'./jquery.fileupload-video',
'./jquery.fileupload-validate'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(
require('jquery'),
require('tmpl')
);
} else {
// Browser globals:
factory(
window.jQuery,
window.tmpl
);
}
}(function ($, tmpl) {
'use strict';
$.blueimp.fileupload.prototype._specialOptions.push(
'filesContainer',
'uploadTemplateId',
'downloadTemplateId'
);
// The UI version extends the file upload widget
// and adds complete user interface interaction:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
// By default, files added to the widget are uploaded as soon
// as the user clicks on the start buttons. To enable automatic
// uploads, set the following option to true:
autoUpload: false,
// The ID of the upload template:
uploadTemplateId: 'template-upload',
// The ID of the download template:
downloadTemplateId: 'template-download',
// The container for the list of files. If undefined, it is set to
// an element with class "files" inside of the widget element:
filesContainer: undefined,
// By default, files are appended to the files container.
// Set the following option to true, to prepend files instead:
prependFiles: false,
// The expected data type of the upload response, sets the dataType
// option of the $.ajax upload requests:
dataType: 'json',
// Error and info messages:
messages: {
unknownError: 'Unknown error'
},
// Function returning the current number of files,
// used by the maxNumberOfFiles validation:
getNumberOfFiles: function () {
return this.filesContainer.children()
.not('.processing').length;
},
// Callback to retrieve the list of files from the server response:
getFilesFromResponse: function (data) {
if (data.result && $.isArray(data.result.files)) {
return data.result.files;
}
return [];
},
// The add callback is invoked as soon as files are added to the fileupload
// widget (via file input selection, drag & drop or add API call).
// See the basic file upload widget for more information:
add: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var $this = $(this),
that = $this.data('blueimp-fileupload') ||
$this.data('fileupload'),
options = that.options;
data.context = that._renderUpload(data.files)
.data('data', data)
.addClass('processing');
options.filesContainer[
options.prependFiles ? 'prepend' : 'append'
](data.context);
that._forceReflow(data.context);
that._transition(data.context);
data.process(function () {
return $this.fileupload('process', data);
}).always(function () {
data.context.each(function (index) {
$(this).find('.size').text(
that._formatFileSize(data.files[index].size)
);
}).removeClass('processing');
that._renderPreviews(data);
}).done(function () {
data.context.find('.start').prop('disabled', false);
if ((that._trigger('added', e, data) !== false) &&
(options.autoUpload || data.autoUpload) &&
data.autoUpload !== false) {
data.submit();
}
}).fail(function () {
if (data.files.error) {
data.context.each(function (index) {
var error = data.files[index].error;
if (error) {
$(this).find('.error').text(error);
}
});
}
});
},
// Callback for the start of each file upload request:
send: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload');
if (data.context && data.dataType &&
data.dataType.substr(0, 6) === 'iframe') {
// Iframe Transport does not support progress events.
// In lack of an indeterminate progress bar, we set
// the progress to 100%, showing the full animated bar:
data.context
.find('.progress').addClass(
!$.support.transition && 'progress-animated'
)
.attr('aria-valuenow', 100)
.children().first().css(
'width',
'100%'
);
}
return that._trigger('sent', e, data);
},
// Callback for successful uploads:
done: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload'),
getFilesFromResponse = data.getFilesFromResponse ||
that.options.getFilesFromResponse,
files = getFilesFromResponse(data),
template,
deferred;
if (data.context) {
data.context.each(function (index) {
var file = files[index] ||
{error: 'Empty file upload result'};
deferred = that._addFinishedDeferreds();
that._transition($(this)).done(
function () {
var node = $(this);
template = that._renderDownload([file])
.replaceAll(node);
that._forceReflow(template);
that._transition(template).done(
function () {
data.context = $(this);
that._trigger('completed', e, data);
that._trigger('finished', e, data);
deferred.resolve();
}
);
}
);
});
} else {
template = that._renderDownload(files)[
that.options.prependFiles ? 'prependTo' : 'appendTo'
](that.options.filesContainer);
that._forceReflow(template);
deferred = that._addFinishedDeferreds();
that._transition(template).done(
function () {
data.context = $(this);
that._trigger('completed', e, data);
that._trigger('finished', e, data);
deferred.resolve();
}
);
}
},
// Callback for failed (abort or error) uploads:
fail: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload'),
template,
deferred;
if (data.context) {
data.context.each(function (index) {
if (data.errorThrown !== 'abort') {
var file = data.files[index];
file.error = file.error || data.errorThrown ||
data.i18n('unknownError');
deferred = that._addFinishedDeferreds();
that._transition($(this)).done(
function () {
var node = $(this);
template = that._renderDownload([file])
.replaceAll(node);
that._forceReflow(template);
that._transition(template).done(
function () {
data.context = $(this);
that._trigger('failed', e, data);
that._trigger('finished', e, data);
deferred.resolve();
}
);
}
);
} else {
deferred = that._addFinishedDeferreds();
that._transition($(this)).done(
function () {
$(this).remove();
that._trigger('failed', e, data);
that._trigger('finished', e, data);
deferred.resolve();
}
);
}
});
} else if (data.errorThrown !== 'abort') {
data.context = that._renderUpload(data.files)[
that.options.prependFiles ? 'prependTo' : 'appendTo'
](that.options.filesContainer)
.data('data', data);
that._forceReflow(data.context);
deferred = that._addFinishedDeferreds();
that._transition(data.context).done(
function () {
data.context = $(this);
that._trigger('failed', e, data);
that._trigger('finished', e, data);
deferred.resolve();
}
);
} else {
that._trigger('failed', e, data);
that._trigger('finished', e, data);
that._addFinishedDeferreds().resolve();
}
},
// Callback for upload progress events:
progress: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var progress = Math.floor(data.loaded / data.total * 100);
if (data.context) {
data.context.each(function () {
$(this).find('.progress')
.attr('aria-valuenow', progress)
.children().first().css(
'width',
progress + '%'
);
});
}
},
// Callback for global upload progress events:
progressall: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var $this = $(this),
progress = Math.floor(data.loaded / data.total * 100),
globalProgressNode = $this.find('.fileupload-progress'),
extendedProgressNode = globalProgressNode
.find('.progress-extended');
if (extendedProgressNode.length) {
extendedProgressNode.html(
($this.data('blueimp-fileupload') || $this.data('fileupload'))
._renderExtendedProgress(data)
);
}
globalProgressNode
.find('.progress')
.attr('aria-valuenow', progress)
.children().first().css(
'width',
progress + '%'
);
},
// Callback for uploads start, equivalent to the global ajaxStart event:
start: function (e) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload');
that._resetFinishedDeferreds();
that._transition($(this).find('.fileupload-progress')).done(
function () {
that._trigger('started', e);
}
);
},
// Callback for uploads stop, equivalent to the global ajaxStop event:
stop: function (e) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload'),
deferred = that._addFinishedDeferreds();
$.when.apply($, that._getFinishedDeferreds())
.done(function () {
that._trigger('stopped', e);
});
that._transition($(this).find('.fileupload-progress')).done(
function () {
$(this).find('.progress')
.attr('aria-valuenow', '0')
.children().first().css('width', '0%');
$(this).find('.progress-extended').html('&nbsp;');
deferred.resolve();
}
);
},
processstart: function (e) {
if (e.isDefaultPrevented()) {
return false;
}
$(this).addClass('fileupload-processing');
},
processstop: function (e) {
if (e.isDefaultPrevented()) {
return false;
}
$(this).removeClass('fileupload-processing');
},
// Callback for file deletion:
destroy: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}
var that = $(this).data('blueimp-fileupload') ||
$(this).data('fileupload'),
removeNode = function () {
that._transition(data.context).done(
function () {
$(this).remove();
that._trigger('destroyed', e, data);
}
);
};
if (data.url) {
data.dataType = data.dataType || that.options.dataType;
$.ajax(data).done(removeNode).fail(function () {
that._trigger('destroyfailed', e, data);
});
} else {
removeNode();
}
}
},
_resetFinishedDeferreds: function () {
this._finishedUploads = [];
},
_addFinishedDeferreds: function (deferred) {
if (!deferred) {
deferred = $.Deferred();
}
this._finishedUploads.push(deferred);
return deferred;
},
_getFinishedDeferreds: function () {
return this._finishedUploads;
},
// Link handler, that allows to download files
// by drag & drop of the links to the desktop:
_enableDragToDesktop: function () {
var link = $(this),
url = link.prop('href'),
name = link.prop('download'),
type = 'application/octet-stream';
link.bind('dragstart', function (e) {
try {
e.originalEvent.dataTransfer.setData(
'DownloadURL',
[type, name, url].join(':')
);
} catch (ignore) {}
});
},
_formatFileSize: function (bytes) {
if (typeof bytes !== 'number') {
return '';
}
if (bytes >= 1000000000) {
return (bytes / 1000000000).toFixed(2) + ' GB';
}
if (bytes >= 1000000) {
return (bytes / 1000000).toFixed(2) + ' MB';
}
return (bytes / 1000).toFixed(2) + ' KB';
},
_formatBitrate: function (bits) {
if (typeof bits !== 'number') {
return '';
}
if (bits >= 1000000000) {
return (bits / 1000000000).toFixed(2) + ' Gbit/s';
}
if (bits >= 1000000) {
return (bits / 1000000).toFixed(2) + ' Mbit/s';
}
if (bits >= 1000) {
return (bits / 1000).toFixed(2) + ' kbit/s';
}
return bits.toFixed(2) + ' bit/s';
},
_formatTime: function (seconds) {
var date = new Date(seconds * 1000),
days = Math.floor(seconds / 86400);
days = days ? days + 'd ' : '';
return days +
('0' + date.getUTCHours()).slice(-2) + ':' +
('0' + date.getUTCMinutes()).slice(-2) + ':' +
('0' + date.getUTCSeconds()).slice(-2);
},
_formatPercentage: function (floatValue) {
return (floatValue * 100).toFixed(2) + ' %';
},
_renderExtendedProgress: function (data) {
return this._formatBitrate(data.bitrate) + ' | ' +
this._formatTime(
(data.total - data.loaded) * 8 / data.bitrate
) + ' | ' +
this._formatPercentage(
data.loaded / data.total
) + ' | ' +
this._formatFileSize(data.loaded) + ' / ' +
this._formatFileSize(data.total);
},
_renderTemplate: function (func, files) {
if (!func) {
return $();
}
var result = func({
files: files,
formatFileSize: this._formatFileSize,
options: this.options
});
if (result instanceof $) {
return result;
}
return $(this.options.templatesContainer).html(result).children();
},
_renderPreviews: function (data) {
data.context.find('.preview').each(function (index, elm) {
$(elm).append(data.files[index].preview);
});
},
_renderUpload: function (files) {
return this._renderTemplate(
this.options.uploadTemplate,
files
);
},
_renderDownload: function (files) {
return this._renderTemplate(
this.options.downloadTemplate,
files
).find('a[download]').each(this._enableDragToDesktop).end();
},
_startHandler: function (e) {
e.preventDefault();
var button = $(e.currentTarget),
template = button.closest('.template-upload'),
data = template.data('data');
button.prop('disabled', true);
if (data && data.submit) {
data.submit();
}
},
_cancelHandler: function (e) {
e.preventDefault();
var template = $(e.currentTarget)
.closest('.template-upload,.template-download'),
data = template.data('data') || {};
data.context = data.context || template;
if (data.abort) {
data.abort();
} else {
data.errorThrown = 'abort';
this._trigger('fail', e, data);
}
},
_deleteHandler: function (e) {
e.preventDefault();
var button = $(e.currentTarget);
this._trigger('destroy', e, $.extend({
context: button.closest('.template-download'),
type: 'DELETE'
}, button.data()));
},
_forceReflow: function (node) {
return $.support.transition && node.length &&
node[0].offsetWidth;
},
_transition: function (node) {
var dfd = $.Deferred();
if ($.support.transition && node.hasClass('fade') && node.is(':visible')) {
node.bind(
$.support.transition.end,
function (e) {
// Make sure we don't respond to other transitions events
// in the container element, e.g. from button elements:
if (e.target === node[0]) {
node.unbind($.support.transition.end);
dfd.resolveWith(node);
}
}
).toggleClass('in');
} else {
node.toggleClass('in');
dfd.resolveWith(node);
}
return dfd;
},
_initButtonBarEventHandlers: function () {
var fileUploadButtonBar = this.element.find('.fileupload-buttonbar'),
filesList = this.options.filesContainer;
this._on(fileUploadButtonBar.find('.start'), {
click: function (e) {
e.preventDefault();
filesList.find('.start').click();
}
});
this._on(fileUploadButtonBar.find('.cancel'), {
click: function (e) {
e.preventDefault();
filesList.find('.cancel').click();
}
});
this._on(fileUploadButtonBar.find('.delete'), {
click: function (e) {
e.preventDefault();
filesList.find('.toggle:checked')
.closest('.template-download')
.find('.delete').click();
fileUploadButtonBar.find('.toggle')
.prop('checked', false);
}
});
this._on(fileUploadButtonBar.find('.toggle'), {
change: function (e) {
filesList.find('.toggle').prop(
'checked',
$(e.currentTarget).is(':checked')
);
}
});
},
_destroyButtonBarEventHandlers: function () {
this._off(
this.element.find('.fileupload-buttonbar')
.find('.start, .cancel, .delete'),
'click'
);
this._off(
this.element.find('.fileupload-buttonbar .toggle'),
'change.'
);
},
_initEventHandlers: function () {
this._super();
this._on(this.options.filesContainer, {
'click .start': this._startHandler,
'click .cancel': this._cancelHandler,
'click .delete': this._deleteHandler
});
this._initButtonBarEventHandlers();
},
_destroyEventHandlers: function () {
this._destroyButtonBarEventHandlers();
this._off(this.options.filesContainer, 'click');
this._super();
},
_enableFileInputButton: function () {
this.element.find('.fileinput-button input')
.prop('disabled', false)
.parent().removeClass('disabled');
},
_disableFileInputButton: function () {
this.element.find('.fileinput-button input')
.prop('disabled', true)
.parent().addClass('disabled');
},
_initTemplates: function () {
var options = this.options;
options.templatesContainer = this.document[0].createElement(
options.filesContainer.prop('nodeName')
);
if (tmpl) {
if (options.uploadTemplateId) {
options.uploadTemplate = tmpl(options.uploadTemplateId);
}
if (options.downloadTemplateId) {
options.downloadTemplate = tmpl(options.downloadTemplateId);
}
}
},
_initFilesContainer: function () {
var options = this.options;
if (options.filesContainer === undefined) {
options.filesContainer = this.element.find('.files');
} else if (!(options.filesContainer instanceof $)) {
options.filesContainer = $(options.filesContainer);
}
},
_initSpecialOptions: function () {
this._super();
this._initFilesContainer();
this._initTemplates();
},
_create: function () {
this._super();
this._resetFinishedDeferreds();
if (!$.support.fileInput) {
this._disableFileInputButton();
}
},
enable: function () {
var wasDisabled = false;
if (this.options.disabled) {
wasDisabled = true;
}
this._super();
if (wasDisabled) {
this.element.find('input, button').prop('disabled', false);
this._enableFileInputButton();
}
},
disable: function () {
if (!this.options.disabled) {
this.element.find('input, button').prop('disabled', true);
this._disableFileInputButton();
}
this._super();
}
});
}));

View File

@ -0,0 +1,122 @@
/*
* jQuery File Upload Validation Plugin 1.1.3
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* global define, require, window */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'./jquery.fileupload-process'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(
window.jQuery
);
}
}(function ($) {
'use strict';
// Append to the default processQueue:
$.blueimp.fileupload.prototype.options.processQueue.push(
{
action: 'validate',
// Always trigger this action,
// even if the previous action was rejected:
always: true,
// Options taken from the global options map:
acceptFileTypes: '@',
maxFileSize: '@',
minFileSize: '@',
maxNumberOfFiles: '@',
disabled: '@disableValidation'
}
);
// The File Upload Validation plugin extends the fileupload widget
// with file validation functionality:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
/*
// The regular expression for allowed file types, matches
// against either file type or file name:
acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i,
// The maximum allowed file size in bytes:
maxFileSize: 10000000, // 10 MB
// The minimum allowed file size in bytes:
minFileSize: undefined, // No minimal file size
// The limit of files to be uploaded:
maxNumberOfFiles: 10,
*/
// Function returning the current number of files,
// has to be overriden for maxNumberOfFiles validation:
getNumberOfFiles: $.noop,
// Error and info messages:
messages: {
maxNumberOfFiles: 'Maximum number of files exceeded',
acceptFileTypes: 'File type not allowed',
maxFileSize: 'File is too large',
minFileSize: 'File is too small'
}
},
processActions: {
validate: function (data, options) {
if (options.disabled) {
return data;
}
var dfd = $.Deferred(),
settings = this.options,
file = data.files[data.index],
fileSize;
if (options.minFileSize || options.maxFileSize) {
fileSize = file.size;
}
if ($.type(options.maxNumberOfFiles) === 'number' &&
(settings.getNumberOfFiles() || 0) + data.files.length >
options.maxNumberOfFiles) {
file.error = settings.i18n('maxNumberOfFiles');
} else if (options.acceptFileTypes &&
!(options.acceptFileTypes.test(file.type) ||
options.acceptFileTypes.test(file.name))) {
file.error = settings.i18n('acceptFileTypes');
} else if (fileSize > options.maxFileSize) {
file.error = settings.i18n('maxFileSize');
} else if ($.type(fileSize) === 'number' &&
fileSize < options.minFileSize) {
file.error = settings.i18n('minFileSize');
} else {
delete file.error;
}
if (file.error || data.files.error) {
data.files.error = true;
dfd.rejectWith(this, [data]);
} else {
dfd.resolveWith(this, [data]);
}
return dfd.promise();
}
}
});
}));

View File

@ -0,0 +1,112 @@
/*
* jQuery File Upload Video Preview Plugin 1.0.4
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2013, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* jshint nomen:false */
/* global define, require, window, document */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define([
'jquery',
'load-image',
'./jquery.fileupload-process'
], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(
require('jquery'),
require('load-image')
);
} else {
// Browser globals:
factory(
window.jQuery,
window.loadImage
);
}
}(function ($, loadImage) {
'use strict';
// Prepend to the default processQueue:
$.blueimp.fileupload.prototype.options.processQueue.unshift(
{
action: 'loadVideo',
// Use the action as prefix for the "@" options:
prefix: true,
fileTypes: '@',
maxFileSize: '@',
disabled: '@disableVideoPreview'
},
{
action: 'setVideo',
name: '@videoPreviewName',
disabled: '@disableVideoPreview'
}
);
// The File Upload Video Preview plugin extends the fileupload widget
// with video preview functionality:
$.widget('blueimp.fileupload', $.blueimp.fileupload, {
options: {
// The regular expression for the types of video files to load,
// matched against the file type:
loadVideoFileTypes: /^video\/.*$/
},
_videoElement: document.createElement('video'),
processActions: {
// Loads the video file given via data.files and data.index
// as video element if the browser supports playing it.
// Accepts the options fileTypes (regular expression)
// and maxFileSize (integer) to limit the files to load:
loadVideo: function (data, options) {
if (options.disabled) {
return data;
}
var file = data.files[data.index],
url,
video;
if (this._videoElement.canPlayType &&
this._videoElement.canPlayType(file.type) &&
($.type(options.maxFileSize) !== 'number' ||
file.size <= options.maxFileSize) &&
(!options.fileTypes ||
options.fileTypes.test(file.type))) {
url = loadImage.createObjectURL(file);
if (url) {
video = this._videoElement.cloneNode(false);
video.src = url;
video.controls = true;
data.video = video;
return data;
}
}
return data;
},
// Sets the video element as a property of the file object:
setVideo: function (data, options) {
if (data.video && !options.disabled) {
data.files[data.index][options.name || 'preview'] = data.video;
}
return data;
}
}
});
}));

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,217 @@
/*
* jQuery Iframe Transport Plugin 1.8.3
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2011, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* global define, require, window, document */
(function (factory) {
'use strict';
if (typeof define === 'function' && define.amd) {
// Register as an anonymous AMD module:
define(['jquery'], factory);
} else if (typeof exports === 'object') {
// Node/CommonJS:
factory(require('jquery'));
} else {
// Browser globals:
factory(window.jQuery);
}
}(function ($) {
'use strict';
// Helper variable to create unique names for the transport iframes:
var counter = 0;
// The iframe transport accepts four additional options:
// options.fileInput: a jQuery collection of file input fields
// options.paramName: the parameter name for the file form data,
// overrides the name property of the file input field(s),
// can be a string or an array of strings.
// options.formData: an array of objects with name and value properties,
// equivalent to the return data of .serializeArray(), e.g.:
// [{name: 'a', value: 1}, {name: 'b', value: 2}]
// options.initialIframeSrc: the URL of the initial iframe src,
// by default set to "javascript:false;"
$.ajaxTransport('iframe', function (options) {
if (options.async) {
// javascript:false as initial iframe src
// prevents warning popups on HTTPS in IE6:
/*jshint scripturl: true */
var initialIframeSrc = options.initialIframeSrc || 'javascript:false;',
/*jshint scripturl: false */
form,
iframe,
addParamChar;
return {
send: function (_, completeCallback) {
form = $('<form style="display:none;"></form>');
form.attr('accept-charset', options.formAcceptCharset);
addParamChar = /\?/.test(options.url) ? '&' : '?';
// XDomainRequest only supports GET and POST:
if (options.type === 'DELETE') {
options.url = options.url + addParamChar + '_method=DELETE';
options.type = 'POST';
} else if (options.type === 'PUT') {
options.url = options.url + addParamChar + '_method=PUT';
options.type = 'POST';
} else if (options.type === 'PATCH') {
options.url = options.url + addParamChar + '_method=PATCH';
options.type = 'POST';
}
// IE versions below IE8 cannot set the name property of
// elements that have already been added to the DOM,
// so we set the name along with the iframe HTML markup:
counter += 1;
iframe = $(
'<iframe src="' + initialIframeSrc +
'" name="iframe-transport-' + counter + '"></iframe>'
).bind('load', function () {
var fileInputClones,
paramNames = $.isArray(options.paramName) ?
options.paramName : [options.paramName];
iframe
.unbind('load')
.bind('load', function () {
var response;
// Wrap in a try/catch block to catch exceptions thrown
// when trying to access cross-domain iframe contents:
try {
response = iframe.contents();
// Google Chrome and Firefox do not throw an
// exception when calling iframe.contents() on
// cross-domain requests, so we unify the response:
if (!response.length || !response[0].firstChild) {
throw new Error();
}
} catch (e) {
response = undefined;
}
// The complete callback returns the
// iframe content document as response object:
completeCallback(
200,
'success',
{'iframe': response}
);
// Fix for IE endless progress bar activity bug
// (happens on form submits to iframe targets):
$('<iframe src="' + initialIframeSrc + '"></iframe>')
.appendTo(form);
window.setTimeout(function () {
// Removing the form in a setTimeout call
// allows Chrome's developer tools to display
// the response result
form.remove();
}, 0);
});
form
.prop('target', iframe.prop('name'))
.prop('action', options.url)
.prop('method', options.type);
if (options.formData) {
$.each(options.formData, function (index, field) {
$('<input type="hidden"/>')
.prop('name', field.name)
.val(field.value)
.appendTo(form);
});
}
if (options.fileInput && options.fileInput.length &&
options.type === 'POST') {
fileInputClones = options.fileInput.clone();
// Insert a clone for each file input field:
options.fileInput.after(function (index) {
return fileInputClones[index];
});
if (options.paramName) {
options.fileInput.each(function (index) {
$(this).prop(
'name',
paramNames[index] || options.paramName
);
});
}
// Appending the file input fields to the hidden form
// removes them from their original location:
form
.append(options.fileInput)
.prop('enctype', 'multipart/form-data')
// enctype must be set as encoding for IE:
.prop('encoding', 'multipart/form-data');
// Remove the HTML5 form attribute from the input(s):
options.fileInput.removeAttr('form');
}
form.submit();
// Insert the file input fields at their original location
// by replacing the clones with the originals:
if (fileInputClones && fileInputClones.length) {
options.fileInput.each(function (index, input) {
var clone = $(fileInputClones[index]);
// Restore the original name and form properties:
$(input)
.prop('name', clone.prop('name'))
.attr('form', clone.attr('form'));
clone.replaceWith(input);
});
}
});
form.append(iframe).appendTo(document.body);
},
abort: function () {
if (iframe) {
// javascript:false as iframe src aborts the request
// and prevents warning popups on HTTPS in IE6.
// concat is used to avoid the "Script URL" JSLint error:
iframe
.unbind('load')
.prop('src', initialIframeSrc);
}
if (form) {
form.remove();
}
}
};
}
});
// The iframe transport returns the iframe content document as response.
// The following adds converters from iframe to text, json, html, xml
// and script.
// Please note that the Content-Type for JSON responses has to be text/plain
// or text/html, if the browser doesn't include application/json in the
// Accept header, else IE will show a download dialog.
// The Content-Type for XML responses on the other hand has to be always
// application/xml or text/xml, so IE properly parses the XML response.
// See also
// https://github.com/blueimp/jQuery-File-Upload/wiki/Setup#content-type-negotiation
$.ajaxSetup({
converters: {
'iframe text': function (iframe) {
return iframe && $(iframe[0].body).text();
},
'iframe json': function (iframe) {
return iframe && $.parseJSON($(iframe[0].body).text());
},
'iframe html': function (iframe) {
return iframe && $(iframe[0].body).html();
},
'iframe xml': function (iframe) {
var xmlDoc = iframe && iframe[0];
return xmlDoc && $.isXMLDoc(xmlDoc) ? xmlDoc :
$.parseXML((xmlDoc.XMLDocument && xmlDoc.XMLDocument.xml) ||
$(xmlDoc.body).html());
},
'iframe script': function (iframe) {
return iframe && $.globalEval($(iframe[0].body).text());
}
}
});
}));

View File

@ -0,0 +1,75 @@
/*
* jQuery File Upload Plugin JS Example 8.9.1
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2010, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://www.opensource.org/licenses/MIT
*/
/* global $, window */
$(function () {
'use strict';
// Initialize the jQuery File Upload widget:
$('#fileupload').fileupload({
// Uncomment the following to send cross-domain cookies:
//xhrFields: {withCredentials: true},
url: 'server/php/'
});
// Enable iframe cross-domain access via redirect option:
$('#fileupload').fileupload(
'option',
'redirect',
window.location.href.replace(
/\/[^\/]*$/,
'/cors/result.html?%s'
)
);
if (window.location.hostname === 'blueimp.github.io') {
// Demo settings:
$('#fileupload').fileupload('option', {
url: '//jquery-file-upload.appspot.com/',
// Enable image resizing, except for Android and Opera,
// which actually support image resizing, but fail to
// send Blob objects via XHR requests:
disableImageResize: /Android(?!.*Chrome)|Opera/
.test(window.navigator.userAgent),
maxFileSize: 5000000,
acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i
});
// Upload server status check for browsers with CORS support:
if ($.support.cors) {
$.ajax({
url: '//jquery-file-upload.appspot.com/',
type: 'HEAD'
}).fail(function () {
$('<div class="alert alert-danger"/>')
.text('Upload server currently unavailable - ' +
new Date())
.appendTo('#fileupload');
});
}
} else {
// Load existing files:
$('#fileupload').addClass('fileupload-processing');
$.ajax({
// Uncomment the following to send cross-domain cookies:
//xhrFields: {withCredentials: true},
url: $('#fileupload').fileupload('option', 'url'),
dataType: 'json',
context: $('#fileupload')[0]
}).always(function () {
$(this).removeClass('fileupload-processing');
}).done(function (result) {
$(this).fileupload('option', 'done')
.call(this, $.Event('done'), {result: result});
});
}
});

View File

@ -0,0 +1,563 @@
/*! jQuery UI - v1.11.1+CommonJS - 2014-09-17
* http://jqueryui.com
* Includes: widget.js
* Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */
(function( factory ) {
if ( typeof define === "function" && define.amd ) {
// AMD. Register as an anonymous module.
define([ "jquery" ], factory );
} else if (typeof exports === "object") {
// Node/CommonJS:
factory(require("jquery"));
} else {
// Browser globals
factory( jQuery );
}
}(function( $ ) {
/*!
* jQuery UI Widget 1.11.1
* http://jqueryui.com
*
* Copyright 2014 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/jQuery.widget/
*/
var widget_uuid = 0,
widget_slice = Array.prototype.slice;
$.cleanData = (function( orig ) {
return function( elems ) {
var events, elem, i;
for ( i = 0; (elem = elems[i]) != null; i++ ) {
try {
// Only trigger remove when necessary to save time
events = $._data( elem, "events" );
if ( events && events.remove ) {
$( elem ).triggerHandler( "remove" );
}
// http://bugs.jquery.com/ticket/8235
} catch( e ) {}
}
orig( elems );
};
})( $.cleanData );
$.widget = function( name, base, prototype ) {
var fullName, existingConstructor, constructor, basePrototype,
// proxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
proxiedPrototype = {},
namespace = name.split( "." )[ 0 ];
name = name.split( "." )[ 1 ];
fullName = namespace + "-" + name;
if ( !prototype ) {
prototype = base;
base = $.Widget;
}
// create selector for plugin
$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
return !!$.data( elem, fullName );
};
$[ namespace ] = $[ namespace ] || {};
existingConstructor = $[ namespace ][ name ];
constructor = $[ namespace ][ name ] = function( options, element ) {
// allow instantiation without "new" keyword
if ( !this._createWidget ) {
return new constructor( options, element );
}
// allow instantiation without initializing for simple inheritance
// must use "new" keyword (the code above always passes args)
if ( arguments.length ) {
this._createWidget( options, element );
}
};
// extend with the existing constructor to carry over any static properties
$.extend( constructor, existingConstructor, {
version: prototype.version,
// copy the object used to create the prototype in case we need to
// redefine the widget later
_proto: $.extend( {}, prototype ),
// track widgets that inherit from this widget in case this widget is
// redefined after a widget inherits from it
_childConstructors: []
});
basePrototype = new base();
// we need to make the options hash a property directly on the new instance
// otherwise we'll modify the options hash on the prototype that we're
// inheriting from
basePrototype.options = $.widget.extend( {}, basePrototype.options );
$.each( prototype, function( prop, value ) {
if ( !$.isFunction( value ) ) {
proxiedPrototype[ prop ] = value;
return;
}
proxiedPrototype[ prop ] = (function() {
var _super = function() {
return base.prototype[ prop ].apply( this, arguments );
},
_superApply = function( args ) {
return base.prototype[ prop ].apply( this, args );
};
return function() {
var __super = this._super,
__superApply = this._superApply,
returnValue;
this._super = _super;
this._superApply = _superApply;
returnValue = value.apply( this, arguments );
this._super = __super;
this._superApply = __superApply;
return returnValue;
};
})();
});
constructor.prototype = $.widget.extend( basePrototype, {
// TODO: remove support for widgetEventPrefix
// always use the name + a colon as the prefix, e.g., draggable:start
// don't prefix for widgets that aren't DOM-based
widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
}, proxiedPrototype, {
constructor: constructor,
namespace: namespace,
widgetName: name,
widgetFullName: fullName
});
// If this widget is being redefined then we need to find all widgets that
// are inheriting from it and redefine all of them so that they inherit from
// the new version of this widget. We're essentially trying to replace one
// level in the prototype chain.
if ( existingConstructor ) {
$.each( existingConstructor._childConstructors, function( i, child ) {
var childPrototype = child.prototype;
// redefine the child widget using the same prototype that was
// originally used, but inherit from the new version of the base
$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
});
// remove the list of existing child constructors from the old constructor
// so the old child constructors can be garbage collected
delete existingConstructor._childConstructors;
} else {
base._childConstructors.push( constructor );
}
$.widget.bridge( name, constructor );
return constructor;
};
$.widget.extend = function( target ) {
var input = widget_slice.call( arguments, 1 ),
inputIndex = 0,
inputLength = input.length,
key,
value;
for ( ; inputIndex < inputLength; inputIndex++ ) {
for ( key in input[ inputIndex ] ) {
value = input[ inputIndex ][ key ];
if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
// Clone objects
if ( $.isPlainObject( value ) ) {
target[ key ] = $.isPlainObject( target[ key ] ) ?
$.widget.extend( {}, target[ key ], value ) :
// Don't extend strings, arrays, etc. with objects
$.widget.extend( {}, value );
// Copy everything else by reference
} else {
target[ key ] = value;
}
}
}
}
return target;
};
$.widget.bridge = function( name, object ) {
var fullName = object.prototype.widgetFullName || name;
$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string",
args = widget_slice.call( arguments, 1 ),
returnValue = this;
// allow multiple hashes to be passed on init
options = !isMethodCall && args.length ?
$.widget.extend.apply( null, [ options ].concat(args) ) :
options;
if ( isMethodCall ) {
this.each(function() {
var methodValue,
instance = $.data( this, fullName );
if ( options === "instance" ) {
returnValue = instance;
return false;
}
if ( !instance ) {
return $.error( "cannot call methods on " + name + " prior to initialization; " +
"attempted to call method '" + options + "'" );
}
if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
return $.error( "no such method '" + options + "' for " + name + " widget instance" );
}
methodValue = instance[ options ].apply( instance, args );
if ( methodValue !== instance && methodValue !== undefined ) {
returnValue = methodValue && methodValue.jquery ?
returnValue.pushStack( methodValue.get() ) :
methodValue;
return false;
}
});
} else {
this.each(function() {
var instance = $.data( this, fullName );
if ( instance ) {
instance.option( options || {} );
if ( instance._init ) {
instance._init();
}
} else {
$.data( this, fullName, new object( options, this ) );
}
});
}
return returnValue;
};
};
$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];
$.Widget.prototype = {
widgetName: "widget",
widgetEventPrefix: "",
defaultElement: "<div>",
options: {
disabled: false,
// callbacks
create: null
},
_createWidget: function( options, element ) {
element = $( element || this.defaultElement || this )[ 0 ];
this.element = $( element );
this.uuid = widget_uuid++;
this.eventNamespace = "." + this.widgetName + this.uuid;
this.options = $.widget.extend( {},
this.options,
this._getCreateOptions(),
options );
this.bindings = $();
this.hoverable = $();
this.focusable = $();
if ( element !== this ) {
$.data( element, this.widgetFullName, this );
this._on( true, this.element, {
remove: function( event ) {
if ( event.target === element ) {
this.destroy();
}
}
});
this.document = $( element.style ?
// element within the document
element.ownerDocument :
// element is window or document
element.document || element );
this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
}
this._create();
this._trigger( "create", null, this._getCreateEventData() );
this._init();
},
_getCreateOptions: $.noop,
_getCreateEventData: $.noop,
_create: $.noop,
_init: $.noop,
destroy: function() {
this._destroy();
// we can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element
.unbind( this.eventNamespace )
.removeData( this.widgetFullName )
// support: jquery <1.6.3
// http://bugs.jquery.com/ticket/9413
.removeData( $.camelCase( this.widgetFullName ) );
this.widget()
.unbind( this.eventNamespace )
.removeAttr( "aria-disabled" )
.removeClass(
this.widgetFullName + "-disabled " +
"ui-state-disabled" );
// clean up events and states
this.bindings.unbind( this.eventNamespace );
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
},
_destroy: $.noop,
widget: function() {
return this.element;
},
option: function( key, value ) {
var options = key,
parts,
curOption,
i;
if ( arguments.length === 0 ) {
// don't return a reference to the internal hash
return $.widget.extend( {}, this.options );
}
if ( typeof key === "string" ) {
// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
parts = key.split( "." );
key = parts.shift();
if ( parts.length ) {
curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
for ( i = 0; i < parts.length - 1; i++ ) {
curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
curOption = curOption[ parts[ i ] ];
}
key = parts.pop();
if ( arguments.length === 1 ) {
return curOption[ key ] === undefined ? null : curOption[ key ];
}
curOption[ key ] = value;
} else {
if ( arguments.length === 1 ) {
return this.options[ key ] === undefined ? null : this.options[ key ];
}
options[ key ] = value;
}
}
this._setOptions( options );
return this;
},
_setOptions: function( options ) {
var key;
for ( key in options ) {
this._setOption( key, options[ key ] );
}
return this;
},
_setOption: function( key, value ) {
this.options[ key ] = value;
if ( key === "disabled" ) {
this.widget()
.toggleClass( this.widgetFullName + "-disabled", !!value );
// If the widget is becoming disabled, then nothing is interactive
if ( value ) {
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
}
}
return this;
},
enable: function() {
return this._setOptions({ disabled: false });
},
disable: function() {
return this._setOptions({ disabled: true });
},
_on: function( suppressDisabledCheck, element, handlers ) {
var delegateElement,
instance = this;
// no suppressDisabledCheck flag, shuffle arguments
if ( typeof suppressDisabledCheck !== "boolean" ) {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// no element argument, shuffle and use this.element
if ( !handlers ) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
element = delegateElement = $( element );
this.bindings = this.bindings.add( element );
}
$.each( handlers, function( event, handler ) {
function handlerProxy() {
// allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if ( !suppressDisabledCheck &&
( instance.options.disabled === true ||
$( this ).hasClass( "ui-state-disabled" ) ) ) {
return;
}
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
// copy the guid so direct unbinding works
if ( typeof handler !== "string" ) {
handlerProxy.guid = handler.guid =
handler.guid || handlerProxy.guid || $.guid++;
}
var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
eventName = match[1] + instance.eventNamespace,
selector = match[2];
if ( selector ) {
delegateElement.delegate( selector, eventName, handlerProxy );
} else {
element.bind( eventName, handlerProxy );
}
});
},
_off: function( element, eventName ) {
eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
element.unbind( eventName ).undelegate( eventName );
},
_delay: function( handler, delay ) {
function handlerProxy() {
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
var instance = this;
return setTimeout( handlerProxy, delay || 0 );
},
_hoverable: function( element ) {
this.hoverable = this.hoverable.add( element );
this._on( element, {
mouseenter: function( event ) {
$( event.currentTarget ).addClass( "ui-state-hover" );
},
mouseleave: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-hover" );
}
});
},
_focusable: function( element ) {
this.focusable = this.focusable.add( element );
this._on( element, {
focusin: function( event ) {
$( event.currentTarget ).addClass( "ui-state-focus" );
},
focusout: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-focus" );
}
});
},
_trigger: function( type, event, data ) {
var prop, orig,
callback = this.options[ type ];
data = data || {};
event = $.Event( event );
event.type = ( type === this.widgetEventPrefix ?
type :
this.widgetEventPrefix + type ).toLowerCase();
// the original event may come from any element
// so we need to reset the target on the new event
event.target = this.element[ 0 ];
// copy original event properties over to the new event
orig = event.originalEvent;
if ( orig ) {
for ( prop in orig ) {
if ( !( prop in event ) ) {
event[ prop ] = orig[ prop ];
}
}
}
this.element.trigger( event, data );
return !( $.isFunction( callback ) &&
callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
event.isDefaultPrevented() );
}
};
$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
if ( typeof options === "string" ) {
options = { effect: options };
}
var hasOptions,
effectName = !options ?
method :
options === true || typeof options === "number" ?
defaultEffect :
options.effect || defaultEffect;
options = options || {};
if ( typeof options === "number" ) {
options = { duration: options };
}
hasOptions = !$.isEmptyObject( options );
options.complete = callback;
if ( options.delay ) {
element.delay( options.delay );
}
if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
element[ method ]( options );
} else if ( effectName !== method && element[ effectName ] ) {
element[ effectName ]( options.duration, options.easing, callback );
} else {
element.queue(function( next ) {
$( this )[ method ]();
if ( callback ) {
callback.call( element[ 0 ] );
}
next();
});
}
};
});
var widget = $.widget;
}));