├── languages
    ├── fr.mo
    ├── de_DE.mo
    ├── template.base.pot
    ├── template.pot
    ├── de_DE.po
    └── fr.po
├── models
    ├── ElementType.php
    └── Table
    │   └── ElementType.php
├── views
    └── admin
    │   ├── javascripts
    │       └── date.js
    │   └── index
    │       ├── edit-options.php
    │       ├── edit.php
    │       └── index.php
├── plugin.ini
├── README.md
├── controllers
    └── IndexController.php
└── ElementTypesPlugin.php


/languages/fr.mo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/biblibre/omeka-plugin-ElementTypes/HEAD/languages/fr.mo


--------------------------------------------------------------------------------
/languages/de_DE.mo:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/biblibre/omeka-plugin-ElementTypes/HEAD/languages/de_DE.mo


--------------------------------------------------------------------------------
/models/ElementType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class ElementType extends Omeka_Record_AbstractRecord
 4 | {
 5 |     public $id;
 6 |     public $element_id;
 7 |     public $element_type;
 8 |     public $element_type_options;
 9 | }
10 | 


--------------------------------------------------------------------------------
/views/admin/javascripts/date.js:
--------------------------------------------------------------------------------
1 | jQuery(document).bind("omeka:elementformload", function() {
2 |     jQuery("input[data-type='date']").each(function() {
3 |         var format = jQuery(this).attr('data-format') || 'yy-mm-dd';
4 |         jQuery(this).datepicker({
5 |             dateFormat: format,
6 |         });
7 |     });
8 | });
9 | 


