├── .travis.yml
├── client-side
    └── dependentSelectBox.js
├── composer.json
├── doc
    └── index.md
├── license.md
├── readme.md
├── src
    ├── Controls
    │   ├── DependentMultiSelectBox.php
    │   └── DependentSelectBox.php
    ├── DependentData.php
    ├── DependentExtension.php
    ├── DependentTrait.php
    ├── Exceptions.php
    ├── _Controls.BackCompatibility.php
    └── _DI.BackCompatibility.php
└── tests
    ├── .coveralls.yml
    ├── app
        ├── presenters
        │   ├── BasePresenter.php
        │   └── templates
        │   │   ├── Base.dependentMultiSelect1.latte
        │   │   ├── Base.dependentMultiSelect2.latte
        │   │   ├── Base.dependentSelect1.latte
        │   │   └── Base.dependentSelect2.latte
        └── router
        │   └── Router.php
    ├── bootstrap.php
    └── tests
        ├── DependentDataTest.phpt
        ├── DependentMultiSelectBoxTest.phpt
        └── DependentSelectBoxTest.phpt


/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |     - 5.6
 5 |     - 7.0
 6 |     - 7.1
 7 |     - 7.2
 8 |     - 7.3
 9 |     - 7.4
10 |     - 8.0
11 | 
12 | install:
13 |     - travis_retry composer install --no-interaction --no-progress
14 | 
15 | script:
16 |     - vendor/bin/tester tests -s
17 | 
18 | after_failure:
19 |     - for i in $(find tests -name \*.expected); do echo "--- $i"; cat $i; echo; echo; done
20 |     - for i in $(find tests -name \*.actual); do echo "--- $i"; cat $i; echo; echo; done
21 | 
22 | jobs:
23 |     include:
24 |         -   env: title="Lowest Dependencies"
25 |             install:
26 |                     - travis_retry composer update --no-interaction --no-progress --prefer-lowest --prefer-stable
27 | 
28 |         -   stage: Code Standard Checker
29 |             php: 7.1
30 |             install:
31 |                 - travis_retry composer create-project nette/code-checker temp/code-checker --no-interaction --no-progress
32 |                 - travis_retry composer create-project nette/coding-standard temp/coding-standard --no-interaction --no-progress
33 | 
34 |             script:
35 |                 - php temp/code-checker/src/code-checker.php --short-arrays
36 |                 - php temp/coding-standard/ecs check src tests --config temp/coding-standard/coding-standard-php56.neon
37 | 
38 |         -   stage: Code Coverage
39 |             php: 7.1
40 |             script:
41 |                 - vendor/bin/tester -p phpdbg tests -s --coverage ./coverage.xml --coverage-src ./src
42 | 
43 |             after_script:
44 |                 - wget https://github.com/satooshi/php-coveralls/releases/download/v1.0.1/coveralls.phar
45 |                 - php coveralls.phar --verbose --config tests/.coveralls.yml
46 | 
47 |     allow_failures:
48 |         - stage: Code Coverage
49 | 
50 | sudo: false
51 | 
52 | cache:
53 |     directories:
54 |         - $HOME/.composer/cache
55 | 
56 | notifications:
57 |     email: false
58 | 


