Coverage Report

Coverage Report - org.kuali.student.common.ui.client.configurable.mvc.binding.HasTextBinding

Classes in this File

Line Coverage

Branch Coverage

Complexity

HasTextBinding

0/66

0/42

10.333

HasTextBinding$1

0/1

N/A

10.333

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.common.ui.client.configurable.mvc.binding;
 
 import java.util.Date;
 
 import org.kuali.student.common.ui.client.mvc.DataModel;
 import org.kuali.student.common.ui.client.validator.ClientDateParser;
 import org.kuali.student.core.assembly.data.QueryPath;
 import org.kuali.student.core.assembly.data.Data.DataType;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.user.client.ui.HasText;
 
 public class HasTextBinding extends ModelWidgetBindingSupport<HasText> {
     public static HasTextBinding INSTANCE = new HasTextBinding();
 
     private ClientDateParser dateParser = new ClientDateParser();
 
     private HasTextBinding() {}
 
     @Override
     public void setModelValue(HasText object, DataModel model, String path) {
         try {
             QueryPath qPath = QueryPath.parse(path);
             DataType type = model.getType(qPath);
             String newValue = object.getText().trim();
 
             try {
                 switch (type) {
                     case STRING:
                         if (!nullsafeEquals(model.get(qPath), newValue)) {
                             model.set(qPath, newValue);
                             setDirtyFlag(model, qPath);
                         }
                         break;
                     case INTEGER:
                                 if(newValue != null && newValue.isEmpty()){
                                         Integer value = null;
                                         model.set(qPath, value);
                                         setDirtyFlag(model, qPath);
                                 }
                                 else{
                             int intValue = Integer.parseInt(newValue);
                             if (!nullsafeEquals(model.get(qPath), intValue)) {
                                 model.set(qPath, intValue);
                                 setDirtyFlag(model, qPath);
                             }
                                 }
                         break;
                     case LONG:
                         long longValue = Long.parseLong(newValue);
                         if (!nullsafeEquals(model.get(qPath), longValue)) {
                             model.set(qPath, longValue);
                             setDirtyFlag(model, qPath);
                         }
                         break;
                     case FLOAT:
                         float floatValue = Float.parseFloat(newValue);
                         if (!nullsafeEquals(model.get(qPath), floatValue)) {
                             model.set(qPath, floatValue);
                             setDirtyFlag(model, qPath);
                         }
                         break;
                     case DOUBLE:
                         double doubleValue = Double.parseDouble(newValue);
                         if (!nullsafeEquals(model.get(qPath), doubleValue)) {
                             model.set(qPath, doubleValue);
                             setDirtyFlag(model, qPath);
                         }
                         break;
                     case BOOLEAN:
                         if (newValue.equalsIgnoreCase("true") || newValue.equalsIgnoreCase("false")) {
                             boolean booleanValue = Boolean.parseBoolean(newValue);
                             if (!nullsafeEquals(model.get(qPath), booleanValue)) {
                                 model.set(qPath, booleanValue);
                                 setDirtyFlag(model, qPath);
                             }
                         } else {
                             throw new UnsupportedOperationException("BooleanTypes can only be set with true or false");
                         }
                         break;
                     case DATE:
                         Date dateValue = dateParser.parseDate(newValue);
                         if (!nullsafeEquals(model.get(qPath), dateValue)) {
                             model.set(qPath, dateValue);
                             setDirtyFlag(model, qPath);
                         }
                         break;
                 }
             } catch (Exception e) {
                 GWT.log("Unable to coerce type for " + path + ", falling back to String", e);
                 model.set(qPath, newValue);
             }
         } catch (Exception e) {
             GWT.log("Error setting model value for: " + path, e);
         }
     }
 
     @Override
     public void setWidgetValue(HasText object, DataModel model, String path) {
         try {
             QueryPath qPath = QueryPath.parse(path);
             
             Object value = null;
             if(model!=null){
                     value = model.get(qPath);
             }
 
             if (value != null && object != null) {
                 if (value instanceof Date) {
                     object.setText(dateParser.toString((Date) value));
                 } else {
                     object.setText(value.toString());
                 }
             } else if (value == null && object != null) {
                 object.setText("");
             }
         } catch (Exception e) {
             GWT.log("Error setting widget value for: " + path, e);
         }
     }
 
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.ui.client.configurable.mvc.binding;
17
18		import java.util.Date;
19
20		import org.kuali.student.common.ui.client.mvc.DataModel;
21		import org.kuali.student.common.ui.client.validator.ClientDateParser;
22		import org.kuali.student.core.assembly.data.QueryPath;
23		import org.kuali.student.core.assembly.data.Data.DataType;
24
25		import com.google.gwt.core.client.GWT;
26		import com.google.gwt.user.client.ui.HasText;
27
28	0	public class HasTextBinding extends ModelWidgetBindingSupport<HasText> {
29	0	public static HasTextBinding INSTANCE = new HasTextBinding();
30
31	0	private ClientDateParser dateParser = new ClientDateParser();
32
33	0	private HasTextBinding() {}
34
35		@Override
36		public void setModelValue(HasText object, DataModel model, String path) {
37		try {
38	0	QueryPath qPath = QueryPath.parse(path);
39	0	DataType type = model.getType(qPath);
40	0	String newValue = object.getText().trim();
41
42		try {
43	0	switch (type) {
44		case STRING:
45	0	if (!nullsafeEquals(model.get(qPath), newValue)) {
46	0	model.set(qPath, newValue);
47	0	setDirtyFlag(model, qPath);
48		}
49		break;
50		case INTEGER:
51	0	if(newValue != null && newValue.isEmpty()){
52	0	Integer value = null;
53	0	model.set(qPath, value);
54	0	setDirtyFlag(model, qPath);
55	0	}
56		else{
57	0	int intValue = Integer.parseInt(newValue);
58	0	if (!nullsafeEquals(model.get(qPath), intValue)) {
59	0	model.set(qPath, intValue);
60	0	setDirtyFlag(model, qPath);
61		}
62		}
63	0	break;
64		case LONG:
65	0	long longValue = Long.parseLong(newValue);
66	0	if (!nullsafeEquals(model.get(qPath), longValue)) {
67	0	model.set(qPath, longValue);
68	0	setDirtyFlag(model, qPath);
69		}
70		break;
71		case FLOAT:
72	0	float floatValue = Float.parseFloat(newValue);
73	0	if (!nullsafeEquals(model.get(qPath), floatValue)) {
74	0	model.set(qPath, floatValue);
75	0	setDirtyFlag(model, qPath);
76		}
77		break;
78		case DOUBLE:
79	0	double doubleValue = Double.parseDouble(newValue);
80	0	if (!nullsafeEquals(model.get(qPath), doubleValue)) {
81	0	model.set(qPath, doubleValue);
82	0	setDirtyFlag(model, qPath);
83		}
84		break;
85		case BOOLEAN:
86	0	if (newValue.equalsIgnoreCase("true") \|\| newValue.equalsIgnoreCase("false")) {
87	0	boolean booleanValue = Boolean.parseBoolean(newValue);
88	0	if (!nullsafeEquals(model.get(qPath), booleanValue)) {
89	0	model.set(qPath, booleanValue);
90	0	setDirtyFlag(model, qPath);
91		}
92	0	} else {
93	0	throw new UnsupportedOperationException("BooleanTypes can only be set with true or false");
94		}
95		break;
96		case DATE:
97	0	Date dateValue = dateParser.parseDate(newValue);
98	0	if (!nullsafeEquals(model.get(qPath), dateValue)) {
99	0	model.set(qPath, dateValue);
100	0	setDirtyFlag(model, qPath);
101		}
102		break;
103		}
104	0	} catch (Exception e) {
105	0	GWT.log("Unable to coerce type for " + path + ", falling back to String", e);
106	0	model.set(qPath, newValue);
107	0	}
108	0	} catch (Exception e) {
109	0	GWT.log("Error setting model value for: " + path, e);
110	0	}
111	0	}
112
113		@Override
114		public void setWidgetValue(HasText object, DataModel model, String path) {
115		try {
116	0	QueryPath qPath = QueryPath.parse(path);
117
118	0	Object value = null;
119	0	if(model!=null){
120	0	value = model.get(qPath);
121		}
122
123	0	if (value != null && object != null) {
124	0	if (value instanceof Date) {
125	0	object.setText(dateParser.toString((Date) value));
126		} else {
127	0	object.setText(value.toString());
128		}
129	0	} else if (value == null && object != null) {
130	0	object.setText("");
131		}
132	0	} catch (Exception e) {
133	0	GWT.log("Error setting widget value for: " + path, e);
134	0	}
135	0	}
136
137		}