Coverage Report

Coverage Report - org.kuali.rice.krad.datadictionary.validation.charlevel.RegexValidationPattern

Classes in this File

Line Coverage

Branch Coverage

Complexity

RegexValidationPattern

0/40

0/22

2.625

 /*
  * Copyright 2007-2008 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.opensource.org/licenses/ecl2.php
  *
  * 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.rice.krad.datadictionary.validation.charlevel;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.krad.datadictionary.exporter.ExportMap;
 import org.kuali.rice.krad.datadictionary.validation.CharacterLevelValidationPattern;
 
 /**
  * This is a description of what this class does - ctdang don't forget to fill this in. 
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public class RegexValidationPattern extends CharacterLevelValidationPattern {
 
     private static final long serialVersionUID = -5642894236634278352L;
     private static final Logger LOG=Logger.getLogger(RegexValidationPattern.class);
     /**
      * Regular expression, e.g. "[a-zA-Z0-9]"
      */
     private String pattern;
 
     private String validationErrorMessageKey;
     /**
      * This exports a representation of this instance by an ExportMap.
      * 
      * @see org.kuali.rice.krad.datadictionary.validation.CharacterLevelValidationPattern#extendExportMap(org.kuali.rice.krad.datadictionary.exporter.ExportMap)
      */
     @Override
         public void extendExportMap(ExportMap exportMap) {
         if (LOG.isTraceEnabled()) {
             String message=String.format("ENTRY %s",
                     (exportMap==null)?"null":exportMap.toString());
             LOG.trace(message);
         }
         
         // Set element value
         exportMap.set("type", "regex");
         // Set attribute (of the above element) value
         exportMap.set("pattern", getPattern());
 
         if (LOG.isTraceEnabled()) {
             String message=String.format("EXIT %s",
                     (exportMap==null)?"null":exportMap.toString());
             LOG.trace(message);
         }
         
      }
 
     /**
      * This returns an instance of this class as string.
      * 
      * @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#getPatternXml()
      */
     public String getPatternXml() {
         if (LOG.isTraceEnabled()) {
             String message=String.format("ENTRY");
             LOG.trace(message);
         }
         
         StringBuffer xml = new StringBuffer("<regex ");
         xml.append(pattern);
         xml.append("/>");
 
         if (LOG.isTraceEnabled()) {
             String message=String.format("EXIT %s", xml.toString());
             LOG.trace(message);
         }
         
         return xml.toString();
     }
 
     /**
      * This returns the specified regular expression defined in the data dictionary
      * entry for validating the value of an attribute.
      * 
      * @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#getRegexString()
      */
     @Override
         protected String getRegexString() {
         if (LOG.isTraceEnabled()) {
             String message=String.format("ENTRY %s",
                     (pattern==null)?"null":pattern.toString());
             LOG.trace(message);
         }
         
         if (StringUtils.isEmpty(pattern)) {
             throw new IllegalStateException(this.getClass().getName()+".pattern is empty");
         }
 
         if (LOG.isTraceEnabled()) {
             String message=String.format("EXIT");
             LOG.trace(message);
         }
         
         return pattern;
     }
 
     /**
      * @return the pattern
      */
     public final String getPattern() {
         return this.pattern;
     }
 
     /**
      * @param pattern the pattern to set
      */
     public final void setPattern(String pattern) {
         this.pattern = pattern;
     }
 
         /**
          * @return the validationErrorMessageKey
          */
     @Override
         public String getValidationErrorMessageKey() {
                 return this.validationErrorMessageKey;
         }
 
         /**
          * @param validationErrorMessageKey a message key from the application's message resource bundle signifying the error message
          * to display if some validation does not match this pattern
          */
         public void setValidationErrorMessageKey(String validationErrorMessageKey) {
                 this.validationErrorMessageKey = validationErrorMessageKey;
         }
 
         /**
          * @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#completeValidation()
          */
         @Override
         public void completeValidation() {
                 super.completeValidation();
                 if (StringUtils.isBlank(validationErrorMessageKey)) {
                         throw new ValidationPatternException("Regex Validation Patterns must have a validation error message key defined");
                 }
         }
 }

