View Javadoc

1   /*
2    *  soapUI, copyright (C) 2004-2010 eviware.com 
3    *
4    *  soapUI is free software; you can redistribute it and/or modify it under the 
5    *  terms of version 2.1 of the GNU Lesser General Public License as published by 
6    *  the Free Software Foundation.
7    *
8    *  soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
9    *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
10   *  See the GNU Lesser General Public License for more details at gnu.org.
11   */
12  package com.eviware.soapui.impl.rest.support;
13  
14  import java.beans.PropertyChangeEvent;
15  import java.beans.PropertyChangeListener;
16  import java.beans.PropertyChangeSupport;
17  import java.util.ArrayList;
18  import java.util.Collection;
19  import java.util.HashMap;
20  import java.util.HashSet;
21  import java.util.List;
22  import java.util.Map;
23  import java.util.Properties;
24  import java.util.Set;
25  
26  import javax.xml.namespace.QName;
27  
28  import com.eviware.soapui.model.ModelItem;
29  import com.eviware.soapui.model.propertyexpansion.PropertyExpansion;
30  import com.eviware.soapui.model.testsuite.TestProperty;
31  import com.eviware.soapui.model.testsuite.TestPropertyListener;
32  import com.eviware.soapui.support.types.StringToStringMap;
33  
34  public class RestRequestParamsPropertyHolder implements RestParamsPropertyHolder, TestPropertyListener
35  {
36  	private StringToStringMap values;
37  	private RestParamsPropertyHolder methodParams;
38  	private ModelItem modelItem;
39  	private Set<TestPropertyListener> listeners = new HashSet<TestPropertyListener>();
40  	private Map<RestParamProperty, InternalRestParamProperty> wrappers = new HashMap<RestParamProperty, InternalRestParamProperty>();
41  
42  	public RestRequestParamsPropertyHolder( RestParamsPropertyHolder methodParams, ModelItem modelItem,
43  			StringToStringMap values )
44  	{
45  		this.methodParams = methodParams;
46  		this.modelItem = modelItem;
47  		this.values = values;
48  		/*
49  		 * for (String key : methodParams.getPropertyNames()) { if
50  		 * (!values.containsKey(key) && methodParams.getPropertyValue(key) != null
51  		 * && !(methodParams.getPropertyValue(key).length() == 0)) {
52  		 * values.put(key, methodParams.getPropertyValue(key)); } }
53  		 */
54  		methodParams.addTestPropertyListener( this );
55  	}
56  	
57  	public void reset( RestParamsPropertyHolder methodParams, StringToStringMap values )
58  	{
59  		this.methodParams = methodParams;
60  		this.values = values;
61  		wrappers.clear();
62  	}
63  
64  	public RestParamProperty addProperty( String name )
65  	{
66  		return methodParams.addProperty(name);
67  	}
68  
69  	public void addParameter( RestParamProperty prop )
70  	{
71  		methodParams.addParameter( prop );
72  	}
73  
74  	public void addTestPropertyListener( TestPropertyListener listener )
75  	{
76  		listeners.add( listener );
77  	}
78  
79  	public void clear()
80  	{
81  		for( String key : getPropertyNames() )
82  		{
83  			String oldValue = getPropertyValue( key );
84  			values.put( key, "" );
85  			firePropertyValueChanged( key, oldValue, "" );
86  		}
87  	}
88  
89  	public boolean containsKey( Object key )
90  	{
91  		return methodParams.containsKey( key );
92  	}
93  
94  	public boolean containsValue( Object value )
95  	{
96  		return values.containsValue( value ) || methodParams.containsValue( value );
97  	}
98  
99  	public Set<Entry<String, TestProperty>> entrySet()
100 	{
101 		Set<Entry<String, TestProperty>> entrySet = methodParams.entrySet();
102 		for( Entry<String, TestProperty> entry : entrySet )
103 		{
104 			entry.setValue( getWrapper( ( RestParamProperty )entry.getValue() ) );
105 		}
106 		return entrySet;
107 	}
108 
109 	public RestParamProperty get( Object key )
110 	{
111 		if( !methodParams.containsKey( key ) )
112 			return null;
113 		return getWrapper( methodParams.get( key ) );
114 	}
115 
116 	public ModelItem getModelItem()
117 	{
118 		return methodParams.getModelItem();
119 	}
120 
121 	public Map<String, TestProperty> getProperties()
122 	{
123 		Map<String, TestProperty> map = methodParams.getProperties();
124 		for( String key : map.keySet() )
125 		{
126 			map.put( key, getWrapper( ( RestParamProperty )map.get( key ) ) );
127 		}
128 		return map;
129 	}
130 
131 	public String getPropertiesLabel()
132 	{
133 		return methodParams.getPropertiesLabel();
134 	}
135 
136 	public RestParamProperty getProperty( String name )
137 	{
138 		if( !methodParams.hasProperty( name ) )
139 			return null;
140 		return getWrapper( methodParams.getProperty( name ) );
141 	}
142 
143 	public RestParamProperty getPropertyAt( int index )
144 	{
145 		if( methodParams.getPropertyCount() <= index )
146 			return null;
147 		return getWrapper( methodParams.getPropertyAt( index ) );
148 	}
149 
150 	public int getPropertyCount()
151 	{
152 		return methodParams.getPropertyCount();
153 	}
154 
155 	public PropertyExpansion[] getPropertyExpansions()
156 	{
157 		return methodParams.getPropertyExpansions();
158 	}
159 
160 	public int getPropertyIndex( String name )
161 	{
162 		return methodParams.getPropertyIndex( name );
163 	}
164 
165 	public String[] getPropertyNames()
166 	{
167 		return methodParams.getPropertyNames();
168 	}
169 
170 	public String getPropertyValue( String name )
171 	{
172 		return values.containsKey( name ) ? values.get( name ) : methodParams.getPropertyValue( name );
173 	}
174 
175 	public boolean hasProperty( String name )
176 	{
177 		return methodParams.hasProperty( name );
178 	}
179 
180 	public boolean isEmpty()
181 	{
182 		return methodParams.isEmpty();
183 	}
184 
185 	public Set<String> keySet()
186 	{
187 		return methodParams.keySet();
188 	}
189 
190 	public void moveProperty( String propertyName, int targetIndex )
191 	{
192 		methodParams.moveProperty( propertyName, targetIndex );
193 	}
194 
195 	public TestProperty put( String key, TestProperty value )
196 	{
197 		if( value.getValue() != null )
198 			values.put( key, value.getValue() );
199 		else
200 			values.remove( key );
201 		return get( key );
202 	}
203 
204 	public void putAll( Map<? extends String, ? extends TestProperty> m )
205 	{
206 		// methodParams.putAll(m);
207 		for( Entry<? extends String, ? extends TestProperty> e : m.entrySet() )
208 			put( e.getKey(), e.getValue() );
209 	}
210 
211 	public TestProperty remove( Object key )
212 	{
213 		values.remove( key );
214 		return methodParams.get( key );
215 	}
216 
217 	public RestParamProperty removeProperty( String propertyName )
218 	{
219 		values.remove( propertyName );
220 		return methodParams.getProperty( propertyName );
221 	}
222 
223 	public void removeTestPropertyListener( TestPropertyListener listener )
224 	{
225 		listeners.remove( listener );
226 	}
227 
228 	public boolean renameProperty( String name, String newName )
229 	{
230 		values.put( newName, values.get( name ) );
231 		values.remove( name );
232 		return methodParams.renameProperty( name, newName );
233 	}
234 
235 	public void resetValues()
236 	{
237 		values.clear();
238 	}
239 
240 	public void saveTo( Properties props )
241 	{
242 		int count = getPropertyCount();
243 		for( int i = 0; i < count; i++ )
244 		{
245 			RestParamProperty p = getPropertyAt( i );
246 			String name = p.getName();
247 			String value = values.containsKey( name ) ? values.get( name ) : p.getValue();
248 			if( value == null )
249 				value = "";
250 
251 			props.setProperty( name, value );
252 		}
253 	}
254 
255 	public void setPropertiesLabel( String propertiesLabel )
256 	{
257 		// methodParams.setPropertiesLabel(propertiesLabel);
258 	}
259 
260 	public void setPropertyValue( String name, String value )
261 	{
262 		if( value == null )
263 			values.remove( name );
264 		else
265 			values.put( name, value );
266 	}
267 
268 	public int size()
269 	{
270 		return methodParams.size();
271 	}
272 
273 	public Collection<TestProperty> values()
274 	{
275 		List<TestProperty> ret = new ArrayList<TestProperty>();
276 		for( TestProperty p : methodParams.values() )
277 		{
278 			ret.add( getWrapper( ( RestParamProperty )p ) );
279 		}
280 		return ret;
281 	}
282 
283 	private void firePropertyAdded( String name )
284 	{
285 		TestPropertyListener[] listenersArray = listeners.toArray( new TestPropertyListener[listeners.size()] );
286 		for( TestPropertyListener listener : listenersArray )
287 		{
288 			listener.propertyAdded( name );
289 		}
290 	}
291 
292 	private void firePropertyRemoved( String name )
293 	{
294 		TestPropertyListener[] listenersArray = listeners.toArray( new TestPropertyListener[listeners.size()] );
295 		for( TestPropertyListener listener : listenersArray )
296 		{
297 			listener.propertyRemoved( name );
298 		}
299 	}
300 
301 	private void firePropertyMoved( String name, int oldIndex, int newIndex )
302 	{
303 		TestPropertyListener[] listenersArray = listeners.toArray( new TestPropertyListener[listeners.size()] );
304 		for( TestPropertyListener listener : listenersArray )
305 		{
306 			listener.propertyMoved( name, oldIndex, newIndex );
307 		}
308 	}
309 
310 	private void firePropertyRenamed( String oldName, String newName )
311 	{
312 		TestPropertyListener[] listenersArray = listeners.toArray( new TestPropertyListener[listeners.size()] );
313 		for( TestPropertyListener listener : listenersArray )
314 		{
315 			listener.propertyRenamed( oldName, newName );
316 		}
317 	}
318 
319 	private void firePropertyValueChanged( String name, String oldValue, String newValue )
320 	{
321 		TestPropertyListener[] listenersArray = listeners.toArray( new TestPropertyListener[listeners.size()] );
322 		for( TestPropertyListener listener : listenersArray )
323 		{
324 			listener.propertyValueChanged( name, oldValue, newValue );
325 		}
326 	}
327 
328 	private RestParamProperty getWrapper( RestParamProperty key )
329 	{
330 		if( !wrappers.containsKey( key ) )
331 		{
332 			wrappers.put( key, new InternalRestParamProperty( key ) );
333 		}
334 		return wrappers.get( key );
335 	}
336 
337 	public void propertyAdded( String name )
338 	{
339 		firePropertyAdded( name );
340 	}
341 
342 	public void propertyMoved( String name, int oldIndex, int newIndex )
343 	{
344 		firePropertyMoved( name, oldIndex, newIndex );
345 	}
346 
347 	public void propertyRemoved( String name )
348 	{
349 		values.remove( name );
350 		firePropertyRemoved( name );
351 	}
352 
353 	public void propertyRenamed( String oldName, String newName )
354 	{
355 		if( values.containsKey( oldName ) )
356 		{
357 			values.put( newName, values.get( oldName ) );
358 			values.remove( oldName );
359 		}
360 		firePropertyRenamed( oldName, newName );
361 	}
362 
363 	public void propertyValueChanged( String name, String oldValue, String newValue )
364 	{
365 		if( !values.containsKey( name ) )
366 			firePropertyValueChanged( name, oldValue, newValue );
367 	}
368 
369 	public class InternalRestParamProperty implements RestParamProperty, PropertyChangeListener
370 	{
371 		private RestParamProperty overriddenProp;
372 		private PropertyChangeSupport propertySupport;
373 
374 		public InternalRestParamProperty( RestParamProperty override )
375 		{
376 			overriddenProp = override;
377 			overriddenProp.addPropertyChangeListener( this );
378 			propertySupport = new PropertyChangeSupport( this );
379 		}
380 
381 		public void addPropertyChangeListener( PropertyChangeListener listener )
382 		{
383 			propertySupport.addPropertyChangeListener( listener );
384 		}
385 
386 		public void addPropertyChangeListener( String propertyName, PropertyChangeListener listener )
387 		{
388 			propertySupport.addPropertyChangeListener( propertyName, listener );
389 		}
390 
391 		public boolean isDisableUrlEncoding()
392 		{
393 			return overriddenProp.isDisableUrlEncoding();
394 		}
395 
396 		public void removePropertyChangeListener( PropertyChangeListener listener )
397 		{
398 			propertySupport.removePropertyChangeListener( listener );
399 		}
400 
401 		public void removePropertyChangeListener( String propertyName, PropertyChangeListener listener )
402 		{
403 			propertySupport.removePropertyChangeListener( propertyName, listener );
404 		}
405 
406 		public void setDisableUrlEncoding( boolean encode )
407 		{
408 			// overriddenProp.setDisableUrlEncoding(encode);
409 		}
410 
411 		public void setName( String name )
412 		{
413 			// overriddenProp.setName(name);
414 		}
415 
416 		public String getDefaultValue()
417 		{
418 			return overriddenProp.getDefaultValue();
419 		}
420 
421 		public String getDescription()
422 		{
423 			return overriddenProp.getDescription();
424 		}
425 
426 		public ModelItem getModelItem()
427 		{
428 			return modelItem;
429 		}
430 
431 		public String getName()
432 		{
433 			return overriddenProp.getName();
434 		}
435 
436 		public QName getType()
437 		{
438 			return overriddenProp.getType();
439 		}
440 
441 		public String getValue()
442 		{
443 			if( values.containsKey( getName() ) && values.get( getName() ) != null )
444 				return values.get( getName() );
445 			return getDefaultValue();
446 		}
447 
448 		public boolean isReadOnly()
449 		{
450 			return overriddenProp.isReadOnly();
451 		}
452 
453 		public void setValue( String value )
454 		{
455 			String oldValue = getValue();
456 			if( getDefaultValue() != null && getDefaultValue().equals( value ) )
457 				value = null;
458 			if( value == null )
459 				values.remove( getName() );
460 			else
461 				values.put( getName(), value );
462 			firePropertyValueChanged( getName(), oldValue, getValue() );
463 		}
464 
465 		public String[] getOptions()
466 		{
467 			return overriddenProp.getOptions();
468 		}
469 
470 		public boolean getRequired()
471 		{
472 			return overriddenProp.getRequired();
473 		}
474 
475 		public ParameterStyle getStyle()
476 		{
477 			return overriddenProp.getStyle();
478 		}
479 
480 		public void setDefaultValue( String default1 )
481 		{
482 			// overriddenProp.setDefaultValue(default1);
483 		}
484 
485 		public void setDescription( String description )
486 		{
487 			// overriddenProp.setDescription(description);
488 		}
489 
490 		public void setOptions( String[] arg0 )
491 		{
492 			// overriddenProp.setOptions(arg0);
493 		}
494 
495 		public void setRequired( boolean arg0 )
496 		{
497 			// overriddenProp.setRequired(arg0);
498 		}
499 
500 		public void setStyle( ParameterStyle style )
501 		{
502 			// overriddenProp.setStyle(style);
503 		}
504 
505 		public void setType( QName arg0 )
506 		{
507 			// overriddenProp.setType(arg0);
508 		}
509 
510 		public void propertyChange( PropertyChangeEvent evt )
511 		{
512 			propertySupport.firePropertyChange( evt );
513 		}
514 	}
515 	
516 	public List<TestProperty> getPropertyList()
517 	{
518 		return methodParams.getPropertyList();
519 	}
520 
521 }