View Javadoc

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