1		/*
2		* Copyright 2007-2008 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.krad.datadictionary.validation.charlevel;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.apache.log4j.Logger;
20		import org.kuali.rice.krad.datadictionary.exporter.ExportMap;
21		import org.kuali.rice.krad.datadictionary.validation.CharacterLevelValidationPattern;
22
23		/**
24		* This is a description of what this class does - ctdang don't forget to fill this in.
25		*
26		* @author Kuali Rice Team (rice.collab@kuali.org)
27		*
28		*/
29	0	public class RegexValidationPattern extends CharacterLevelValidationPattern {
30
31		private static final long serialVersionUID = -5642894236634278352L;
32	0	private static final Logger LOG=Logger.getLogger(RegexValidationPattern.class);
33		/**
34		* Regular expression, e.g. "[a-zA-Z0-9]"
35		*/
36		private String pattern;
37
38		private String validationErrorMessageKey;
39		/**
40		* This exports a representation of this instance by an ExportMap.
41		*
42		* @see org.kuali.rice.krad.datadictionary.validation.CharacterLevelValidationPattern#extendExportMap(org.kuali.rice.krad.datadictionary.exporter.ExportMap)
43		*/
44		@Override
45		public void extendExportMap(ExportMap exportMap) {
46	0	if (LOG.isTraceEnabled()) {
47	0	String message=String.format("ENTRY %s",
48		(exportMap==null)?"null":exportMap.toString());
49	0	LOG.trace(message);
50		}
51
52		// Set element value
53	0	exportMap.set("type", "regex");
54		// Set attribute (of the above element) value
55	0	exportMap.set("pattern", getPattern());
56
57	0	if (LOG.isTraceEnabled()) {
58	0	String message=String.format("EXIT %s",
59		(exportMap==null)?"null":exportMap.toString());
60	0	LOG.trace(message);
61		}
62
63	0	}
64
65		/**
66		* This returns an instance of this class as string.
67		*
68		* @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#getPatternXml()
69		*/
70		public String getPatternXml() {
71	0	if (LOG.isTraceEnabled()) {
72	0	String message=String.format("ENTRY");
73	0	LOG.trace(message);
74		}
75
76	0	StringBuffer xml = new StringBuffer("<regex ");
77	0	xml.append(pattern);
78	0	xml.append("/>");
79
80	0	if (LOG.isTraceEnabled()) {
81	0	String message=String.format("EXIT %s", xml.toString());
82	0	LOG.trace(message);
83		}
84
85	0	return xml.toString();
86		}
87
88		/**
89		* This returns the specified regular expression defined in the data dictionary
90		* entry for validating the value of an attribute.
91		*
92		* @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#getRegexString()
93		*/
94		@Override
95		protected String getRegexString() {
96	0	if (LOG.isTraceEnabled()) {
97	0	String message=String.format("ENTRY %s",
98		(pattern==null)?"null":pattern.toString());
99	0	LOG.trace(message);
100		}
101
102	0	if (StringUtils.isEmpty(pattern)) {
103	0	throw new IllegalStateException(this.getClass().getName()+".pattern is empty");
104		}
105
106	0	if (LOG.isTraceEnabled()) {
107	0	String message=String.format("EXIT");
108	0	LOG.trace(message);
109		}
110
111	0	return pattern;
112		}
113
114		/**
115		* @return the pattern
116		*/
117		public final String getPattern() {
118	0	return this.pattern;
119		}
120
121		/**
122		* @param pattern the pattern to set
123		*/
124		public final void setPattern(String pattern) {
125	0	this.pattern = pattern;
126	0	}
127
128		/**
129		* @return the validationErrorMessageKey
130		*/
131		@Override
132		public String getValidationErrorMessageKey() {
133	0	return this.validationErrorMessageKey;
134		}
135
136		/**
137		* @param validationErrorMessageKey a message key from the application's message resource bundle signifying the error message
138		* to display if some validation does not match this pattern
139		*/
140		public void setValidationErrorMessageKey(String validationErrorMessageKey) {
141	0	this.validationErrorMessageKey = validationErrorMessageKey;
142	0	}
143
144		/**
145		* @see org.kuali.rice.krad.datadictionary.validation.ValidationPattern#completeValidation()
146		*/
147		@Override
148		public void completeValidation() {
149	0	super.completeValidation();
150	0	if (StringUtils.isBlank(validationErrorMessageKey)) {
151	0	throw new ValidationPatternException("Regex Validation Patterns must have a validation error message key defined");
152		}
153	0	}
154		}