--------------------------------------------------------------------------------
/client-side/dependentSelectBox.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * DependentSelectBox
  3 |  * @author Dusan Hudak <admin@dusan-hudak.com>
  4 |  */
  5 | 
  6 | (function ($) {
  7 | 	$.fn.dependentSelectBox = function (options, listener) {
  8 | 
  9 | 		var callback = function () {};
 10 | 		if(typeof( options ) === 'function' ) {
 11 | 			callback = options;
 12 | 			options = null;
 13 | 		}
 14 | 		if(typeof( listener ) === 'function' ) {
 15 | 			callback = listener;
 16 | 		}
 17 | 
 18 | 		var dsb = this;
 19 | 		dsb.timeout = [];
 20 | 		dsb.settings = $.extend({
 21 | 			suggestTimeout: 350,
 22 | 			dataLinkName: 'dependentselectbox',
 23 | 			dataParentsName: 'dependentselectboxParents',
 24 | 			dataParamsName: 'dependentselectboxParams'
 25 | 		}, options);
 26 | 
 27 | 
 28 | 		/**
 29 | 		 * Get link to signal
 30 | 		 * @param element
 31 | 		 * @returns {*}
 32 | 		 */
 33 | 		this.getSignalLink = function (element) {
 34 | 			var signalLink = element.data(dsb.settings.dataLinkName);
 35 | 			var params = element.data(dsb.settings.dataParamsName);
 36 | 
 37 | 			if (signalLink === undefined) {
 38 | 				return false;
 39 | 			}
 40 | 
 41 | 			$.each(params, function (name, id) {
 42 | 				var paramElement = $('#' + id);
 43 | 
 44 | 				if (paramElement.length > 0) {
 45 | 					var val;
 46 | 
 47 | 					if (paramElement.prop('type') === 'checkbox') {
 48 | 						val = paramElement.prop('checked') ? 1 : 0;
 49 | 
 50 | 					} else {
 51 | 						val = $(paramElement).val();
 52 | 						if (!val) {
 53 | 							return;
 54 | 						}
 55 | 					}
 56 | 
 57 | 
 58 | 					if (val instanceof Array) {
 59 | 						$.each(val, function (key, value) {
 60 | 							signalLink += '&' + name + '[]=' + value;
 61 | 						});
 62 | 
 63 | 					} else {
 64 | 						signalLink += '&' + name + '=' + val;
 65 | 					}
 66 | 				}
 67 | 			});
 68 | 
 69 | 			return signalLink;
 70 | 		};
 71 | 
 72 | 
 73 | 		/**
 74 | 		 * process
 75 | 		 * @param e
 76 | 		 * @param parentElement
 77 | 		 */
 78 | 		this.process = function (e, parentElement, dependentSelect) {
 79 | 
 80 | 			// Validate if signalLink exist
 81 | 			var signalLink = dsb.getSignalLink(dependentSelect);
 82 | 			if (signalLink == false) {
 83 | 				return false;
 84 | 			}
 85 | 			// skip cascaded data loading if parentEl is not yet set, empty dependentSelect & add empty prompt
 86 | 			var parentElVal = parentElement.val();
 87 | 			if (!parentElVal) {
 88 | 				dependentSelect.empty().append('<option value="" />').change();
 89 | 				dependentSelect.selectpicker && dependentSelect.selectpicker('refresh');
 90 | 				return false;
 91 | 			}
 92 | 			// Send ajax request
 93 | 			$.ajax(signalLink, {
 94 | 				async: false,
 95 | 				success: function (payload) {
 96 | 					var data = payload.dependentselectbox;
 97 | 					if (data !== undefined) {
 98 | 
 99 | 						var $select = $('#' + data.id);
100 | 						$select.empty();
101 | 
102 | 						// prompt set
103 | 						if (data.prompt !== false && data.prompt !== undefined) {
104 | 							$('<option>').attr('value', '').text(data.prompt).appendTo($select);
105 | 						}
106 | 
107 | 						if (Object.keys(data.items).length > 0) {
108 | 							// set disabled, when control haven not choices
109 | 							if (data.disabledWhenEmpty === true) {
110 | 								$select.prop('disabled', false);
111 | 							}
112 | 
113 | 							$.each(data.items, function (i, item) {
114 | 
115 | 								if (typeof item.value === 'object') {
116 | 									var otpGroup = $('<optgroup>')
117 | 										.attr('label', item.key);
118 | 
119 | 									$.each(item.value, function (objI, objItem) {
120 | 										var option = $('<option>')
121 | 											.attr('value', objI).text(objItem.value);
122 | 										if (data.value !== null && objI == data.value) {
123 | 											option.attr('selected', true);
124 | 										}
125 | 										otpGroup.append(option);
126 | 									});
127 | 									otpGroup.appendTo($select);
128 | 								}
129 | 								else {
130 | 									var option = $('<option>')
131 | 										.attr('value', item.key).text(item.value);
132 | 
133 | 									if ('attributes' in item) {
134 | 										$.each(item.attributes, function (attr, attrValue) {
135 | 											option.attr(attr, attrValue);
136 | 										});
137 | 									}
138 | 
139 | 									if (data.value !== null && item.key == data.value) {
140 | 										option.attr('selected', true);
141 | 									}
142 | 
143 | 									option.appendTo($select);
144 | 								}
145 | 
146 | 
147 | 
148 | 							});
149 | 						} else {
150 | 							if (data.disabledWhenEmpty) {
151 | 								$select.prop('disabled', true);
152 | 							}
153 | 						}
154 | 
155 | 						$select.change();
156 | 					}
157 | 				},
158 | 				complete: callback
159 | 			});
160 | 		};
161 | 
162 | 
163 | 		/**
164 | 		 * Event onChange
165 | 		 * @param e
166 | 		 * @param parentElement
167 | 		 * @returns {boolean}
168 | 		 */
169 | 		this.onChange = function (e, parentElement, dependentSelect) {
170 | 			dsb.process(e, parentElement, dependentSelect);
171 | 		};
172 | 
173 | 
174 | 		/**
175 | 		 * Event onKeyup
176 | 		 * @param e
177 | 		 * @param parentElement
178 | 		 * @returns {boolean}
179 | 		 */
180 | 		this.onKeyup = function (e, parentElement, dependentSelect) {
181 | 			// reset timeout
182 | 			var timeoutKey = dependentSelect.attr('id');
183 | 			if (dsb.timeout[timeoutKey] != undefined && dsb.timeout[timeoutKey] != false) {
184 | 				clearTimeout(dsb.timeout[timeoutKey]);
185 | 			}
186 | 
187 | 			dsb.timeout[timeoutKey] = setTimeout(function () {
188 | 				dsb.process(e, parentElement, dependentSelect);
189 | 			}, dsb.settings.suggestTimeout);
190 | 		};
191 | 
192 | 		/**
193 | 		 * Process
194 | 		 */
195 | 		return this.each(function () {
196 | 			var $dependentSelect = $(this);
197 | 
198 | 			var parents = $($dependentSelect).data(dsb.settings.dataParentsName);
199 | 			$.each(parents, function (name, id) {
200 | 				var parentElement = $('#' + id);
201 | 
202 | 				if (parentElement.length > 0) {
203 | 					if (parentElement.prop('type') === 'text' || parentElement.prop('nodeName').toLowerCase() === 'textarea') {
204 | 						$(parentElement).on("keyup", function (e) {
205 | 							dsb.onKeyup(e, $(this), $dependentSelect);
206 | 						});
207 | 					} else {
208 | 						$(parentElement).on("change", function (e) {
209 | 							dsb.onChange(e, $(this), $dependentSelect);
210 | 						});
211 | 					}
212 | 				}
213 | 			});
214 | 		});
215 | 	};
216 | })(jQuery);
217 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "nasext/dependent-select-box",
 3 | 	"type": "library",
 4 | 	"description": "Dependent Select Box for Nette Framework.",
 5 | 	"keywords": ["nette", "nasext", "DependentSelectBox"],
 6 | 	"license": ["MIT"],
 7 | 	"authors": [
 8 | 		{
 9 | 			"name": "Dusan Hudak"
10 | 		},
11 | 		{
12 | 			"name": "Jáchym Toušek"
13 | 		},
14 | 		{
15 | 			"name": "Ales Wita",
16 | 			"email": "aleswita+github@gmail.com"
17 | 		}
18 | 	],
19 | 	"require": {
20 | 		"php": ">=7.1",
21 | 		"nette/application": "^2.4 || ^3.0.0",
22 | 		"nette/forms": "^3.1.0",
23 | 		"nette/utils": "^2.4 || ^3.0.0 || ^4.0.0"
24 | 	},
25 | 	"require-dev": {
26 | 		"nette/di": "^2.4.6 || ^3.0.0",
27 | 		"nette/robot-loader": "^2.4 || ^3.0.0 || ^4.0.0",
28 | 		"nette/bootstrap": "^2.4 || ^3.0.0",
29 | 		"nette/http": "^2.4 || ^3.0.0",
30 | 		"tracy/tracy": "^2.4 || ^3.0.0",
31 | 		"nette/tester": "^2.0",
32 | 		"latte/latte": "^2.4 || ^3.0.0"
33 | 	},
34 | 	"autoload": {
35 | 		"classmap": ["src/"]
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/doc/index.md:
--------------------------------------------------------------------------------
  1 | # NasExt/DependentSelectBox
  2 | DependentSelectBox for [Nette Framework](https://nette.org). This dependent select box support dependence for more form controls , not only for select boxes but also dependence for text input, textarea and more.
  3 | 
  4 | ## Installation
  5 | The best way to install NasExt/DependentSelectBox is using [Composer](http://getcomposer.org/):
  6 | ```sh
  7 | $ composer require nasext/dependent-select-box
  8 | ```
  9 | 
 10 | 
 11 | Initialization in your `bootstrap.php`:
 12 | ```php
 13 | NasExt\Forms\DependentExtension::registerControls();
 14 | ```
 15 | 
 16 | 
 17 | Or enable the extension using your neon config:
 18 | ```neon
 19 | extensions:
 20 | 	dependentSelectBox: NasExt\Forms\DependentExtension
 21 | ```
 22 | 
 23 | 
 24 | Include from client-side folder:
 25 | ```
 26 | dependentSelectBox.js
 27 | ```
 28 | 
 29 | 
 30 | Initialize DependentSelectBox:
 31 | ```js
 32 | // @param callback a handler to be called when Ajax requests complete
 33 | $('[data-dependentselectbox]').dependentSelectBox(callback);
 34 | ```
 35 | 
 36 | 
 37 | ## Usage
 38 | How to use DependentSelectBox in form:
 39 | ```php
 40 | $form->addDependentSelectBox('name', 'Label', $dependentControl1, $dependentControl2, ...)
 41 | 	->setDependentCallback(function ($values) {
 42 | 		return new \NasExt\Forms\DependentData(items, value, prompt);
 43 | 	})
 44 | ```
 45 | 
 46 | 
 47 | ```php
 48 | $country = [
 49 | 	1 => 'Slovakia',
 50 | 	2 => 'Czechia',
 51 | 	3 => 'USA',
 52 | ];
 53 | 
 54 | $citySlovakia = [
 55 | 	1 => 'Bratislaba',
 56 | 	2 => 'Kosice',
 57 | 	3 => 'Zilina',
 58 | ];
 59 | 
 60 | $cityCzechia = [
 61 | 	1 => 'Praha',
 62 | 	2 => 'Brno',
 63 | 	3 => 'Ostrava',
 64 | ];
 65 | 
 66 | $cityUsa = [
 67 | 	1 => 'Toronto',
 68 | 	2 => 'Philadelphia',
 69 | 	3 => 'Boston',
 70 | ];
 71 | 
 72 | $street1 = [
 73 | 	1 => 'street1-1',
 74 | 	2 => 'street1-2',
 75 | 	3 => 'street1-3',
 76 | ];
 77 | 
 78 | $street2 = [
 79 | 	1 => 'street2-1',
 80 | 	2 => 'street2-2',
 81 | 	3 => 'street2-3',
 82 | ];
 83 | 
 84 | $street3 = [
 85 | 	1 => 'street3-1',
 86 | 	2 => 'street3-2',
 87 | 	3 => 'street3-3',
 88 | ];
 89 | 
 90 | 
 91 | $form->addSelect('country', 'Country', $country)
 92 | 	->setPrompt('--- Select ---');
 93 | 
 94 | $form->addText('text', 'Text')
 95 | 	->setAttribute('placeholder', 'Text');
 96 | 
 97 | $form->addDependentSelectBox('city', 'City', $form['country'])
 98 | 	->setDependentCallback(function ($values) use ($citySlovakia, $cityCzechia, $cityUsa) {
 99 | 		$data = new \NasExt\Forms\DependentData;
100 | 
101 | 		if ($values['country'] === 1) {
102 | 			$data->setItems($citySlovakia)->setPrompt('---');
103 | 
104 | 		} elseif ($values['country'] === 2) {
105 | 			$data->setItems($cityCzechia)->setPrompt('---');
106 | 
107 | 		} elseif ($values['country'] === 3) {
108 | 			$data->setItems($cityUsa)->setPrompt('---');
109 | 		}
110 | 
111 | 		return $data;
112 | 	})
113 | 	->setPrompt('--- Select country first ---');
114 | 
115 | $form->addDependentSelectBox('street', 'Street', $form['city'], $form['text'])
116 | 	->setDependentCallback(function ($values) use ($street1, $street2, $street3) {
117 | 		$data = new \NasExt\Forms\DependentData;
118 | 
119 | 		if ($values['city'] === 1) {
120 | 			if (!empty($values['text'])) {
121 | 				$street1 = array_merge($street1, [10 => 'Value from Text input: ' . $values['text']]);
122 | 			}
123 | 
124 | 			$data->setItems($street1);
125 | 
126 | 		} elseif ($values['city'] === 2) {
127 | 			if (!empty($values['text'])) {
128 | 				$street2 = array_merge($street2, [10 => 'Value from Text input: ' . $values['text']]);
129 | 			}
130 | 
131 | 			$data->setItems($street2);
132 | 
133 | 		} elseif ($values['city'] === 3) {
134 | 			if (!empty($values['text'])) {
135 | 				$street3 = array_merge($street3, [10 => 'Value from Text input: ' . $values['text']]);
136 | 			}
137 | 
138 | 			$data->setItems($street3);
139 | 
140 | 
141 | 		return $data;
142 | 	})
143 | 	->setPrompt('--- Select ---');
144 | 
145 | // alternative with callback params
146 | /* set callback params if the control should not be reloaded after change of any parents/params .. e.g. if control is dependant on another control3,
147 | 	which is dependant on control2 and that is dependant on control1, we should set parent(control3) and params(control1, control2, control3) in this order.
148 | 	Note, control3 has to be set within `params` as well (the order is important)
149 | 	If, however, control should reload after change of any depending control, we set all those controls as parents(control1, control2, control3) in this order
150 |  order of params matters! as the control values are being set in that order, thus the allowed items for that particular control are being loaded based
151 |  on passed params.. otherwise we would have to call `->checkDefaultValue(false)` on those dependent controls
152 | */
153 | $form->addDependentSelectBox('street', 'Street', $form['city'])
154 | 	->setDependentCallbackParams([$form['city'], $form['text']])
155 | 	->setDependentCallback(function ($values) use ($street1, $street2, $street3) {
156 | 		$data = new \NasExt\Forms\DependentData;
157 | 		if ($values['city'] === 1 && !empty($values['text'])) {
158 | 			$data->setItems($street1);
159 | 		}
160 | 		return $data;
161 | 	})
162 | 	->setPrompt('--- Select ---');
163 | 
164 | ```
165 | 
166 | 
167 | You can set the select box as disabled with `setDisabledWhenEmpty(true)` when empty, but remember, a disabled select box does not support validation.
168 | ```php
169 | $form->addDependentSelectBox('city', 'City', $form['country'])
170 | 	->setDependentCallback(function ($values) use ($citySlovakia, $cityCzechia, $cityUsa) {
171 | 		$data = new \NasExt\Forms\Controls\DependentSelectBoxData;
172 | 
173 | 		if ($values['country'] === 1) {
174 | 			$data->setItems($citySlovakia);
175 | 
176 | 		} elseif ($values['country'] === 2) {
177 | 			$data->setItems($cityCzechia);
178 | 
179 | 		} elseif ($values['country'] === 3) {
180 | 			$data->setItems($cityUsa);
181 | 		}
182 | 
183 | 		return $data;
184 | 	})
185 | 	->setDisabledWhenEmpty(true)
186 | 	->setPrompt('--- Select ---');
187 | ```
188 | 


--------------------------------------------------------------------------------
/license.md:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Dependent Select Box
 2 | Dependent Select Box for [Nette Framework](https://nette.org) and PHP 5.6.0 or higher.
 3 | 
 4 | [![Build Status](https://travis-ci.org/NasExt/DependentSelectBox.svg?branch=master)](https://travis-ci.org/NasExt/DependentSelectBox)
 5 | [![Coverage Status](https://coveralls.io/repos/github/NasExt/DependentSelectBox/badge.svg?branch=master)](https://coveralls.io/github/NasExt/DependentSelectBox?branch=master)
 6 | 
 7 | ## Installation
 8 | The best way to install NasExt/DependentSelectBox is using [Composer](http://getcomposer.org/):
 9 | ```sh
10 | $ composer require nasext/dependent-select-box
11 | ```
12 | 
13 | 
14 | ## Documentation
15 | Learn more in the [documentation](https://github.com/NasExt/DependentSelectBox/blob/master/doc/index.md).
16 | 


--------------------------------------------------------------------------------
/src/Controls/DependentMultiSelectBox.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  */
 11 | 
 12 | namespace NasExt\Forms\Controls;
 13 | 
 14 | use NasExt;
 15 | use Nette;
 16 | 
 17 | 
 18 | /**
 19 |  * @author Jáchym Toušek
 20 |  * @author Dusan Hudak
 21 |  * @author Ales Wita
 22 |  * @license MIT
 23 |  */
 24 | class DependentMultiSelectBox extends Nette\Forms\Controls\MultiSelectBox implements Nette\Application\UI\ISignalReceiver
 25 | {
 26 | 	use NasExt\Forms\DependentTrait {
 27 | 	    getValue as protected traitGetValue;
 28 |     }
 29 | 
 30 | 	/** @var string */
 31 | 	const SIGNAL_NAME = DependentSelectBox::SIGNAL_NAME;
 32 | 
 33 | 
 34 | 	/**
 35 | 	 * @param string $label
 36 | 	 * @param array<int, Nette\Forms\Control> $parents
 37 | 	 */
 38 | 	public function __construct($label, array $parents)
 39 | 	{
 40 | 		$this->parents = $parents;
 41 | 		$this->dependentCallbackParams = $this->parents;//default
 42 | 		parent::__construct($label);
 43 | 	}
 44 | 
 45 | 
 46 | 	/**
 47 | 	 * @throws $value
 48 | 	 * @param bool
 49 | 	 * @return self
 50 | 	 */
 51 | 	public function setDisabled($value = true)
 52 | 	{
 53 | 		if (is_array($value)) {
 54 | 			throw new Nette\InvalidArgumentException('NasExt\\Forms\\Controls\\DependentMultiSelectBox not supported disabled items!');
 55 | 		}
 56 | 
 57 | 		return parent::setDisabled($value);
 58 | 	}
 59 | 
 60 | 
 61 | 	/**
 62 | 	 * @return array
 63 |      	 */
 64 | 	public function getValue(): array
 65 | 	{
 66 | 		return $this->traitGetValue();
 67 | 	}
 68 | 
 69 | 
 70 |     	/**
 71 | 	 * @param string $signal
 72 | 	 * @return void
 73 | 	 */
 74 | 	public function signalReceived(string $signal) : void
 75 | 	{
 76 | 		$presenter = $this->lookup('Nette\\Application\\UI\\Presenter');
 77 | 
 78 | 		if ($presenter->isAjax() && $signal === self::SIGNAL_NAME && !$this->isDisabled()) {
 79 | 			$cbParamNames = [];
 80 | 			foreach ($this->dependentCallbackParams as $param) {
 81 | 				$value = $presenter->getParameter($this->getNormalizeName($param));
 82 | 
 83 | 				if ($param instanceof Nette\Forms\Controls\MultiChoiceControl) {
 84 | 					if (is_string($value)) {
 85 | 						$value = explode(',', $value);
 86 | 					}
 87 | 					if ($value !== null) {
 88 | 						$value = array_filter($value, static function ($val) {return !in_array($val, [null, '', []], true);});
 89 | 					}
 90 | 				}
 91 | 
 92 | 				$param->setValue($value);
 93 | 
 94 | 				$cbParamNames[$param->getName()] = $param->getValue();
 95 | 			}
 96 | 
 97 | 			$data = $this->getDependentData([$cbParamNames]);
 98 | 			$presenter->payload->dependentselectbox = [
 99 | 				'id' => $this->getHtmlId(),
100 | 				'items' => $data->getPreparedItems(!is_array($this->disabled) ?: $this->disabled),
101 | 				'value' => $data->getValue(),
102 | 				'prompt' => false,
103 | 				'disabledWhenEmpty' => $this->disabledWhenEmpty,
104 | 			];
105 | 
106 | 			$presenter->sendPayload();
107 | 		}
108 | 	}
109 | 
110 | 
111 | 	/**
112 | 	 * @return void
113 | 	 */
114 | 	private function tryLoadItems()
115 | 	{
116 | 		if ($this->dependentCallbackParams === array_filter($this->dependentCallbackParams, function ($p) {return !$p->hasErrors();})) {
117 | 			$cbParamValues = [];
118 | 			foreach ($this->dependentCallbackParams as $param) {
119 | 				$cbParamValues[$param->getName()] = $param->getValue();
120 | 			}
121 | 
122 | 			$data = $this->getDependentData([$cbParamValues]);
123 | 			$items = $data->getItems();
124 | 
125 | 			if ($this->getForm()->isSubmitted()) {
126 | 				$this->setValue($this->value);
127 | 
128 | 			} elseif ($this->tempValue !== null) {
129 | 				$this->setValue($this->tempValue);
130 | 
131 | 			} else {
132 | 				$this->setValue($data->getValue());
133 | 			}
134 | 
135 | 
136 | 			$this->loadHttpData();
137 | 			$this->setItems($items);
138 | 
139 | 			if (count($items) === 0) {
140 | 				if ($this->disabledWhenEmpty === true && !$this->isDisabled()) {
141 | 					$this->setDisabled();
142 | 				}
143 | 			}
144 | 		}
145 | 	}
146 | }
147 | 


--------------------------------------------------------------------------------
/src/Controls/DependentSelectBox.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  */
 11 | 
 12 | namespace NasExt\Forms\Controls;
 13 | 
 14 | use NasExt;
 15 | use Nette;
 16 | 
 17 | 
 18 | /**
 19 |  * @author Jáchym Toušek
 20 |  * @author Dusan Hudak
 21 |  * @author Ales Wita
 22 |  * @license MIT
 23 |  */
 24 | class DependentSelectBox extends Nette\Forms\Controls\SelectBox implements Nette\Application\UI\ISignalReceiver
 25 | {
 26 | 	use NasExt\Forms\DependentTrait;
 27 | 
 28 | 	/** @var string */
 29 | 	const SIGNAL_NAME = 'load';
 30 | 
 31 | 
 32 | 	/**
 33 | 	 * @param string $label
 34 | 	 * @param array<int, Nette\Forms\Control> $parents
 35 | 	 */
 36 | 	public function __construct($label, array $parents)
 37 | 	{
 38 | 		$this->parents = $parents;
 39 | 		$this->dependentCallbackParams = $this->parents;//default
 40 | 		parent::__construct($label);
 41 | 	}
 42 | 
 43 | 
 44 | 	/**
 45 | 	 * @param string $signal
 46 | 	 * @return void
 47 | 	 */
 48 | 	public function signalReceived(string $signal) : void
 49 | 	{
 50 | 		$presenter = $this->lookup('Nette\\Application\\UI\\Presenter');
 51 | 
 52 | 		if ($presenter->isAjax() && $signal === self::SIGNAL_NAME && !$this->isDisabled()) {
 53 | 			$cbParamNames = [];
 54 | 			foreach ($this->dependentCallbackParams as $param) {
 55 | 				$value = $presenter->getParameter($this->getNormalizeName($param));
 56 | 
 57 | 				if ($param instanceof Nette\Forms\Controls\MultiChoiceControl) {
 58 | 					if (is_string($value)) {
 59 | 						$value = explode(',', $value);
 60 | 					}
 61 | 
 62 | 					if ($value !== null) {
 63 | 						$value = array_filter($value, static function ($val) {return !in_array($val, [null, '', []], true);});
 64 | 					}
 65 | 				}
 66 | 
 67 | 				$param->setValue($value);
 68 | 
 69 | 				$cbParamNames[$param->getName()] = $param->getValue();
 70 | 			}
 71 | 
 72 | 			$data = $this->getDependentData([$cbParamNames]);
 73 | 			$presenter->payload->dependentselectbox = [
 74 | 				'id' => $this->getHtmlId(),
 75 | 				'items' => $data->getPreparedItems(!is_array($this->disabled) ?: $this->disabled),
 76 | 				'value' => $data->getValue(),
 77 | 				'prompt' => $data->getPrompt() === null ? $this->translate($this->getPrompt()) : $this->translate($data->getPrompt()),
 78 | 				'disabledWhenEmpty' => $this->disabledWhenEmpty,
 79 | 			];
 80 | 			$presenter->sendPayload();
 81 | 		}
 82 | 	}
 83 | 
 84 | 
 85 | 	/**
 86 | 	 * @return void
 87 | 	 */
 88 | 	private function tryLoadItems()
 89 | 	{
 90 | 		if ($this->dependentCallbackParams === array_filter($this->dependentCallbackParams, function ($p) {return !$p->hasErrors();})) {
 91 | 			$cbParamValues = [];
 92 | 			foreach ($this->dependentCallbackParams as $param) {
 93 | 				$cbParamValues[$param->getName()] = $param->getValue();
 94 | 			}
 95 | 
 96 | 			$data = $this->getDependentData([$cbParamValues]);
 97 | 			$items = $data->getItems();
 98 | 
 99 | 
100 | 			if ($this->getForm()->isSubmitted()) {
101 | 				$this->setValue($this->value);
102 | 
103 | 			} elseif ($this->tempValue !== null) {
104 | 				$this->setValue($this->tempValue);
105 | 
106 | 			} else {
107 | 				$this->setValue($data->getValue());
108 | 			}
109 | 
110 | 
111 | 			$this->loadHttpData();
112 | 			$this->setItems($items)
113 | 				->setPrompt($data->getPrompt() === null ? $this->getPrompt() : $data->getPrompt());
114 | 
115 | 			if (count($items) === 0) {
116 | 				if ($this->disabledWhenEmpty === true && !$this->isDisabled()) {
117 | 					$this->setDisabled();
118 | 				}
119 | 			}
120 | 		}
121 | 	}
122 | }
123 | 


--------------------------------------------------------------------------------
/src/DependentData.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  */
 11 | 
 12 | namespace NasExt\Forms;
 13 | 
 14 | use Nette;
 15 | 
 16 | 
 17 | /**
 18 |  * @property array $items
 19 |  * @property string|int $value
 20 |  * @property string $prompt
 21 |  *
 22 |  * @author Dusan Hudak
 23 |  * @author Ales Wita
 24 |  * @license MIT
 25 |  */
 26 | class DependentData
 27 | {
 28 | 	use Nette\SmartObject;
 29 | 
 30 | 	/** @var array */
 31 | 	private $items = [];
 32 | 
 33 | 	/** @var string|int */
 34 | 	private $value;
 35 | 
 36 | 	/** @var string */
 37 | 	private $prompt;
 38 | 
 39 | 
 40 | 	/**
 41 | 	 * @param array $items
 42 | 	 * @param string|int $value
 43 | 	 * @param string $prompt
 44 | 	 */
 45 | 	public function __construct(array $items = [], $value = null, $prompt = null)
 46 | 	{
 47 | 		$this->items = $items;
 48 | 		$this->value = $value;
 49 | 		$this->prompt = $prompt;
 50 | 	}
 51 | 
 52 | 
 53 | 	/**
 54 | 	 * @return array
 55 | 	 */
 56 | 	public function getItems()
 57 | 	{
 58 | 		return $this->items;
 59 | 	}
 60 | 
 61 | 
 62 | 	/**
 63 | 	 * @param array $items
 64 | 	 * @return self
 65 | 	 */
 66 | 	public function setItems(array $items)
 67 | 	{
 68 | 		$this->items = $items;
 69 | 		return $this;
 70 | 	}
 71 | 
 72 | 
 73 | 	/**
 74 | 	 * @return string|int
 75 | 	 */
 76 | 	public function getValue()
 77 | 	{
 78 | 		return $this->value;
 79 | 	}
 80 | 
 81 | 
 82 | 	/**
 83 | 	 * @param string|int $value
 84 | 	 * @return self
 85 | 	 */
 86 | 	public function setValue($value)
 87 | 	{
 88 | 		$this->value = $value;
 89 | 		return $this;
 90 | 	}
 91 | 
 92 | 
 93 | 	/**
 94 | 	 * @return string
 95 | 	 */
 96 | 	public function getPrompt()
 97 | 	{
 98 | 		return $this->prompt;
 99 | 	}
100 | 
101 | 
102 | 	/**
103 | 	 * @param string $value
104 | 	 * @return self
105 | 	 */
106 | 	public function setPrompt($value)
107 | 	{
108 | 		$this->prompt = $value;
109 | 		return $this;
110 | 	}
111 | 
112 | 
113 | 	/**
114 | 	 * @param array $disabledItems
115 | 	 * @return array
116 | 	 */
117 | 	public function getPreparedItems($disabledItems = null)
118 | 	{
119 | 		$items = [];
120 | 		foreach ($this->items as $key => $item) {
121 | 			$elements = [];
122 | 			if (is_array($item)) {
123 | 				$groupItems = [];
124 | 				foreach ($item as $innerKey => $innerItem) {
125 | 					$el = $this->getPreparedElement($innerKey, $innerItem, $disabledItems);
126 | 					$this->addElementToItemsList($groupItems, $el);
127 | 				}
128 | 
129 | 				$items[$key] = [
130 | 					'key' => $key,
131 | 					'value' => $groupItems,
132 | 				];
133 | 
134 | 			} else {
135 | 				$el = $this->getPreparedElement($key, $item, $disabledItems);
136 | 				$this->addElementToItemsList($items, $el);
137 | 			}
138 | 		}
139 | 		// make a List so the order of items is preserved when sent as JSON to client
140 | 		return array_values($items);
141 | 	}
142 | 
143 | 
144 | 	/**
145 | 	 * @param string $key
146 | 	 * @param mixed $item
147 | 	 * @param array|null $disabledItems
148 | 	 * @return Nette\Utils\Html
149 | 	 */
150 | 	private function getPreparedElement($key, $item, $disabledItems = null)
151 | 	{
152 | 		if (!($item instanceof Nette\Utils\Html)) {
153 | 			$el = Nette\Utils\Html::el('option')->value($key)->setText($item);
154 | 
155 | 		} else {
156 | 			$el = $item;
157 | 		}
158 | 
159 | 		// disable element
160 | 		if (is_array($disabledItems) && array_key_exists($key, $disabledItems) && $disabledItems[$key] === true) {
161 | 			$el->disabled(true);
162 | 		}
163 | 
164 | 		return $el;
165 | 	}
166 | 
167 | 
168 | 	/**
169 | 	 * @param array &$items
170 | 	 * @param Nette\Utils\Html $el
171 | 	 */
172 | 	private function addElementToItemsList(&$items, $el)
173 | 	{
174 | 		$items[$el->getAttribute('value')] = [
175 | 			'key' => $el->getValue(),
176 | 			'value' => $el->getText(),
177 | 		];
178 | 		end($items);
179 | 		$lKey = key($items);
180 | 		foreach ($el->attrs as $attr => $val) {
181 | 			$items[$lKey]['attributes'][$attr] = $val;
182 | 		}
183 | 	}
184 | }
185 | 


--------------------------------------------------------------------------------
/src/DependentExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | namespace NasExt\Forms;
13 | 
14 | use NasExt;
15 | use Nette;
16 | 
17 | 
18 | /**
19 |  * @author Ondra Votava <ondra.votava@pixidos.com>
20 |  * @author Ales Wita
21 |  * @license MIT
22 |  */
23 | class DependentExtension extends Nette\DI\CompilerExtension
24 | {
25 | 	/**
26 | 	 * @param Nette\PhpGenerator\ClassType $class
27 | 	 * @return void
28 | 	 */
29 | 	public function afterCompile(Nette\PhpGenerator\ClassType $class)
30 | 	{
31 | 		$initialize = $class->getMethod('initialize');
32 | 		$initialize->addBody(__CLASS__ . '::registerControls();');
33 | 	}
34 | 
35 | 
36 | 	/**
37 | 	 * @return void
38 | 	 */
39 | 	public static function registerControls()
40 | 	{
41 | 		Nette\Forms\Container::extensionMethod('addDependentSelectBox', function (Nette\Forms\Container $container, $name, $label, Nette\Forms\Control ...$parents) {
42 | 			return $container[$name] = new NasExt\Forms\Controls\DependentSelectBox($label, $parents);
43 | 		});
44 | 
45 | 		Nette\Forms\Container::extensionMethod('addDependentMultiSelectBox', function (Nette\Forms\Container $container, $name, $label, Nette\Forms\Control ...$parents) {
46 | 			return $container[$name] = new NasExt\Forms\Controls\DependentMultiSelectBox($label, $parents);
47 | 		});
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/src/DependentTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  */
 11 | 
 12 | namespace NasExt\Forms;
 13 | 
 14 | use NasExt;
 15 | use Nette;
 16 | 
 17 | 
 18 | /**
 19 |  * @author Ales Wita
 20 |  * @license MIT
 21 |  */
 22 | trait DependentTrait
 23 | {
 24 | 	/** @var array */
 25 | 	private $parents;
 26 | 
 27 | 	/**
 28 | 	 * @var array
 29 | 	 * Defaults to $this->parents
 30 | 	 * Useful when selectbox should receive more params that those it's being changed by
 31 | 	 */
 32 | 	private $dependentCallbackParams;
 33 | 
 34 | 	/** @var callable */
 35 | 	private $dependentCallback;
 36 | 
 37 | 	/** @var bool */
 38 | 	private $disabledWhenEmpty;
 39 | 
 40 | 	/** @var mixed */
 41 | 	private $tempValue;
 42 | 
 43 | 
 44 | 	/**
 45 | 	 * @return Nette\Utils\Html
 46 | 	 */
 47 | 	public function getControl() : Nette\Utils\Html
 48 | 	{
 49 | 		$this->tryLoadItems();
 50 | 
 51 | 		$attrs = [];
 52 | 		$control = parent::getControl();
 53 | 		$form = $this->getForm();
 54 | 
 55 | 		$parents = [];
 56 | 		foreach ($this->parents as $parent) {
 57 | 			$parents[$this->getNormalizeName($parent)] = $parent->getHtmlId();
 58 | 		}
 59 | 
 60 | 		$params = [];
 61 | 		foreach ($this->dependentCallbackParams as $param) {
 62 | 			$params[$this->getNormalizeName($param)] = $param->getHtmlId();
 63 | 		}
 64 | 
 65 | 		$attrs['data-dependentselectbox-parents'] = Nette\Utils\Json::encode($parents);
 66 | 		$attrs['data-dependentselectbox-params'] = Nette\Utils\Json::encode($params);
 67 | 		$attrs['data-dependentselectbox'] = $form->getPresenter()->link($this->lookupPath('Nette\\Application\\UI\\Presenter') . Nette\ComponentModel\IComponent::NAME_SEPARATOR . self::SIGNAL_NAME . '!');
 68 | 
 69 | 		$control->addAttributes($attrs);
 70 | 		return $control;
 71 | 	}
 72 | 
 73 | 
 74 | 	/**
 75 | 	 * @return string|int
 76 | 	 */
 77 | 	public function getValue()
 78 | 	{
 79 | 		$this->tryLoadItems();
 80 | 
 81 | 		if (!in_array($this->tempValue, [null, '', []], true)) {
 82 | 			return $this->tempValue;
 83 | 		}
 84 | 
 85 | 		return parent::getValue();
 86 | 	}
 87 | 
 88 | 
 89 | 	/**
 90 | 	 * @param string|int $value
 91 | 	 * @return self
 92 | 	 */
 93 | 	public function setValue($value)
 94 | 	{
 95 | 		$this->tempValue = $value;
 96 | 		return $this;
 97 | 	}
 98 | 
 99 | 
100 | 	/**
101 | 	 * @param array $items
102 | 	 * @param bool $useKeys
103 | 	 * @return self
104 | 	 */
105 | 	public function setItems(array $items, bool $useKeys = true)
106 | 	{
107 | 		parent::setItems($items, $useKeys);
108 | 		
109 | 		if (!in_array($this->tempValue, [null, '', []], true)) {
110 | 			parent::setValue($this->tempValue);
111 | 		}
112 | 
113 | 		return $this;
114 | 	}
115 | 
116 | 
117 | 	/**
118 | 	 * @param array $args
119 | 	 * @return NasExt\Forms\DependentData
120 | 	 * @throws NasExt\Forms\DependentCallbackException
121 | 	 */
122 | 	private function getDependentData(array $args = [])
123 | 	{
124 | 		if ($this->dependentCallback === null) {
125 | 			throw new NasExt\Forms\DependentCallbackException('Dependent callback for "' . $this->getHtmlId() . '" must be set!');
126 | 		}
127 | 
128 | 		$dependentData = call_user_func_array($this->dependentCallback, $args);
129 | 
130 | 		if (!($dependentData instanceof NasExt\Forms\DependentData) && !($dependentData instanceof NasExt\Forms\Controls\DependentSelectBoxData)) {
131 | 			throw new NasExt\Forms\DependentCallbackException('Callback for "' . $this->getHtmlId() . '" must return NasExt\\Forms\\DependentData instance!');
132 | 		}
133 | 
134 | 		return $dependentData;
135 | 	}
136 | 
137 | 
138 | 	/**
139 | 	 * @param callable $callback
140 | 	 * @return self
141 | 	 */
142 | 	public function setDependentCallback(callable $callback)
143 | 	{
144 | 		$this->dependentCallback = $callback;
145 | 		return $this;
146 | 	}
147 | 
148 | 
149 | 	/**
150 | 	 * @param array $params
151 | 	 * @return self
152 | 	 */
153 | 	public function setDependentCallbackParams(array $params)
154 | 	{
155 | 		$this->dependentCallbackParams = $params;
156 | 		return $this;
157 | 	}
158 | 
159 | 
160 | 	/**
161 | 	 * @param bool $value
162 | 	 * @return self
163 | 	 */
164 | 	public function setDisabledWhenEmpty($value = true)
165 | 	{
166 | 		$this->disabledWhenEmpty = $value;
167 | 		return $this;
168 | 	}
169 | 
170 | 
171 | 	/**
172 | 	 * @param Nette\Forms\Controls\BaseControl $parent
173 | 	 * @return string
174 | 	 */
175 | 	private function getNormalizeName(Nette\Forms\Controls\BaseControl $parent)
176 | 	{
177 | 		return str_replace('-', '_', $parent->getHtmlId());
178 | 	}
179 | }
180 | 


--------------------------------------------------------------------------------
/src/Exceptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | namespace NasExt\Forms;
13 | 
14 | 
15 | /**
16 |  * @author Ales Wita
17 |  * @license MIT
18 |  */
19 | class DependentCallbackException extends \Exception
20 | {
21 | }
22 | 
23 | 
24 | /**
25 |  * @author Ales Wita
26 |  * @license MIT
27 |  */
28 | class Test extends \Exception
29 | {
30 | }
31 | 


--------------------------------------------------------------------------------
/src/_Controls.BackCompatibility.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | namespace NasExt\Forms\Controls;
13 | 
14 | 
15 | /**
16 |  * @author Ales Wita
17 |  * @license MIT
18 |  *
19 |  * @deprecated
20 |  */
21 | class DependentSelectBoxData extends \NasExt\Forms\DependentData
22 | {
23 | }
24 | 
25 | 
26 | /**
27 |  * @author Ales Wita
28 |  * @license MIT
29 |  */
30 | class Test
31 | {
32 | }
33 | 


--------------------------------------------------------------------------------
/src/_DI.BackCompatibility.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | namespace NasExt\Forms\DI;
13 | 
14 | 
15 | /**
16 |  * @author Ales Wita
17 |  * @license MIT
18 |  *
19 |  * @deprecated
20 |  */
21 | class DependentSelectBoxExtension extends \NasExt\Forms\DependentExtension
22 | {
23 | }
24 | 
25 | 
26 | /**
27 |  * @author Ales Wita
28 |  * @license MIT
29 |  */
30 | class Test
31 | {
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/.coveralls.yml:
--------------------------------------------------------------------------------
1 | service_name: travis-ci
2 | coverage_clover: coverage.xml
3 | json_path: coverage.json
4 | 


--------------------------------------------------------------------------------
/tests/app/presenters/BasePresenter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  */
 11 | 
 12 | namespace NasExt\Forms\Tests\App\Presenters;
 13 | 
 14 | use NasExt;
 15 | use Nette;
 16 | 
 17 | 
 18 | /**
 19 |  * @author Ales Wita
 20 |  * @license MIT
 21 |  */
 22 | final class BasePresenter extends Nette\Application\UI\Presenter
 23 | {
 24 | 	/**
 25 | 	 * @return void
 26 | 	 */
 27 | 	public function actionDependentSelect1()
 28 | 	{
 29 | 	}
 30 | 
 31 | 
 32 | 	/**
 33 | 	 * @return void
 34 | 	 */
 35 | 	public function actionDependentSelect2()
 36 | 	{
 37 | 	}
 38 | 
 39 | 
 40 | 	/**
 41 | 	 * @return void
 42 | 	 */
 43 | 	public function actionDependentSelect2Exception1()
 44 | 	{
 45 | 		$this->setView('dependentSelect2');
 46 | 	}
 47 | 
 48 | 
 49 | 	/**
 50 | 	 * @return void
 51 | 	 */
 52 | 	public function actionDependentSelect2Exception2()
 53 | 	{
 54 | 		$this['dependentSelectForm2']['dependentSelect']->setDependentCallback(function () {});
 55 | 		$this->setView('dependentSelect2');
 56 | 	}
 57 | 
 58 | 
 59 | 	/**
 60 | 	 * @return void
 61 | 	 */
 62 | 	public function actionDependentSelect2Disabled1()
 63 | 	{
 64 | 		$this['dependentSelectForm2']['dependentSelect']->setDependentCallback([$this, 'dependentCallback'])
 65 | 			->setDisabled();
 66 | 
 67 | 		$this->setView('dependentSelect2');
 68 | 	}
 69 | 
 70 | 
 71 | 	/**
 72 | 	 * @return void
 73 | 	 */
 74 | 	public function actionDependentSelect2Disabled2()
 75 | 	{
 76 | 		$this['dependentSelectForm2']['dependentSelect']->setDependentCallback([$this, 'dependentCallback'])
 77 | 			->setDisabled([2]);
 78 | 
 79 | 		$this->setView('dependentSelect2');
 80 | 	}
 81 | 
 82 | 
 83 | 	/**
 84 | 	 * @return void
 85 | 	 */
 86 | 	public function actionDependentSelect2Disabled3()
 87 | 	{
 88 | 		$this['dependentSelectForm2']['dependentSelect']->setDependentCallback([$this, 'dependentCallback'])
 89 | 			->setDisabledWhenEmpty();
 90 | 
 91 | 		$this->setView('dependentSelect2');
 92 | 	}
 93 | 
 94 | 
 95 | 	/**
 96 | 	 * @return Nette\Application\UI\Form
 97 | 	 */
 98 | 	protected function createComponentDependentSelectForm1()
 99 | 	{
100 | 		$form = new Nette\Application\UI\Form;
101 | 
102 | 		$form->addSelect('select', 'Select', [1 => 'First', 2 => 'Second'])
103 | 			->setPrompt('---');
104 | 
105 | 		$form->addDependentSelectBox('dependentSelect', 'Dependent select', $form['select'])
106 | 			->setDependentCallback([$this, 'dependentCallback'])
107 | 			->setPrompt('Select select first');
108 | 
109 | 		return $form;
110 | 	}
111 | 
112 | 
113 | 	/**
114 | 	 * @return Nette\Application\UI\Form
115 | 	 */
116 | 	protected function createComponentDependentSelectForm2()
117 | 	{
118 | 		$form = new Nette\Application\UI\Form;
119 | 
120 | 		$form->addSelect('select', 'Select', [1 => 'First', 2 => 'Second', 3 => 'Third'])
121 | 			->setPrompt('---');
122 | 
123 | 		$form->addDependentSelectBox('dependentSelect', 'Dependent select', $form['select'])
124 | 			->setPrompt('Select select first');
125 | 
126 | 		return $form;
127 | 	}
128 | 
129 | 
130 | 	/**
131 | 	 * @return void
132 | 	 */
133 | 	public function actionDependentMultiSelect1()
134 | 	{
135 | 	}
136 | 
137 | 
138 | 	/**
139 | 	 * @return void
140 | 	 */
141 | 	public function actionDependentMultiSelect2()
142 | 	{
143 | 	}
144 | 
145 | 
146 | 	/**
147 | 	 * @return void
148 | 	 */
149 | 	public function actionDependentMultiSelect2Exception1()
150 | 	{
151 | 		$this->setView('dependentMultiSelect2');
152 | 	}
153 | 
154 | 
155 | 	/**
156 | 	 * @return void
157 | 	 */
158 | 	public function actionDependentMultiSelect2Exception2()
159 | 	{
160 | 		$this['dependentMultiSelectForm2']['dependentMultiSelect']->setDependentCallback(function () {});
161 | 		$this->setView('dependentMultiSelect2');
162 | 	}
163 | 
164 | 
165 | 	/**
166 | 	 * @return void
167 | 	 */
168 | 	public function actionDependentMultiSelect2Disabled1()
169 | 	{
170 | 		$this['dependentMultiSelectForm2']['dependentMultiSelect']->setDependentCallback([$this, 'dependentCallback'])
171 | 			->setDisabled();
172 | 
173 | 		$this->setView('dependentMultiSelect2');
174 | 	}
175 | 
176 | 
177 | 	/**
178 | 	 * @return void
179 | 	 */
180 | 	public function actionDependentMultiSelect2Disabled2()
181 | 	{
182 | 		$this['dependentMultiSelectForm2']['dependentMultiSelect']->setDependentCallback([$this, 'dependentCallback'])
183 | 			->setDisabled([2]);
184 | 
185 | 		$this->setView('dependentMultiSelect2');
186 | 	}
187 | 
188 | 
189 | 	/**
190 | 	 * @return void
191 | 	 */
192 | 	public function actionDependentMultiSelect2Disabled3()
193 | 	{
194 | 		$this['dependentMultiSelectForm2']['dependentMultiSelect']->setDependentCallback([$this, 'dependentCallback'])
195 | 			->setDisabledWhenEmpty();
196 | 
197 | 		$this->setView('dependentMultiSelect2');
198 | 	}
199 | 
200 | 
201 | 	/**
202 | 	 * @return Nette\Application\UI\Form
203 | 	 */
204 | 	protected function createComponentDependentMultiSelectForm1()
205 | 	{
206 | 		$form = new Nette\Application\UI\Form;
207 | 
208 | 		$form->addSelect('select', 'Select', [1 => 'First', 2 => 'Second'])
209 | 			->setPrompt('---');
210 | 
211 | 		$form->addDependentMultiSelectBox('dependentMultiSelect', 'Dependent multi select', $form['select'])
212 | 			->setDependentCallback([$this, 'dependentCallback']);
213 | 
214 | 		return $form;
215 | 	}
216 | 
217 | 
218 | 	/**
219 | 	 * @return Nette\Application\UI\Form
220 | 	 */
221 | 	protected function createComponentDependentMultiSelectForm2()
222 | 	{
223 | 		$form = new Nette\Application\UI\Form;
224 | 
225 | 		$form->addSelect('select', 'Select', [1 => 'First', 2 => 'Second', 3 => 'Third'])
226 | 			->setPrompt('---');
227 | 
228 | 		$form->addDependentMultiSelectBox('dependentMultiSelect', 'Dependent multi select', $form['select']);
229 | 
230 | 		return $form;
231 | 	}
232 | 
233 | 
234 | 	/**
235 | 	 * @param array $values
236 | 	 * @return NasExt\Forms\DependentData
237 | 	 */
238 | 	public function dependentCallback(array $values)
239 | 	{
240 | 		$data = new NasExt\Forms\DependentData;
241 | 
242 | 		switch ($values['select']) {
243 | 			case 1:
244 | 				$data->setItems([1 => 'First', 2 => 'Still first'])
245 | 					->setPrompt('---');
246 | 				break;
247 | 
248 | 			case 2:
249 | 				$data->setItems([3 => 'Second', 4 => 'Still second'])
250 | 					->setPrompt('---');
251 | 				break;
252 | 		}
253 | 
254 | 		return $data;
255 | 	}
256 | }
257 | 


--------------------------------------------------------------------------------
/tests/app/presenters/templates/Base.dependentMultiSelect1.latte:
--------------------------------------------------------------------------------
1 | {control dependentMultiSelectForm1}
2 | 


--------------------------------------------------------------------------------
/tests/app/presenters/templates/Base.dependentMultiSelect2.latte:
--------------------------------------------------------------------------------
1 | {control dependentMultiSelectForm2}
2 | 


--------------------------------------------------------------------------------
/tests/app/presenters/templates/Base.dependentSelect1.latte:
--------------------------------------------------------------------------------
1 | {control dependentSelectForm1}
2 | 


--------------------------------------------------------------------------------
/tests/app/presenters/templates/Base.dependentSelect2.latte:
--------------------------------------------------------------------------------
1 | {control dependentSelectForm2}
2 | 


--------------------------------------------------------------------------------
/tests/app/router/Router.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | namespace NasExt\Forms\Tests\App\Router;
13 | 
14 | use Nette;
15 | 
16 | 
17 | /**
18 |  * @author Ales Wita
19 |  * @license MIT
20 |  */
21 | final class Router
22 | {
23 | 	/**
24 | 	 * @return Nette\Application\IRouter
25 | 	 */
26 | 	public static function createRouter()
27 | 	{
28 | 		$route = new Nette\Application\Routers\RouteList;
29 | 		$route[] = new Nette\Application\Routers\Route('<presenter>/<action>[/<id>]', 'Base:default');
30 | 		return $route;
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  */
11 | 
12 | if (@!include __DIR__ . '/../vendor/autoload.php') {
13 | 	echo 'Install Nette Tester using `composer install`';
14 | 	exit(1);
15 | }
16 | 
17 | require_once __DIR__ . '/app/presenters/BasePresenter.php';
18 | require_once __DIR__ . '/app/router/Router.php';
19 | 
20 | Tester\Environment::setup();
21 | 
22 | define('TEMP_DIR', __DIR__ . '/tmp/' . lcg_value());
23 | @mkdir(dirname(TEMP_DIR));
24 | @mkdir(TEMP_DIR);
25 | 


--------------------------------------------------------------------------------
/tests/tests/DependentDataTest.phpt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the NasExt extensions of Nette Framework
 5 |  *
 6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
 7 |  *
 8 |  * For the full copyright and license information, please view
 9 |  * the file license.md that was distributed with this source code.
10 |  *
11 |  * @phpVersion 5.6.0
12 |  */
13 | 
14 | namespace NasExt\Forms\Tests\Tests;
15 | 
16 | use NasExt;
17 | use Tester;
18 | 
19 | require_once __DIR__ . '/../bootstrap.php';
20 | 
21 | 
22 | /**
23 |  * @author Ales Wita
24 |  * @license MIT
25 |  */
26 | final class DependentDataTest extends Tester\TestCase
27 | {
28 | 	/**
29 | 	 * @return void
30 | 	 */
31 | 	public function testOne()
32 | 	{
33 | 		$data = new NasExt\Forms\DependentData;
34 | 
35 | 		Tester\Assert::same([], $data->getItems());
36 | 		Tester\Assert::same(null, $data->getValue());
37 | 		Tester\Assert::same(null, $data->getPrompt());
38 | 	}
39 | 
40 | 
41 | 	/**
42 | 	 * @return void
43 | 	 */
44 | 	public function testTwo()
45 | 	{
46 | 		$items = [1, 2, 3, 4, 5];
47 | 		$value = 'foo';
48 | 		$prompt = '---';
49 | 
50 | 		$data = new NasExt\Forms\DependentData($items, $value, $prompt);
51 | 
52 | 		Tester\Assert::same($items, $data->getItems());
53 | 		Tester\Assert::same([
54 | 			['key' => 0, 'value' => '1', 'attributes' => ['value' => 0, 'disabled' => true]],
55 | 			['key' => 1, 'value' => '2', 'attributes' => ['value' => 1]],
56 | 			['key' => 2, 'value' => '3', 'attributes' => ['value' => 2]],
57 | 			['key' => 3, 'value' => '4', 'attributes' => ['value' => 3]],
58 | 			['key' => 4, 'value' => '5', 'attributes' => ['value' => 4, 'disabled' => true]],
59 | 		], $data->getPreparedItems([0 => true, 4 => true]));
60 | 		Tester\Assert::same($value, $data->getValue());
61 | 		Tester\Assert::same($prompt, $data->getPrompt());
62 | 	}
63 | 
64 | 
65 | 	/**
66 | 	 * @return void
67 | 	 */
68 | 	public function testThree()
69 | 	{
70 | 		$items = [1, 2, 3, 4, 5];
71 | 		$value = 'foo';
72 | 		$prompt = '---';
73 | 
74 | 		$data = new NasExt\Forms\DependentData;
75 | 
76 | 		$data->setItems($items)
77 | 			->setValue($value)
78 | 			->setPrompt($prompt);
79 | 
80 | 		Tester\Assert::same($items, $data->getItems());
81 | 		Tester\Assert::same([
82 | 			['key' => 0, 'value' => '1', 'attributes' => ['value' => 0, 'disabled' => true]],
83 | 			['key' => 1, 'value' => '2', 'attributes' => ['value' => 1]],
84 | 			['key' => 2, 'value' => '3', 'attributes' => ['value' => 2]],
85 | 			['key' => 3, 'value' => '4', 'attributes' => ['value' => 3]],
86 | 			['key' => 4, 'value' => '5', 'attributes' => ['value' => 4, 'disabled' => true]],
87 | 		], $data->getPreparedItems([0 => true, 4 => true]));
88 | 		Tester\Assert::same($value, $data->getValue());
89 | 		Tester\Assert::same($prompt, $data->getPrompt());
90 | 	}
91 | }
92 | 
93 | 
94 | $test = new DependentDataTest;
95 | $test->run();
96 | 


--------------------------------------------------------------------------------
/tests/tests/DependentMultiSelectBoxTest.phpt:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  *
 11 |  * @phpVersion 5.6.0
 12 |  */
 13 | 
 14 | namespace NasExt\Forms\Tests\Tests;
 15 | 
 16 | use NasExt;
 17 | use Nette;
 18 | use Tester;
 19 | 
 20 | require_once __DIR__ . '/../bootstrap.php';
 21 | 
 22 | 
 23 | /**
 24 |  * @author Ales Wita
 25 |  * @license MIT
 26 |  */
 27 | final class DependentMultiSelectBoxTest extends Tester\TestCase
 28 | {
 29 | 	/**
 30 | 	 * @return void
 31 | 	 */
 32 | 	public function testOne()
 33 | 	{
 34 | 		$configurator = new Nette\Configurator();
 35 | 		$configurator->setTempDirectory(TEMP_DIR);
 36 | 		$configurator->addConfig($this->getConfig());
 37 | 
 38 | 		$container = $configurator->createContainer();
 39 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
 40 | 
 41 | 		$presenter = $presenterFactory->createPresenter('Base');
 42 | 		$presenter->autoCanonicalize = false;
 43 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentMultiSelect1']);
 44 | 		$response = $presenter->run($request);
 45 | 
 46 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
 47 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
 48 | 
 49 | 
 50 | 		// check form
 51 | 		$form = $presenter['dependentMultiSelectForm1'];
 52 | 
 53 | 		Tester\Assert::true($form instanceof Nette\Application\UI\Form);
 54 | 
 55 | 
 56 | 		// check dependent multi select
 57 | 		$dependentMultiSelect = $form['dependentMultiSelect'];
 58 | 
 59 | 		Tester\Assert::true($dependentMultiSelect instanceof NasExt\Forms\Controls\DependentMultiSelectBox);
 60 | 
 61 | 
 62 | 		// check control
 63 | 		$control = $dependentMultiSelect->getControl();
 64 | 
 65 | 		Tester\Assert::true($control instanceof Nette\Utils\Html);
 66 | 
 67 | 
 68 | 		// check source
 69 | 		$source = (string) $response->getSource();
 70 | 		$dom = Tester\DomQuery::fromHtml($source);
 71 | 
 72 | 
 73 | 		// dependent select tag
 74 | 		$data = $dom->find('select[name="dependentMultiSelect[]"]');
 75 | 
 76 | 		Tester\Assert::count(1, $data);
 77 | 
 78 | 		$foo = (array) $data[0];
 79 | 		Tester\Assert::count(5, $foo['@attributes']);
 80 | 		Tester\Assert::same($control->getAttribute('name'), $foo['@attributes']['name']);
 81 | 		Tester\Assert::same($control->getAttribute('id'), $foo['@attributes']['id']);
 82 | 		Tester\Assert::same('multiple', $foo['@attributes']['multiple']);
 83 | 		Tester\Assert::same($control->getAttribute('data-dependentselectbox'), $foo['@attributes']['data-dependentselectbox']);
 84 | 		Tester\Assert::same($control->getAttribute('data-dependentselectbox-parents'), $foo['@attributes']['data-dependentselectbox-parents']);
 85 | 	}
 86 | 
 87 | 
 88 | 	/**
 89 | 	 * @return void
 90 | 	 */
 91 | 	public function testTwo()
 92 | 	{
 93 | 		$configurator = new Nette\Configurator();
 94 | 		$configurator->setTempDirectory(TEMP_DIR);
 95 | 		$configurator->addConfig($this->getConfig());
 96 | 
 97 | 		$container = $configurator->createContainer();
 98 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
 99 | 
100 | 		$presenter = $presenterFactory->createPresenter('Base');
101 | 		$presenter->autoCanonicalize = false;
102 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect1'], ['_do' => 'dependentMultiSelectForm1-submit'], ['select' => 1, 'dependentMultiSelect' => [1]]);
103 | 		$response = $presenter->run($request);
104 | 
105 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
106 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
107 | 
108 | 
109 | 		// check multi dependent select
110 | 		$dependentMultiSelect = $presenter['dependentMultiSelectForm1']['dependentMultiSelect'];
111 | 
112 | 		Tester\Assert::true($dependentMultiSelect instanceof NasExt\Forms\Controls\DependentMultiSelectBox);
113 | 		Tester\Assert::same([1], $dependentMultiSelect->getValue());
114 | 	}
115 | 
116 | 
117 | 	/**
118 | 	 * @throws Nette\InvalidArgumentException Values '3', '4' are out of allowed set [1, 2] in field 'dependentMultiSelect'.
119 | 	 * @return void
120 | 	 */
121 | 	public function testThree()
122 | 	{
123 | 		$configurator = new Nette\Configurator();
124 | 		$configurator->setTempDirectory(TEMP_DIR);
125 | 		$configurator->addConfig($this->getConfig());
126 | 
127 | 		$container = $configurator->createContainer();
128 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
129 | 
130 | 		$presenter = $presenterFactory->createPresenter('Base');
131 | 		$presenter->autoCanonicalize = false;
132 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect1'], ['_do' => 'dependentMultiSelectForm1-submit'], ['select' => 1, 'dependentMultiSelect' => [3, 4]]);
133 | 		$response = $presenter->run($request);
134 | 
135 | 		$presenter['dependentMultiSelectForm1']->getValues();// must load values for throws exception
136 | 	}
137 | 
138 | 
139 | 	/**
140 | 	 * @return void
141 | 	 */
142 | 	public function testFour()
143 | 	{
144 | 		$configurator = new Nette\Configurator();
145 | 		$configurator->setTempDirectory(TEMP_DIR);
146 | 		$configurator->addConfig($this->getConfig());
147 | 
148 | 		$container = $configurator->createContainer();
149 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
150 | 
151 | 		$presenter = $presenterFactory->createPresenter('Base');
152 | 		$presenter->autoCanonicalize = false;
153 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect1'], ['_do' => 'dependentMultiSelectForm1-submit']);
154 | 		$response = $presenter->run($request);
155 | 
156 | 
157 | 		// check form
158 | 		$form = $presenter['dependentMultiSelectForm1'];
159 | 
160 | 		Tester\Assert::true($form->isSubmitted());
161 | 		Tester\Assert::true($form->isSuccess());
162 | 		Tester\Assert::same(['select' => null, 'dependentMultiSelect' => []], (array) $form->getValues());
163 | 	}
164 | 
165 | 
166 | 	/**
167 | 	 * @return void
168 | 	 */
169 | 	public function testFive()
170 | 	{
171 | 		$_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';// make ajax request
172 | 
173 | 		$configurator = new Nette\Configurator();
174 | 		$configurator->setTempDirectory(TEMP_DIR);
175 | 		$configurator->addConfig($this->getConfig());
176 | 
177 | 		$container = $configurator->createContainer();
178 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
179 | 
180 | 		$presenter = $presenterFactory->createPresenter('Base');
181 | 		$presenter->autoCanonicalize = false;
182 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentMultiSelect1', 'do' => 'dependentMultiSelectForm1-dependentMultiSelect-load', 'frm_dependentMultiSelectForm1_select' => 1]);
183 | 		$response = $presenter->run($request);
184 | 
185 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\JsonResponse);
186 | 		Tester\Assert::same([
187 | 			'id' => 'frm-dependentMultiSelectForm1-dependentMultiSelect',
188 | 			'items' => [
189 | 				1 => ['key' => 1, 'value' => 'First', 'attributes' => ['value' => 1]],
190 | 				2 => ['key' => 2, 'value' => 'Still first', 'attributes' => ['value' => 2]],
191 | 			],
192 | 			'value' => null,
193 | 			'prompt' => false,
194 | 			'disabledWhenEmpty' => null,
195 | 		], $response->getPayload()->dependentselectbox);
196 | 	}
197 | 
198 | 
199 | 	/**
200 | 	 * @throws NasExt\Forms\DependentCallbackException Dependent callback for "frm-dependentMultiSelectForm2-dependentMultiSelect" must be set!
201 | 	 * @return void
202 | 	 */
203 | 	public function testSix()
204 | 	{
205 | 		$configurator = new Nette\Configurator();
206 | 		$configurator->setTempDirectory(TEMP_DIR);
207 | 		$configurator->addConfig($this->getConfig());
208 | 
209 | 		$container = $configurator->createContainer();
210 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
211 | 
212 | 		$presenter = $presenterFactory->createPresenter('Base');
213 | 		$presenter->autoCanonicalize = false;
214 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentMultiSelect2Exception1']);
215 | 		$response = $presenter->run($request);
216 | 
217 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
218 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
219 | 
220 | 		$response->getSource()->render();
221 | 	}
222 | 
223 | 
224 | 	/**
225 | 	 * @throws NasExt\Forms\DependentCallbackException Callback for "frm-dependentMultiSelectForm2-dependentMultiSelect" must return NasExt\Forms\DependentData instance!
226 | 	 * @return void
227 | 	 */
228 | 	public function testSeven()
229 | 	{
230 | 		$configurator = new Nette\Configurator();
231 | 		$configurator->setTempDirectory(TEMP_DIR);
232 | 		$configurator->addConfig($this->getConfig());
233 | 
234 | 		$container = $configurator->createContainer();
235 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
236 | 
237 | 		$presenter = $presenterFactory->createPresenter('Base');
238 | 		$presenter->autoCanonicalize = false;
239 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentMultiSelect2Exception2']);
240 | 		$response = $presenter->run($request);
241 | 
242 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
243 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
244 | 
245 | 		$response->getSource()->render();
246 | 	}
247 | 
248 | 
249 | 	/**
250 | 	 * @return void
251 | 	 */
252 | 	public function testEight()
253 | 	{
254 | 		$configurator = new Nette\Configurator();
255 | 		$configurator->setTempDirectory(TEMP_DIR);
256 | 		$configurator->addConfig($this->getConfig());
257 | 
258 | 		$container = $configurator->createContainer();
259 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
260 | 
261 | 		$presenter = $presenterFactory->createPresenter('Base');
262 | 		$presenter->autoCanonicalize = false;
263 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect2Disabled1'], ['_do' => 'dependentMultiSelectForm2-submit'], ['select' => 1, 'dependentMultiSelect' => [2]]);
264 | 		$response = $presenter->run($request);
265 | 
266 | 
267 | 		// check form
268 | 		$form = $presenter['dependentMultiSelectForm2'];
269 | 
270 | 		Tester\Assert::true($form->isSubmitted());
271 | 		Tester\Assert::true($form->isSuccess());
272 | 		Tester\Assert::same(['select' => 1], (array) $form->getValues());
273 | 	}
274 | 
275 | 
276 | 	/**
277 | 	 * @throws Nette\InvalidArgumentException NasExt\Forms\Controls\DependentMultiSelectBox not supported disabled items!
278 | 	 * @return void
279 | 	 */
280 | 	public function testNine()
281 | 	{
282 | 		$configurator = new Nette\Configurator();
283 | 		$configurator->setTempDirectory(TEMP_DIR);
284 | 		$configurator->addConfig($this->getConfig());
285 | 
286 | 		$container = $configurator->createContainer();
287 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
288 | 
289 | 		$presenter = $presenterFactory->createPresenter('Base');
290 | 		$presenter->autoCanonicalize = false;
291 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect2Disabled2'], ['_do' => 'dependentMultiSelectForm2-submit'], ['select' => 1, 'dependentMultiSelect' => [2]]);
292 | 		$response = $presenter->run($request);
293 | 
294 | 
295 | 		// check form
296 | 		//$form = $presenter['dependentMultiSelectForm2'];
297 | 
298 | 		//Tester\Assert::true($form->isSubmitted());
299 | 		//Tester\Assert::true($form->isSuccess());
300 | 		//Tester\Assert::same(['select' => 1, 'dependentMultiSelect' => []], (array) $form->getValues());
301 | 	}
302 | 
303 | 
304 | 	/**
305 | 	 * @return void
306 | 	 */
307 | 	public function testTen()
308 | 	{
309 | 		$configurator = new Nette\Configurator();
310 | 		$configurator->setTempDirectory(TEMP_DIR);
311 | 		$configurator->addConfig($this->getConfig());
312 | 
313 | 		$container = $configurator->createContainer();
314 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
315 | 
316 | 		$presenter = $presenterFactory->createPresenter('Base');
317 | 		$presenter->autoCanonicalize = false;
318 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentMultiSelect2Disabled3'], ['_do' => 'dependentMultiSelectForm2-submit'], ['select' => 3]);
319 | 		$response = $presenter->run($request);
320 | 
321 | 
322 | 		// check form
323 | 		$form = $presenter['dependentMultiSelectForm2'];
324 | 		$form->getValues();// must load values for check if omitted
325 | 
326 | 		Tester\Assert::true($form->isSubmitted());
327 | 		Tester\Assert::true($form->isSuccess());
328 | 		Tester\Assert::true($form['dependentMultiSelect']->isOmitted());
329 | 		Tester\Assert::same(['select' => 3], (array) $form->getValues());
330 | 	}
331 | 
332 | 
333 | 	/**
334 | 	 * @internal
335 | 	 */
336 | 	private function getConfig()
337 | 	{
338 | 		return Tester\FileMock::create('
339 | extensions:
340 | 	dependentSelectBox: NasExt\Forms\DependentExtension
341 | 
342 | application:
343 | 	mapping:
344 | 		*: NasExt\Forms\Tests\App\Presenters\*Presenter
345 | 
346 | services:
347 | 	base.presenter:
348 | 		class: NasExt\Forms\Tests\App\Presenters\BasePresenter
349 | 
350 | 	routing.router: NasExt\Forms\Tests\App\Router\Router::createRouter', 'neon');
351 | 	}
352 | }
353 | 
354 | 
355 | $test = new DependentMultiSelectBoxTest;
356 | $test->run();
357 | 


--------------------------------------------------------------------------------
/tests/tests/DependentSelectBoxTest.phpt:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the NasExt extensions of Nette Framework
  5 |  *
  6 |  * Copyright (c) 2013 Dusan Hudak (http://dusan-hudak.com)
  7 |  *
  8 |  * For the full copyright and license information, please view
  9 |  * the file license.md that was distributed with this source code.
 10 |  *
 11 |  * @phpVersion 5.6.0
 12 |  */
 13 | 
 14 | namespace NasExt\Forms\Tests\Tests;
 15 | 
 16 | use NasExt;
 17 | use Nette;
 18 | use Tester;
 19 | 
 20 | require_once __DIR__ . '/../bootstrap.php';
 21 | 
 22 | 
 23 | /**
 24 |  * @author Ales Wita
 25 |  * @license MIT
 26 |  */
 27 | final class DependentSelectBoxTest extends Tester\TestCase
 28 | {
 29 | 	/**
 30 | 	 * @return void
 31 | 	 */
 32 | 	public function testOne()
 33 | 	{
 34 | 		$configurator = new Nette\Configurator();
 35 | 		$configurator->setTempDirectory(TEMP_DIR);
 36 | 		$configurator->addConfig($this->getConfig());
 37 | 
 38 | 		$container = $configurator->createContainer();
 39 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
 40 | 
 41 | 		$presenter = $presenterFactory->createPresenter('Base');
 42 | 		$presenter->autoCanonicalize = false;
 43 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentSelect1']);
 44 | 		$response = $presenter->run($request);
 45 | 
 46 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
 47 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
 48 | 
 49 | 
 50 | 		// check form
 51 | 		$form = $presenter['dependentSelectForm1'];
 52 | 
 53 | 		Tester\Assert::true($form instanceof Nette\Application\UI\Form);
 54 | 
 55 | 
 56 | 		// check dependent select
 57 | 		$dependentSelect = $form['dependentSelect'];
 58 | 
 59 | 		Tester\Assert::true($dependentSelect instanceof NasExt\Forms\Controls\DependentSelectBox);
 60 | 
 61 | 
 62 | 		// check control
 63 | 		$control = $dependentSelect->getControl();
 64 | 
 65 | 		Tester\Assert::true($control instanceof Nette\Utils\Html);
 66 | 
 67 | 
 68 | 		// check source
 69 | 		$source = (string) $response->getSource();
 70 | 		$dom = Tester\DomQuery::fromHtml($source);
 71 | 
 72 | 
 73 | 		// dependent select tag
 74 | 		$data = $dom->find('select[name="dependentSelect"]');
 75 | 
 76 | 		Tester\Assert::count(1, $data);
 77 | 
 78 | 		$foo = (array) $data[0];
 79 | 		Tester\Assert::count(4, $foo['@attributes']);
 80 | 		Tester\Assert::same($control->getAttribute('name'), $foo['@attributes']['name']);
 81 | 		Tester\Assert::same($control->getAttribute('id'), $foo['@attributes']['id']);
 82 | 		Tester\Assert::same($control->getAttribute('data-dependentselectbox'), $foo['@attributes']['data-dependentselectbox']);
 83 | 		Tester\Assert::same($control->getAttribute('data-dependentselectbox-parents'), $foo['@attributes']['data-dependentselectbox-parents']);
 84 | 
 85 | 		Tester\Assert::same('Select select first', $foo['option']);
 86 | 	}
 87 | 
 88 | 
 89 | 	/**
 90 | 	 * @return void
 91 | 	 */
 92 | 	public function testTwo()
 93 | 	{
 94 | 		$configurator = new Nette\Configurator();
 95 | 		$configurator->setTempDirectory(TEMP_DIR);
 96 | 		$configurator->addConfig($this->getConfig());
 97 | 
 98 | 		$container = $configurator->createContainer();
 99 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
100 | 
101 | 		$presenter = $presenterFactory->createPresenter('Base');
102 | 		$presenter->autoCanonicalize = false;
103 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect1'], ['_do' => 'dependentSelectForm1-submit'], ['select' => 1, 'dependentSelect' => 1]);
104 | 		$response = $presenter->run($request);
105 | 
106 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
107 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
108 | 
109 | 
110 | 		// check dependent select
111 | 		$dependentSelect = $presenter['dependentSelectForm1']['dependentSelect'];
112 | 
113 | 		Tester\Assert::true($dependentSelect instanceof NasExt\Forms\Controls\DependentSelectBox);
114 | 		Tester\Assert::same(1, $dependentSelect->getValue());
115 | 	}
116 | 
117 | 
118 | 	/**
119 | 	 * @throws Nette\InvalidArgumentException Value '3' is out of allowed set [1, 2] in field 'dependentSelect'.
120 | 	 * @return void
121 | 	 */
122 | 	public function testThree()
123 | 	{
124 | 		$configurator = new Nette\Configurator();
125 | 		$configurator->setTempDirectory(TEMP_DIR);
126 | 		$configurator->addConfig($this->getConfig());
127 | 
128 | 		$container = $configurator->createContainer();
129 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
130 | 
131 | 		$presenter = $presenterFactory->createPresenter('Base');
132 | 		$presenter->autoCanonicalize = false;
133 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect1'], ['_do' => 'dependentSelectForm1-submit'], ['select' => 1, 'dependentSelect' => 3]);
134 | 		$response = $presenter->run($request);
135 | 	}
136 | 
137 | 
138 | 	/**
139 | 	 * @return void
140 | 	 */
141 | 	public function testFour()
142 | 	{
143 | 		$configurator = new Nette\Configurator();
144 | 		$configurator->setTempDirectory(TEMP_DIR);
145 | 		$configurator->addConfig($this->getConfig());
146 | 
147 | 		$container = $configurator->createContainer();
148 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
149 | 
150 | 		$presenter = $presenterFactory->createPresenter('Base');
151 | 		$presenter->autoCanonicalize = false;
152 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect1'], ['_do' => 'dependentSelectForm1-submit']);
153 | 		$response = $presenter->run($request);
154 | 
155 | 
156 | 		// check form
157 | 		$form = $presenter['dependentSelectForm1'];
158 | 
159 | 		Tester\Assert::true($form->isSubmitted());
160 | 		Tester\Assert::true($form->isSuccess());
161 | 		Tester\Assert::same(['select' => null, 'dependentSelect' => null], (array) $form->getValues());
162 | 	}
163 | 
164 | 
165 | 	/**
166 | 	 * @return void
167 | 	 */
168 | 	public function testFive()
169 | 	{
170 | 		$_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';// make ajax request
171 | 
172 | 		$configurator = new Nette\Configurator();
173 | 		$configurator->setTempDirectory(TEMP_DIR);
174 | 		$configurator->addConfig($this->getConfig());
175 | 
176 | 		$container = $configurator->createContainer();
177 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
178 | 
179 | 		$presenter = $presenterFactory->createPresenter('Base');
180 | 		$presenter->autoCanonicalize = false;
181 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentSelect1', 'do' => 'dependentSelectForm1-dependentSelect-load', 'frm_dependentSelectForm1_select' => 1]);
182 | 		$response = $presenter->run($request);
183 | 
184 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\JsonResponse);
185 | 		Tester\Assert::same([
186 | 			'id' => 'frm-dependentSelectForm1-dependentSelect',
187 | 			'items' => [
188 | 				1 => ['key' => 1, 'value' => 'First', 'attributes' => ['value' => 1]],
189 | 				2 => ['key' => 2, 'value' => 'Still first', 'attributes' => ['value' => 2]],
190 | 			],
191 | 			'value' => null,
192 | 			'prompt' => '---',
193 | 			'disabledWhenEmpty' => null,
194 | 		], $response->getPayload()->dependentselectbox);
195 | 	}
196 | 
197 | 
198 | 	/**
199 | 	 * @throws NasExt\Forms\DependentCallbackException Dependent callback for "frm-dependentSelectForm2-dependentSelect" must be set!
200 | 	 * @return void
201 | 	 */
202 | 	public function testSix()
203 | 	{
204 | 		$configurator = new Nette\Configurator();
205 | 		$configurator->setTempDirectory(TEMP_DIR);
206 | 		$configurator->addConfig($this->getConfig());
207 | 
208 | 		$container = $configurator->createContainer();
209 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
210 | 
211 | 		$presenter = $presenterFactory->createPresenter('Base');
212 | 		$presenter->autoCanonicalize = false;
213 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentSelect2Exception1']);
214 | 		$response = $presenter->run($request);
215 | 
216 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
217 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
218 | 
219 | 		$response->getSource()->render();
220 | 	}
221 | 
222 | 
223 | 	/**
224 | 	 * @throws NasExt\Forms\DependentCallbackException Callback for "frm-dependentSelectForm2-dependentSelect" must return NasExt\Forms\DependentData instance!
225 | 	 * @return void
226 | 	 */
227 | 	public function testSeven()
228 | 	{
229 | 		$configurator = new Nette\Configurator();
230 | 		$configurator->setTempDirectory(TEMP_DIR);
231 | 		$configurator->addConfig($this->getConfig());
232 | 
233 | 		$container = $configurator->createContainer();
234 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
235 | 
236 | 		$presenter = $presenterFactory->createPresenter('Base');
237 | 		$presenter->autoCanonicalize = false;
238 | 		$request = new Nette\Application\Request('Base', 'GET', ['action' => 'dependentSelect2Exception2']);
239 | 		$response = $presenter->run($request);
240 | 
241 | 		Tester\Assert::true($response instanceof Nette\Application\Responses\TextResponse);
242 | 		Tester\Assert::true($response->getSource() instanceof Nette\Application\UI\ITemplate);
243 | 
244 | 		$response->getSource()->render();
245 | 	}
246 | 
247 | 
248 | 	/**
249 | 	 * @return void
250 | 	 */
251 | 	public function testEight()
252 | 	{
253 | 		$configurator = new Nette\Configurator();
254 | 		$configurator->setTempDirectory(TEMP_DIR);
255 | 		$configurator->addConfig($this->getConfig());
256 | 
257 | 		$container = $configurator->createContainer();
258 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
259 | 
260 | 		$presenter = $presenterFactory->createPresenter('Base');
261 | 		$presenter->autoCanonicalize = false;
262 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect2Disabled1'], ['_do' => 'dependentSelectForm2-submit'], ['select' => 1, 'dependentSelect' => 2]);
263 | 		$response = $presenter->run($request);
264 | 
265 | 
266 | 		// check form
267 | 		$form = $presenter['dependentSelectForm2'];
268 | 
269 | 		Tester\Assert::true($form->isSubmitted());
270 | 		Tester\Assert::true($form->isSuccess());
271 | 		Tester\Assert::same(['select' => 1], (array) $form->getValues());
272 | 	}
273 | 
274 | 
275 | 	/**
276 | 	 * @return void
277 | 	 */
278 | 	public function testNine()
279 | 	{
280 | 		$configurator = new Nette\Configurator();
281 | 		$configurator->setTempDirectory(TEMP_DIR);
282 | 		$configurator->addConfig($this->getConfig());
283 | 
284 | 		$container = $configurator->createContainer();
285 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
286 | 
287 | 		$presenter = $presenterFactory->createPresenter('Base');
288 | 		$presenter->autoCanonicalize = false;
289 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect2Disabled2'], ['_do' => 'dependentSelectForm2-submit'], ['select' => 1, 'dependentSelect' => 2]);
290 | 		$response = $presenter->run($request);
291 | 
292 | 
293 | 		// check form
294 | 		$form = $presenter['dependentSelectForm2'];
295 | 
296 | 		Tester\Assert::true($form->isSubmitted());
297 | 		Tester\Assert::true($form->isSuccess());
298 | 		Tester\Assert::same(['select' => 1, 'dependentSelect' => null], (array) $form->getValues());
299 | 	}
300 | 
301 | 
302 | 	/**
303 | 	 * @return void
304 | 	 */
305 | 	public function testTen()
306 | 	{
307 | 		$configurator = new Nette\Configurator();
308 | 		$configurator->setTempDirectory(TEMP_DIR);
309 | 		$configurator->addConfig($this->getConfig());
310 | 
311 | 		$container = $configurator->createContainer();
312 | 		$presenterFactory = $container->getByType('Nette\\Application\\IPresenterFactory');
313 | 
314 | 		$presenter = $presenterFactory->createPresenter('Base');
315 | 		$presenter->autoCanonicalize = false;
316 | 		$request = new Nette\Application\Request('Base', 'POST', ['action' => 'dependentSelect2Disabled3'], ['_do' => 'dependentSelectForm2-submit'], ['select' => 3]);
317 | 		$response = $presenter->run($request);
318 | 
319 | 
320 | 		// check form
321 | 		$form = $presenter['dependentSelectForm2'];
322 | 
323 | 		Tester\Assert::true($form->isSubmitted());
324 | 		Tester\Assert::true($form->isSuccess());
325 | 		Tester\Assert::true($form['dependentSelect']->isOmitted());
326 | 		Tester\Assert::same(['select' => 3], (array) $form->getValues());
327 | 	}
328 | 
329 | 
330 | 	/**
331 | 	 * @internal
332 | 	 */
333 | 	private function getConfig()
334 | 	{
335 | 		return Tester\FileMock::create('
336 | extensions:
337 | 	dependentSelectBox: NasExt\Forms\DependentExtension
338 | 
339 | application:
340 | 	mapping:
341 | 		*: NasExt\Forms\Tests\App\Presenters\*Presenter
342 | 
343 | services:
344 | 	base.presenter:
345 | 		class: NasExt\Forms\Tests\App\Presenters\BasePresenter
346 | 
347 | 	routing.router: NasExt\Forms\Tests\App\Router\Router::createRouter', 'neon');
348 | 	}
349 | }
350 | 
351 | 
352 | $test = new DependentSelectBoxTest;
353 | $test->run();
354 | 


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