--------------------------------------------------------------------------------
/models/Table/ElementType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Table_ElementType extends Omeka_Db_Table
 4 | {
 5 |     public function findByElementId($elementId)
 6 |     {
 7 |         $select = $this->getSelect()->where('element_id = ?', $elementId);
 8 |         return $this->fetchObject($select);
 9 |     }
10 | 
11 |     public function findByElementType($elementType)
12 |     {
13 |         $select = $this->getSelect()->where('element_type = ?', $elementType);
14 |         return $this->fetchObjects($select);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/views/admin/index/edit-options.php:
--------------------------------------------------------------------------------
 1 | <?php echo head(array('title' => __('Element Types'))); ?>
 2 | <?php echo flash(); ?>
 3 | 
 4 | <h1><?php echo __('Configure type %1$s for element %2$s', __($element_types[$element_type['element_type']]), __($element['name'])); ?></h1>
 5 | 
 6 | <form method="post" action="<?php echo url('element-types/index/save-options'); ?>">
 7 |     <div>
 8 |         <?php echo $options_form; ?>
 9 |     </div>
10 |     <?php echo $this->formHidden('element_id', $element['id']); ?>
11 |     <?php echo $this->formSubmit('save', __('Save')); ?>
12 | </form>
13 | 
14 | <?php echo foot(); ?>
15 | 


--------------------------------------------------------------------------------
/plugin.ini:
--------------------------------------------------------------------------------
 1 | [info]
 2 | name = "Element Types"
 3 | author = "Julian Maurice"
 4 | description = "Allow elements to have a type, thus allowing easier input. For instance, this plugin implements the 'date' type and show a datepicker widget for elements of this type. Other types can be implemented by plugins."
 5 | version = "0.5.0"
 6 | license = "GPLv3"
 7 | link = "https://github.com/biblibre/omeka-plugin-ElementTypes"
 8 | support_link = "https://github.com/biblibre/omeka-plugin-ElementTypes/issues"
 9 | omeka_minimum_version = "2.0"
10 | omeka_target_version = "2.3"
11 | required_plugins = ""
12 | optional_plugins = ""
13 | 


--------------------------------------------------------------------------------
/languages/template.base.pot:
--------------------------------------------------------------------------------
 1 | # Translation for the Element Types plugin for Omeka.
 2 | # Copyright (C) 2015 BibLibre
 3 | # This file is distributed under the same license as the Omeka package.
 4 | # Julian Maurice <julian.maurice@biblibre.com>, 2015
 5 | #
 6 | #, fuzzy
 7 | msgid ""
 8 | msgstr ""
 9 | "Project-Id-Version: ElementTypes\n"
10 | "Report-Msgid-Bugs-To: \n"
11 | "POT-Creation-Date: 2015-04-30 09:27+0000\n"
12 | "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
13 | "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
14 | "Language-Team: LANGUAGE <LL@li.org>\n"
15 | "Language: \n"
16 | "MIME-Version: 1.0\n"
17 | "Content-Type: text/plain; charset=UTF-8\n"
18 | "Content-Transfer-Encoding: 8bit\n"
19 | 
20 | 


--------------------------------------------------------------------------------
/views/admin/index/edit.php:
--------------------------------------------------------------------------------
 1 | <?php echo head(array('title' => __('Element Types'))); ?>
 2 | <?php echo flash(); ?>
 3 | 
 4 | <h1><?php echo __('Change type of element %s', __($element['name'])); ?></h1>
 5 | 
 6 | <form method="post" action="<?php echo url('element-types/index/save'); ?>">
 7 |   <div>
 8 |     <?php
 9 |       echo $this->formHidden('element_id', $element['id']);
10 |       $name = 'type';
11 |       echo $this->formLabel($name, __('Type'));
12 |       echo ' ';
13 |       echo $this->formSelect(
14 |         $name,
15 |         $element_type['element_type'],
16 |         null,
17 |         $element_types_info_options
18 |       );
19 |     ?>
20 |   </div>
21 |   <?php
22 |     echo $this->formSubmit('save', __('Save'));
23 |   ?>
24 | </form>
25 | 
26 | <?php echo foot(); ?>
27 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # omeka-plugin-ElementTypes
 2 | 
 3 | Allow elements to have a type, thus allowing easier input. For instance, this plugin implements the 'date' type and show a datepicker widget for elements of this type. Other types can be implemented by plugins.
 4 | 
 5 | # Quick start
 6 | 
 7 | * Install ElementTypes and Date plugins
 8 | * A new link 'Element Types' appears on navigation menu, click on it.
 9 | * Say you want to assign the type 'date' to the 'Date' element, click on "Modify" on the corresponding row, select "Date", then Save.
10 | * Optionally, you can configure the 'date' type for this particular element by clicking on 'Configure' link (for now you can only configure the date format)
11 | * Edit or create an item, and see you now have a datepicker for the Date element.
12 | 
13 | ## New plugins for other needs
14 | 
15 | You can create as many as plugins as you want for your specific needs and new types. For example we created one to suggest Koha authorities when you enter text. We are developping another omeka plugin to allow to define taxonomies and declare an element type 'taxonomy-term' (https://github.com/biblibre/omeka-plugin-Taxonomy).
16 | 


--------------------------------------------------------------------------------
/views/admin/index/index.php:
--------------------------------------------------------------------------------
 1 | <?php echo head(array('title' => __('Element Types'))); ?>
 2 | <?php echo flash(); ?>
 3 | 
 4 | <table>
 5 |   <thead>
 6 |     <tr>
 7 |       <th><?php echo __('Element'); ?></th>
 8 |       <th><?php echo __('Type'); ?></th>
 9 |       <th><?php echo __('Actions'); ?></th>
10 |     </tr>
11 |   </thead>
12 |   <tbody>
13 |     <?php foreach ($elements as $group => $elts): ?>
14 |       <tr><td colspan="3"><strong><?php echo $group ?></strong></td></tr>
15 |       <?php foreach($elts as $element): ?>
16 |         <tr>
17 |           <td><?php echo __($element['element_name']); ?></td>
18 |           <td>
19 |             <?php
20 |               if (isset($element_types_info[$element['element_type']])) {
21 |                 echo __($element_types_info[$element['element_type']]['label']);
22 |               }
23 |             ?>
24 |           </td>
25 |           <td>
26 |               <a href="<?php echo url("element-types/index/edit/element_id/{$element['element_id']}"); ?>"><?php echo __('Modify'); ?></a>
27 |               <?php if (isset($element_types_info[$element['element_type']]['hooks']['OptionsForm'])): ?>
28 |                 | <a href="<?php echo url("element-types/index/edit-options/element_id/{$element['element_id']}"); ?>"><?php echo __('Configure'); ?></a>
29 |               <?php endif; ?>
30 |             </ul>
31 |           </td>
32 |         </tr>
33 |       <?php endforeach; ?>
34 |     <?php endforeach; ?>
35 |   </tbody>
36 | </table>
37 | 
38 | <?php echo foot(); ?>
39 | 


--------------------------------------------------------------------------------
/languages/template.pot:
--------------------------------------------------------------------------------
 1 | # Translation for the Element Types plugin for Omeka.
 2 | # Copyright (C) 2015 BibLibre
 3 | # This file is distributed under the same license as the Omeka package.
 4 | # Julian Maurice <julian.maurice@biblibre.com>, 2015
 5 | #
 6 | #, fuzzy
 7 | msgid ""
 8 | msgstr ""
 9 | "Project-Id-Version: ElementTypes\n"
10 | "Report-Msgid-Bugs-To: \n"
11 | "POT-Creation-Date: 2015-04-30 09:27+0000\n"
12 | "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
13 | "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
14 | "Language-Team: LANGUAGE <LL@li.org>\n"
15 | "Language: \n"
16 | "MIME-Version: 1.0\n"
17 | "Content-Type: text/plain; charset=UTF-8\n"
18 | "Content-Transfer-Encoding: 8bit\n"
19 | 
20 | #: controllers/IndexController.php:42 controllers/IndexController.php:81
21 | msgid "Successfully saved configuration"
22 | msgstr ""
23 | 
24 | #: views/admin/index/index.php:1 views/admin/index/edit-options.php:1
25 | #: views/admin/index/edit.php:1
26 | msgid "Element Types"
27 | msgstr ""
28 | 
29 | #: views/admin/index/index.php:7
30 | msgid "Element"
31 | msgstr ""
32 | 
33 | #: views/admin/index/index.php:9
34 | msgid "Actions"
35 | msgstr ""
36 | 
37 | #: views/admin/index/index.php:26
38 | msgid "Modify"
39 | msgstr ""
40 | 
41 | #: views/admin/index/edit-options.php:4
42 | #, php-format
43 | msgid "Configure type %1$s for element %2$s"
44 | msgstr ""
45 | 
46 | #: views/admin/index/edit-options.php:11 views/admin/index/edit.php:22
47 | msgid "Save"
48 | msgstr ""
49 | 
50 | #: views/admin/index/edit.php:4
51 | #, php-format
52 | msgid "Change type of element %s"
53 | msgstr ""
54 | 
55 | #: ElementTypesPlugin.php:165
56 | msgid "Element types"
57 | msgstr ""
58 | 
59 | #: ElementTypesPlugin.php:281
60 | msgid "See the list of all possible formats"
61 | msgstr ""
62 | 


--------------------------------------------------------------------------------
/languages/de_DE.po:
--------------------------------------------------------------------------------
 1 | # Translation for the Element Types plugin for Omeka.
 2 | # Copyright (C) 2015 BibLibre
 3 | # This file is distributed under the same license as the Omeka package.
 4 | # Julian Maurice <julian.maurice@biblibre.com>, 2015
 5 | #
 6 | msgid ""
 7 | msgstr ""
 8 | "Project-Id-Version: ElementTypes\n"
 9 | "Report-Msgid-Bugs-To: \n"
10 | "POT-Creation-Date: 2015-04-30 09:27+0000\n"
11 | "PO-Revision-Date: 2015-06-05 11:29+0100\n"
12 | "Last-Translator: \n"
13 | "Language-Team: \n"
14 | "Language: de_DE\n"
15 | "MIME-Version: 1.0\n"
16 | "Content-Type: text/plain; charset=UTF-8\n"
17 | "Content-Transfer-Encoding: 8bit\n"
18 | "X-Generator: Poedit 1.8.1\n"
19 | 
20 | #: controllers/IndexController.php:42 controllers/IndexController.php:81
21 | msgid "Successfully saved configuration"
22 | msgstr "Konfiguration erfolgreich gesichert"
23 | 
24 | #: views/admin/index/index.php:1 views/admin/index/edit-options.php:1
25 | #: views/admin/index/edit.php:1
26 | msgid "Element Types"
27 | msgstr "Elementtypen"
28 | 
29 | #: views/admin/index/index.php:7
30 | msgid "Element"
31 | msgstr "Objekt"
32 | 
33 | #: views/admin/index/index.php:9
34 | msgid "Actions"
35 | msgstr "Aktionen"
36 | 
37 | #: views/admin/index/index.php:26
38 | msgid "Modify"
39 | msgstr "Ändern"
40 | 
41 | #: views/admin/index/edit-options.php:4
42 | #, php-format
43 | msgid "Configure type %1$s for element %2$s"
44 | msgstr "Typ %1$s konfigurieren für Element %2$s"
45 | 
46 | #: views/admin/index/edit-options.php:11 views/admin/index/edit.php:22
47 | msgid "Save"
48 | msgstr "Speichern"
49 | 
50 | #: views/admin/index/edit.php:4
51 | #, php-format
52 | msgid "Change type of element %s"
53 | msgstr "Typ von Element %s ändern"
54 | 
55 | #: ElementTypesPlugin.php:165
56 | msgid "Element types"
57 | msgstr "Elementtypen"
58 | 
59 | #: ElementTypesPlugin.php:281
60 | msgid "See the list of all possible formats"
61 | msgstr "Liste aller verfügbaren Formate anzeigen"
62 | 


--------------------------------------------------------------------------------
/languages/fr.po:
--------------------------------------------------------------------------------
 1 | # Translation for the Element Types plugin for Omeka.
 2 | # Copyright (C) 2015 BibLibre
 3 | # This file is distributed under the same license as the Omeka package.
 4 | # Julian Maurice <julian.maurice@biblibre.com>, 2015
 5 | #
 6 | msgid ""
 7 | msgstr ""
 8 | "Project-Id-Version: ElementTypes\n"
 9 | "Report-Msgid-Bugs-To: \n"
10 | "POT-Creation-Date: 2015-04-30 09:27+0000\n"
11 | "PO-Revision-Date: 2015-05-22 13:10+0200\n"
12 | "Last-Translator: Julian Maurice <julian.maurice@biblibre.com>\n"
13 | "Language-Team: French\n"
14 | "Language: fr\n"
15 | "MIME-Version: 1.0\n"
16 | "Content-Type: text/plain; charset=UTF-8\n"
17 | "Content-Transfer-Encoding: 8bit\n"
18 | "Plural-Forms: nplurals=2; plural=(n > 1);\n"
19 | 
20 | #: controllers/IndexController.php:42 controllers/IndexController.php:81
21 | msgid "Successfully saved configuration"
22 | msgstr "Configuration enregistrée"
23 | 
24 | #: views/admin/index/index.php:1 views/admin/index/edit-options.php:1
25 | #: views/admin/index/edit.php:1
26 | msgid "Element Types"
27 | msgstr "Types d'élément"
28 | 
29 | #: views/admin/index/index.php:7
30 | msgid "Element"
31 | msgstr "Élément"
32 | 
33 | #: views/admin/index/index.php:9
34 | msgid "Actions"
35 | msgstr "Actions"
36 | 
37 | #: views/admin/index/index.php:26
38 | msgid "Modify"
39 | msgstr "Modifier"
40 | 
41 | #: views/admin/index/edit-options.php:4
42 | #, php-format
43 | msgid "Configure type %1$s for element %2$s"
44 | msgstr "Configurer le type %1$s pour l'élément %2$s"
45 | 
46 | #: views/admin/index/edit-options.php:11 views/admin/index/edit.php:22
47 | msgid "Save"
48 | msgstr "Enregistrer"
49 | 
50 | #: views/admin/index/edit.php:4
51 | #, php-format
52 | msgid "Change type of element %s"
53 | msgstr "Changer le type de l'élément %s"
54 | 
55 | #: ElementTypesPlugin.php:165
56 | msgid "Element types"
57 | msgstr "Types d'élément"
58 | 
59 | #: ElementTypesPlugin.php:281
60 | msgid "See the list of all possible formats"
61 | msgstr "Voir la liste de tous les formats possibles"
62 | 


--------------------------------------------------------------------------------
/controllers/IndexController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | class ElementTypes_IndexController extends Omeka_Controller_AbstractActionController
  4 | {
  5 |     /**
  6 |      * Configuration form.
  7 |      */
  8 |     public function indexAction()
  9 |     {
 10 |         $this->view->elements = $this->_getElements();
 11 |         $this->view->element_types_info = $this->_getElementTypesInfo();
 12 |     }
 13 | 
 14 |     public function editAction()
 15 |     {
 16 |         $element_id = $this->_getParam('element_id');
 17 |         $this->view->element = $this->_getElement($element_id);
 18 |         $this->view->element_type = $this->_getElementType($element_id);
 19 |         $this->view->element_types_info_options = $this->_getElementTypesInfoOptions();
 20 |     }
 21 | 
 22 |     /**
 23 |      * Save configuration and redirect to configuration form.
 24 |      */
 25 |     public function saveAction()
 26 |     {
 27 |         $element_id = $this->_getParam('element_id');
 28 |         $type = $this->_getParam('type');
 29 |         $element_type = $this->_getElementType($element_id);
 30 | 
 31 |         if ($type) {
 32 |             if (!isset($element_type)) {
 33 |                 $element_type = new ElementType;
 34 |                 $element_type->element_id = $element_id;
 35 |             }
 36 |             $element_type->element_type = $type;
 37 |             $element_type->save();
 38 |         } elseif (isset($element_type)) {
 39 |             $element_type->delete();
 40 |         }
 41 | 
 42 |         $this->_helper->flashMessenger(__('Successfully saved configuration'),
 43 |             'success');
 44 | 
 45 |         $this->_helper->redirector('index', 'index');
 46 |     }
 47 | 
 48 |     public function editOptionsAction() {
 49 |         $element_id = $this->_getParam('element_id');
 50 |         $element_type = $this->_getElementType($element_id);
 51 |         $element_type['element_type_options'] =
 52 |             json_decode($element_type['element_type_options'], TRUE);
 53 | 
 54 |         $hook = "element_types_{$element_type['element_type']}_OptionsForm";
 55 |         $this->view->options_form = get_plugin_hook_output($hook, array(
 56 |             'element_type' => $element_type,
 57 |         ));
 58 |         $this->view->element = $this->_getElement($element_id);
 59 |         $this->view->element_type = $element_type;
 60 |         $this->view->element_types = $this->_getElementTypesInfoOptions();
 61 |     }
 62 | 
 63 |     public function saveOptionsAction()
 64 |     {
 65 |         $params = $this->_getAllParams();
 66 |         $element_id = $params['element_id'];
 67 | 
 68 |         unset($params['element_id']);
 69 |         unset($params['admin']);
 70 |         unset($params['module']);
 71 |         unset($params['controller']);
 72 |         unset($params['action']);
 73 |         unset($params['save']);
 74 | 
 75 |         $element_type = $this->_getElementType($element_id);
 76 |         if (isset($element_type)) {
 77 |             $element_type->element_type_options = json_encode($params);
 78 |             $element_type->save();
 79 |         }
 80 | 
 81 |         $this->_helper->flashMessenger(__('Successfully saved configuration'),
 82 |             'success');
 83 | 
 84 |         $this->_helper->redirector('index', 'index');
 85 |     }
 86 | 
 87 |     /**
 88 |      * Returns all elements grouped by element sets
 89 |      */
 90 |     protected function _getElements()
 91 |     {
 92 |         $db = get_db();
 93 |         $sql = "
 94 |             SELECT
 95 |                 es.name AS element_set_name,
 96 |                 e.id AS element_id,
 97 |                 e.name AS element_name,
 98 |                 it.name AS item_type_name,
 99 |                 et.id AS element_type_id,
100 |                 et.element_type AS element_type,
101 |                 et.element_type_options AS element_type_options
102 |             FROM {$db->ElementSet} es
103 |                 JOIN {$db->Element} e ON es.id = e.element_set_id
104 |                 LEFT JOIN {$db->ItemTypesElements} ite ON e.id = ite.element_id
105 |                 LEFT JOIN {$db->ItemType} it ON ite.item_type_id = it.id
106 |                 LEFT JOIN {$db->ElementType} et ON e.id = et.element_id
107 |             WHERE es.record_type IS NULL
108 |               OR (es.record_type = 'Item' AND it.name IS NOT NULL)
109 |             ORDER BY es.name, it.name, e.name
110 |         ";
111 |         $elements = $db->fetchAll($sql);
112 |         $result = array();
113 |         foreach ($elements as $element) {
114 |             $group = $element['item_type_name']
115 |                 ? __('Item Type') . ': ' . __($element['item_type_name'])
116 |                 : __($element['element_set_name']);
117 |             $result[$group][] = $element;
118 |         }
119 |         return $result;
120 |     }
121 | 
122 |     protected function _getElementTypesInfo() {
123 |         return Zend_Registry::get('element_types_info');
124 |     }
125 | 
126 |     protected function _getElementTypesInfoOptions() {
127 |         $element_types = $this->_getElementTypesInfo();
128 |         $options = array('' => '');
129 |         foreach ($element_types as $key => $type) {
130 |             $options[$key] = __($type['label']);
131 |         }
132 |         return $options;
133 |     }
134 | 
135 |     protected function _getElementType($element_id) {
136 |         return get_db()
137 |             ->getTable('ElementType')
138 |             ->findByElementId($element_id);
139 |     }
140 | 
141 |     protected function _getElement($element_id) {
142 |         return get_db()
143 |             ->getTable('Element')
144 |             ->find($element_id);
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/ElementTypesPlugin.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * @file
  5 |  * Element Types plugin main file.
  6 |  */
  7 | 
  8 | /**
  9 |  * Element Types plugin main class.
 10 |  */
 11 | class ElementTypesPlugin extends Omeka_Plugin_AbstractPlugin
 12 | {
 13 |     protected $_hooks = array(
 14 |         'install',
 15 |         'uninstall',
 16 |         'upgrade',
 17 |         'initialize',
 18 |         'admin_head',
 19 |     );
 20 | 
 21 |     protected $_filters = array(
 22 |         'admin_navigation_main',
 23 |         'element_types_info',
 24 |     );
 25 | 
 26 |     /**
 27 |      * Create database table.
 28 |      */
 29 |     public function hookInstall() {
 30 |         $this->_installOptions();
 31 | 
 32 |         $db = $this->_db;
 33 |         $sql = "
 34 |             CREATE TABLE IF NOT EXISTS {$db->ElementType} (
 35 |                 id int(10) unsigned NOT NULL AUTO_INCREMENT,
 36 |                 element_id int(10) unsigned NOT NULL,
 37 |                 element_type varchar(255) NOT NULL,
 38 |                 element_type_options TEXT NULL DEFAULT NULL,
 39 |                 PRIMARY KEY (id),
 40 |                 FOREIGN KEY (element_id) REFERENCES {$db->Element} (id)
 41 |                     ON DELETE CASCADE ON UPDATE CASCADE
 42 |             ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
 43 |         ";
 44 |         $db->query($sql);
 45 |     }
 46 | 
 47 |     /**
 48 |      * Remove database table.
 49 |      */
 50 |     public function hookUninstall() {
 51 |         $this->_uninstallOptions();
 52 | 
 53 |         $db = $this->_db;
 54 |         $sql = "DROP TABLE IF EXISTS {$db->ElementType}";
 55 |         $db->query($sql);
 56 |     }
 57 | 
 58 |     public function hookUpgrade($args)
 59 |     {
 60 |         $old_version = $args['old_version'];
 61 |         $db = $this->_db;
 62 | 
 63 |         if (version_compare($old_version, '0.3', '<=')) {
 64 |             $table = $db->getTable('ElementText');
 65 |             $select = $table->getSelect()
 66 |                 ->join(array('et' => "{$db->ElementType}"),
 67 |                     'element_texts.element_id = et.element_id')
 68 |                 ->where('et.element_type = ?', 'date');
 69 |             $elementTexts = $table->fetchObjects($select);
 70 |             foreach ($elementTexts as $elementText) {
 71 |                 $text = $this->dateFilterFormat($elementText->text, array());
 72 |                 if (isset($text)) {
 73 |                     $elementText->text = $text;
 74 |                     $elementText->save();
 75 |                 }
 76 |             }
 77 | 
 78 |             $table = $db->getTable('ElementType');
 79 |             $elementTypes = $table->findByElementType('date');
 80 |             foreach ($elementTypes as $elementType) {
 81 |                 $elementType->element_type_options = json_encode(array('format' => ''));
 82 |                 $elementType->save();
 83 |             }
 84 |         }
 85 |     }
 86 | 
 87 |     /**
 88 |      * Set up plugins, translations, and filters
 89 |      */
 90 |     public function hookInitialize()
 91 |     {
 92 |         add_translation_source(dirname(__FILE__) . '/languages');
 93 | 
 94 |         $db = get_db();
 95 | 
 96 |         $element_types_info = apply_filters('element_types_info', array());
 97 |         Zend_Registry::set('element_types_info', $element_types_info);
 98 | 
 99 |         // Add filters
100 |         $filter_names = array(
101 |             'Display',
102 |             'ElementForm',
103 |             'ElementInput',
104 |             'Flatten',
105 |             'Save',
106 |             'Validate',
107 |             'Format',
108 |         );
109 |         $element_types = $db->getTable('ElementType')->findAll();
110 |         $element_types_by_id = array();
111 |         foreach ($element_types as $element_type) {
112 |             if (!isset($element_types_info[$element_type->element_type])) {
113 |                 continue;
114 |             };
115 | 
116 |             $element = $db->getTable('Element')->find($element_type->element_id);
117 |             $elementSet = $db->getTable('ElementSet')->find($element->element_set_id);
118 | 
119 |             foreach ($filter_names as $filter_name) {
120 |                 add_filter(
121 |                     array($filter_name, 'Item', $elementSet->name, $element->name),
122 |                     array($this, 'filter' . $filter_name)
123 |                 );
124 |                 add_filter(
125 |                     array($filter_name, 'Collection', $elementSet->name, $element->name),
126 |                     array($this, 'filter' . $filter_name)
127 |                 );
128 |             }
129 | 
130 | 
131 |             $element_types_by_id[$element_type->element_id] = $element_type;
132 |         }
133 |         Zend_Registry::set('element_types_by_id', $element_types_by_id);
134 | 
135 |         foreach ($element_types_info as $type => $element_type_info) {
136 |             if (isset($element_type_info['hooks'])) {
137 |                 foreach ($element_type_info['hooks'] as $key => $hook) {
138 |                     $hook_name = "element_types_{$type}_{$key}";
139 |                     add_plugin_hook($hook_name, $hook);
140 |                 }
141 |             }
142 |         }
143 |     }
144 | 
145 |     public function hookAdminHead($args) {
146 |         queue_js_file('date');
147 |     }
148 | 
149 |     /**
150 |      * Add an entry in the admin navigation menu.
151 |      */
152 |     public function filterAdminNavigationMain($nav)
153 |     {
154 |         $nav[] = array(
155 |             'label' => __('Element types'),
156 |             'uri' => url('element-types'),
157 |         );
158 |         return $nav;
159 |     }
160 | 
161 |     public function filterElementTypesInfo($types) {
162 |         $types['date'] = array(
163 |             'label' => __('Date'),
164 |             'filters' => array(
165 |                 'ElementInput' => array($this, 'dateFilterElementInput'),
166 |                 'Save' => array($this, 'dateFilterSave'),
167 |                 'Validate' => array($this, 'dateFilterValidate'),
168 |                 'Display' => array($this, 'dateFilterDisplay'),
169 |                 'Format' => array($this, 'dateFilterFormat'),
170 |             ),
171 |             'hooks' => array(
172 |                 'OptionsForm' => array($this, 'dateHookOptionsForm'),
173 |             ),
174 |         );
175 |         return $types;
176 |     }
177 | 
178 |     public function filterDisplay($text, $args) {
179 |         if (!$args['element_text']) {
180 |             return $text;
181 |         }
182 | 
183 |         $element_id = $args['element_text']->element_id;
184 |         return $this->_applyFilters('Display', $element_id, $text, $args);
185 |     }
186 | 
187 |     public function filterElementForm($components, $args) {
188 |         $element_id = $args['element']->id;
189 |         return $this->_applyFilters('ElementForm', $element_id, $components, $args);
190 |     }
191 | 
192 |     public function filterElementInput($components, $args) {
193 |         $element_id = $args['element']->id;
194 |         return $this->_applyFilters('ElementInput', $element_id, $components, $args);
195 |     }
196 | 
197 |     public function filterFlatten($flatText, $args) {
198 |         $element_id = $args['element']->id;
199 |         return $this->_applyFilters('Flatten', $element_id, $flatText, $args);
200 |     }
201 | 
202 |     public function filterSave($text, $args) {
203 |         $element_id = $args['element']->id;
204 |         return $this->_applyFilters('Save', $element_id, $text, $args);
205 |     }
206 | 
207 |     public function filterValidate($isValid, $args) {
208 |         $element_id = $args['element']->id;
209 |         return $this->_applyFilters('Validate', $element_id, $isValid, $args);
210 |     }
211 | 
212 |     public function filterFormat($value, $args) {
213 |         $element_id = $args['element']->id;
214 |         return $this->_applyFilters('Format', $element_id, $value, $args);
215 |     }
216 | 
217 |     protected function _applyFilters($name, $element_id, $value, $args) {
218 |         $element_types_info = Zend_Registry::get('element_types_info');
219 |         $element_types_by_id = Zend_Registry::get('element_types_by_id');
220 |         $element_type = $element_types_by_id[$element_id];
221 | 
222 |         $type = $element_type['element_type'];
223 |         if (!isset($element_types_info[$type]['filters'][$name])) {
224 |             return $value;
225 |         }
226 | 
227 |         $filter = $element_types_info[$type]['filters'][$name];
228 |         $args['element_type_options'] = json_decode(
229 |             $element_type['element_type_options'], TRUE);
230 | 
231 |         return call_user_func($filter, $value, $args);
232 |     }
233 | 
234 | 
235 |     // Date type callbacks //
236 | 
237 |     public function dateFilterElementInput($components, $args)
238 |     {
239 |         $view = get_view();
240 |         $element = $args['element'];
241 |         $element_id = $element->id;
242 |         $index = $args['index'];
243 |         $name = "Elements[$element_id][$index][text]";
244 |         $format = $args['element_type_options']['format'];
245 |         $value = $this->dateFilterDisplay($args['value'], $args);
246 |         $components['input'] = $view->formText($name, $value, array(
247 |             'data-type' => 'date',
248 |             'data-format' => $this->_phpToDatepickerFormat($format),
249 |         ));
250 |         $components['html_checkbox'] = NULL;
251 |         return $components;
252 |     }
253 | 
254 |     public function dateFilterSave($text, $args)
255 |     {
256 |         $format = $args['element_type_options']['format'];
257 |         $format = $format ? $format : 'Y-m-d';
258 | 
259 |         $dt = DateTime::createFromFormat($format, $text);
260 |         if ($dt) {
261 |             return $dt->format('Y-m-d');
262 |         }
263 | 
264 |         return $text;
265 |     }
266 | 
267 |     public function dateFilterValidate($isValid, $args)
268 |     {
269 |         $dt = DateTime::createFromFormat('Y-m-d', $args['text']);
270 | 
271 |         return $dt ? true : false;
272 |     }
273 | 
274 |     public function dateFilterDisplay($text, $args)
275 |     {
276 |         $format = $args['element_type_options']['format'];
277 |         $format = $format ? $format : 'Y-m-d';
278 | 
279 |         $dt = DateTime::createFromFormat('Y-m-d', $text);
280 |         if ($dt) {
281 |             return $dt->format($format);
282 |         }
283 | 
284 |         return '';
285 |     }
286 | 
287 |     public function dateFilterFormat($value, $args)
288 |     {
289 |         $format = $args['element_type_options']['format'];
290 |         $format = $format ? $format : 'Y-m-d';
291 | 
292 |         $dt = DateTime::createFromFormat($format, $value);
293 |         if ($dt) {
294 |             return $dt->format('Y-m-d');
295 |         }
296 | 
297 |         $time = strtotime($value);
298 |         if ($time) {
299 |             return date('Y-m-d', $time);
300 |         }
301 | 
302 |         return null;
303 |     }
304 | 
305 |     public function dateHookOptionsForm($args) {
306 |         $view = get_view();
307 |         $options = $args['element_type']['element_type_options'];
308 |         print $view->formLabel('format', __('Format')) . ' ';
309 |         print $view->formText(
310 |             'format',
311 |             isset($options) ? $options['format'] : ''
312 |         );
313 |         print ' <span>(' . __('Example:') . ' Y-m-d)</span>';
314 |         print
315 |             '<h2>' . __('Possible formats') . '</h2>'
316 |             . '<table>'
317 |             . '  <tbody>'
318 |             . '    <tr><td>j</td><td>' . __('Day of month') . '</td></tr>'
319 |             . '    <tr><td>d</td><td>' . __('Day of month (with padding zero)') . '</td></tr>'
320 |             . '    <tr><td>z</td><td>' . __('Day of year') . '</td></tr>'
321 |             . '    <tr><td>D</td><td>' . __('Day name (short)') . '</td></tr>'
322 |             . '    <tr><td>l</td><td>' . __('Day name (long)') . '</td></tr>'
323 |             . '    <tr><td>n</td><td>' . __('Month of year') . '</td></tr>'
324 |             . '    <tr><td>m</td><td>' . __('Month of year (with padding zero)') . '</td></tr>'
325 |             . '    <tr><td>M</td><td>' . __('Month name (short)') . '</td></tr>'
326 |             . '    <tr><td>F</td><td>' . __('Month name (long)') . '</td></tr>'
327 |             . '    <tr><td>y</td><td>' . __('Year (2 digits)') . '</td></tr>'
328 |             . '    <tr><td>Y</td><td>' . __('Year (4 digits)') . '</td></tr>'
329 |             . '  </tbody>'
330 |             . '</table>';
331 |     }
332 | 
333 |     protected function _phpToDatepickerFormat($format)
334 |     {
335 |         $chars = str_split($format);
336 |         $escaped = false;
337 |         $dpFormat = '';
338 |         foreach ($chars as $c) {
339 |             if ($escaped) {
340 |                 $dpFormat .= $c == "'" ? "''" : "'$c'";
341 |                 $escaped = false;
342 |                 continue;
343 |             }
344 | 
345 |             switch ($c) {
346 |                 case 'j': $dpFormat .= 'd';  break;  // day of month
347 |                 case 'd': $dpFormat .= 'dd'; break;  // day of month with 0
348 |                 case 'z': $dpFormat .= 'o';  break;  // day of year
349 |                 case 'D': $dpFormat .= 'D';  break;  // day name short
350 |                 case 'l': $dpFormat .= 'DD'; break;  // day name long
351 |                 case 'n': $dpFormat .= 'm';  break;  // month of year
352 |                 case 'm': $dpFormat .= 'mm'; break;  // month of year with 0
353 |                 case 'M': $dpFormat .= 'M';  break;  // month name short
354 |                 case 'F': $dpFormat .= 'MM'; break;  // month name long
355 |                 case 'y': $dpFormat .= 'y';  break;  // year (2 digits)
356 |                 case 'Y': $dpFormat .= 'yy'; break;  // year (4 digits)
357 | 
358 |                 case "'": $dpFormat .= "''"; break;  // single quote
359 |                 case "\\": $escaped = true;  break;
360 | 
361 |                 default: $dpFormat .= "'$c'";
362 |             }
363 |         }
364 |         return $dpFormat;
365 |     }
366 | }
367 | 
368 | function element_types_format($element_id, $value)
369 | {
370 |     $db = get_db();
371 |     $element = $db->getTable('Element')->find($element_id);
372 |     $elementSet = $db->getTable('ElementSet')->find($element->element_set_id);
373 |     $filter = array('Format', 'Item', $elementSet->name, $element->name);
374 |     return apply_filters($filter, $value, array('element' => $element));
375 | }
376 | 


--------------------------------------------------------------------------------