[-\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;
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Protocol/InterpreterTest.php b/application/module/Goodby/CSV/Import/Tests/Protocol/InterpreterTest.php
new file mode 100644
index 00000000..a570375e
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Protocol/InterpreterTest.php
@@ -0,0 +1,42 @@
+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);
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Protocol/LexerTest.php b/application/module/Goodby/CSV/Import/Tests/Protocol/LexerTest.php
new file mode 100644
index 00000000..82fa0a0a
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Protocol/LexerTest.php
@@ -0,0 +1,41 @@
+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);
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/CSVFiles.php b/application/module/Goodby/CSV/Import/Tests/Standard/Join/CSVFiles.php
new file mode 100644
index 00000000..082dd937
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/CSVFiles.php
@@ -0,0 +1,69 @@
+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);
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/Observer/PdoObserverTest.php b/application/module/Goodby/CSV/Import/Tests/Standard/Join/Observer/PdoObserverTest.php
new file mode 100644
index 00000000..971b07b2
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/Observer/PdoObserverTest.php
@@ -0,0 +1,86 @@
+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')));
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/colon-separated.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/colon-separated.csv
new file mode 100644
index 00000000..5f6b7c6b
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/colon-separated.csv
@@ -0,0 +1,2 @@
+value1:value2:value3
+value4:value5:value6
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/issue-5.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/issue-5.csv
new file mode 100644
index 00000000..6133eefb
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/issue-5.csv
@@ -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
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/mac-excel.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/mac-excel.csv
new file mode 100644
index 00000000..fa249e7e
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/mac-excel.csv
@@ -0,0 +1 @@
+a,b,c
d,e,f
\ No newline at end of file
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/sjis.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/sjis.csv
new file mode 100644
index 00000000..f93d9fd8
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/sjis.csv
@@ -0,0 +1,4 @@
+,,,,
+{,{,{,{,{
+,,,,
+"""quoted""",a'quote',"a, b and c",,
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/tab-separated.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/tab-separated.csv
new file mode 100644
index 00000000..7d2eeaeb
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/tab-separated.csv
@@ -0,0 +1,7 @@
+value1 value2 value3
+value4 value5 value6
+
+
+
+
+
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/utf-8.csv b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/utf-8.csv
new file mode 100644
index 00000000..2638604a
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Join/csv_files/utf-8.csv
@@ -0,0 +1,3 @@
+✔,✔,✔,✔
+★,★,★,★
+유,니,코,드
\ No newline at end of file
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/SandboxDirectoryManager.php b/application/module/Goodby/CSV/Import/Tests/Standard/SandboxDirectoryManager.php
new file mode 100644
index 00000000..329e04f9
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/SandboxDirectoryManager.php
@@ -0,0 +1,45 @@
+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);
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Unit/LexerConfigTest.php b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/LexerConfigTest.php
new file mode 100644
index 00000000..94a3262a
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/LexerConfigTest.php
@@ -0,0 +1,61 @@
+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());
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Unit/Observer/SqlObserverTest.php b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/Observer/SqlObserverTest.php
new file mode 100644
index 00000000..9096800d
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/Observer/SqlObserverTest.php
@@ -0,0 +1,51 @@
+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')));
+ }
+}
diff --git a/application/module/Goodby/CSV/Import/Tests/Standard/Unit/StreamFilter/ConvertMbstringEncodingTest.php b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/StreamFilter/ConvertMbstringEncodingTest.php
new file mode 100644
index 00000000..7cf944f7
--- /dev/null
+++ b/application/module/Goodby/CSV/Import/Tests/Standard/Unit/StreamFilter/ConvertMbstringEncodingTest.php
@@ -0,0 +1,64 @@
+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));
+ }
+}
diff --git a/application/module/Goodby/CSV/TestHelper/DbManager.php b/application/module/Goodby/CSV/TestHelper/DbManager.php
new file mode 100644
index 00000000..61a78560
--- /dev/null
+++ b/application/module/Goodby/CSV/TestHelper/DbManager.php
@@ -0,0 +1,54 @@
+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;
+ }
+}
diff --git a/application/module/Helpers/PDO.php b/application/module/Helpers/PDO.php
index d41733c4..2a8ac2fc 100644
--- a/application/module/Helpers/PDO.php
+++ b/application/module/Helpers/PDO.php
@@ -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};"
diff --git a/application/module/Westdc/Dataimport/AbstractProcessing.php b/application/module/Westdc/Dataimport/AbstractProcessing.php
new file mode 100644
index 00000000..135a9d37
--- /dev/null
+++ b/application/module/Westdc/Dataimport/AbstractProcessing.php
@@ -0,0 +1,40 @@
+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;
+ }
+
+}
\ No newline at end of file
diff --git a/application/module/Westdc/Dataimport/ProcessFactory.php b/application/module/Westdc/Dataimport/ProcessFactory.php
new file mode 100644
index 00000000..8a743299
--- /dev/null
+++ b/application/module/Westdc/Dataimport/ProcessFactory.php
@@ -0,0 +1,39 @@
+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;
+ }
+}
\ No newline at end of file
diff --git a/application/module/Westdc/Dataimport/ProcessingInterface.php b/application/module/Westdc/Dataimport/ProcessingInterface.php
new file mode 100644
index 00000000..1df69657
--- /dev/null
+++ b/application/module/Westdc/Dataimport/ProcessingInterface.php
@@ -0,0 +1,32 @@
+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);
}
}
\ No newline at end of file
diff --git a/htdocs/js/lib/jquery.fileupload/app.js b/htdocs/js/lib/jquery.fileupload/app.js
new file mode 100644
index 00000000..47b4f923
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/app.js
@@ -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);
+ };
+ }
+ }
+ ]);
+
+}());
diff --git a/htdocs/js/lib/jquery.fileupload/cors/jquery.postmessage-transport.js b/htdocs/js/lib/jquery.fileupload/cors/jquery.postmessage-transport.js
new file mode 100644
index 00000000..65c19e6b
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/cors/jquery.postmessage-transport.js
@@ -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 = $('').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 = $(
+ ''
+ ).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();
+ }
+ }
+ };
+ }
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/cors/jquery.xdr-transport.js b/htdocs/js/lib/jquery.fileupload/cors/jquery.xdr-transport.js
new file mode 100644
index 00000000..2dfd0faf
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/cors/jquery.xdr-transport.js
@@ -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();
+ }
+ }
+ };
+ }
+ });
+ }
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/css/demo-ie8.css b/htdocs/js/lib/jquery.fileupload/css/demo-ie8.css
new file mode 100644
index 00000000..262493d0
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/demo-ie8.css
@@ -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;
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/demo.css b/htdocs/js/lib/jquery.fileupload/css/demo.css
new file mode 100644
index 00000000..2b4d4393
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/demo.css
@@ -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: "| ";
+ }
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-noscript.css b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-noscript.css
new file mode 100644
index 00000000..64d728fc
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-noscript.css
@@ -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;
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui-noscript.css b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui-noscript.css
new file mode 100644
index 00000000..87f110cd
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui-noscript.css
@@ -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;
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui.css b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui.css
new file mode 100644
index 00000000..76fb376d
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload-ui.css
@@ -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%;
+ }
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload.css b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload.css
new file mode 100644
index 00000000..fb6044d3
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/jquery.fileupload.css
@@ -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%;
+ }
+}
diff --git a/htdocs/js/lib/jquery.fileupload/css/style.css b/htdocs/js/lib/jquery.fileupload/css/style.css
new file mode 100644
index 00000000..b2c60a6f
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/css/style.css
@@ -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;
+}
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-angular.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-angular.js
new file mode 100644
index 00000000..e4ef3926
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-angular.js
@@ -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) {}
+ });
+ };
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-audio.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-audio.js
new file mode 100644
index 00000000..1e3d05de
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-audio.js
@@ -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;
+ }
+
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-image.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-image.js
new file mode 100644
index 00000000..0ac99365
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-image.js
@@ -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;
+ }
+
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-jquery-ui.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-jquery-ui.js
new file mode 100755
index 00000000..e6cf5c72
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-jquery-ui.js
@@ -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();
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-process.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-process.js
new file mode 100644
index 00000000..da78fa03
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-process.js
@@ -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();
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-ui.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-ui.js
new file mode 100644
index 00000000..1a8e36cc
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-ui.js
@@ -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(' ');
+ 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();
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-validate.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-validate.js
new file mode 100644
index 00000000..cb0d9f8b
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-validate.js
@@ -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();
+ }
+
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload-video.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-video.js
new file mode 100644
index 00000000..db5f2480
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload-video.js
@@ -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;
+ }
+
+ }
+
+ });
+
+}));
diff --git a/htdocs/js/lib/jquery.fileupload/jquery.fileupload.js b/htdocs/js/lib/jquery.fileupload/jquery.fileupload.js
new file mode 100644
index 00000000..e99f3091
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/jquery.fileupload.js
@@ -0,0 +1,1466 @@
+/*
+ * jQuery File Upload Plugin 5.42.2
+ * 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, document, location, Blob, FormData */
+
+(function (factory) {
+ 'use strict';
+ if (typeof define === 'function' && define.amd) {
+ // Register as an anonymous AMD module:
+ define([
+ 'jquery',
+ 'jquery.ui.widget'
+ ], factory);
+ } else if (typeof exports === 'object') {
+ // Node/CommonJS:
+ factory(
+ require('jquery'),
+ require('./vendor/jquery.ui.widget')
+ );
+ } else {
+ // Browser globals:
+ factory(window.jQuery);
+ }
+}(function ($) {
+ 'use strict';
+
+ // Detect file input support, based on
+ // http://viljamis.com/blog/2012/file-upload-support-on-mobile/
+ $.support.fileInput = !(new RegExp(
+ // Handle devices which give false positives for the feature detection:
+ '(Android (1\\.[0156]|2\\.[01]))' +
+ '|(Windows Phone (OS 7|8\\.0))|(XBLWP)|(ZuneWP)|(WPDesktop)' +
+ '|(w(eb)?OSBrowser)|(webOS)' +
+ '|(Kindle/(1\\.0|2\\.[05]|3\\.0))'
+ ).test(window.navigator.userAgent) ||
+ // Feature detection for all other devices:
+ $('
')
+ .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});
+ });
+ }
+
+});
diff --git a/htdocs/js/lib/jquery.fileupload/vendor/jquery.ui.widget.js b/htdocs/js/lib/jquery.fileupload/vendor/jquery.ui.widget.js
new file mode 100644
index 00000000..5ac2ed5a
--- /dev/null
+++ b/htdocs/js/lib/jquery.fileupload/vendor/jquery.ui.widget.js
@@ -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: "",
+ 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;
+
+
+
+}));