ValidateElement.java

  1. /**
  2.  *
  3.  * Copyright 2014 Anno van Vliet 
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.xdatavalidation.packet;

  19. import org.jivesoftware.smack.packet.NamedElement;
  20. import org.jivesoftware.smack.packet.ExtensionElement;
  21. import org.jivesoftware.smack.util.NumberUtil;
  22. import org.jivesoftware.smack.util.StringUtils;
  23. import org.jivesoftware.smack.util.XmlStringBuilder;
  24. import org.jivesoftware.smackx.xdata.FormField;
  25. import org.jivesoftware.smackx.xdata.packet.DataForm;
  26. import org.jivesoftware.smackx.xdatavalidation.ValidationConsistencyException;

  28. /**
  29.  * DataValidation Extension according to XEP-0122: Data Forms Validation. This specification defines a
  30.  * backwards-compatible extension to the XMPP Data Forms protocol that enables applications to specify additional
  31.  * validation guidelines related to a {@link FormField} in a {@link DataForm}, such as validation of standard XML
  32.  * datatypes, application-specific datatypes, value ranges, and regular expressions.
  33.  *
  34.  * @author Anno van Vliet
  35.  */
  36. public abstract class ValidateElement implements ExtensionElement {

  38.     public static final String DATATYPE_XS_STRING = "xs:string";
  39.     public static final String ELEMENT = "validate";
  40.     public static final String NAMESPACE = "http://jabber.org/protocol/xdata-validate";

  42.     private final String datatype;

  44.     private ListRange listRange;

  46.     /**
  47.      * The 'datatype' attribute specifies the datatype. This attribute is OPTIONAL, and when not specified, defaults to
  48.      * "xs:string".
  49.      * 
  50.      * @param datatype the data type of any value contained within the {@link FormField} element.
  51.      */
  52.     private ValidateElement(String datatype) {
  53.         this.datatype = StringUtils.isNotEmpty(datatype) ? datatype : null;
  54.     }

  56.     /**
  57.      * Specifies the data type of any value contained within the {@link FormField} element. It MUST meet one of the
  58.      * following conditions:
  59.      * <ul>
  60.      * <li>Start with "xs:", and be one of the "built-in" datatypes defined in XML Schema Part 2 <a
  61.      * href="http://www.xmpp.org/extensions/xep-0122.html#nt-idp1476016">[2]</a></li>
  62.      * <li>Start with a prefix registered with the XMPP Registrar <a
  63.      * href="http://www.xmpp.org/extensions/xep-0122.html#nt-idp1478544">[3]</a></li>
  64.      * <li>Start with "x:", and specify a user-defined datatype <a
  65.      * href="http://www.xmpp.org/extensions/xep-0122.html#nt-idp1477360">[4]</a></li>
  66.      * </ul>
  67.      * 
  68.      * @return the datatype
  69.      */
  70.     public String getDatatype() {
  71.         return datatype != null ? datatype : DATATYPE_XS_STRING;
  72.     }

  74.     @Override
  75.     public String getElementName() {
  76.         return ELEMENT;
  77.     }

  79.     @Override
  80.     public String getNamespace() {
  81.         return NAMESPACE;
  82.     }

  84.     @Override
  85.     public XmlStringBuilder toXML() {
  86.         XmlStringBuilder buf = new XmlStringBuilder(this);
  87.         buf.optAttribute("datatype", datatype);
  88.         buf.rightAngleBracket();
  89.         appendXML(buf);
  90.         buf.optAppend(getListRange());
  91.         buf.closeElement(this);
  92.         return buf;
  93.     }

  95.     /**
  96.      * @param buf
  97.      */
  98.     protected abstract void appendXML(XmlStringBuilder buf);

  100.     /**
  101.      * @param listRange the listRange to set
  102.      */
  103.     public void setListRange(ListRange listRange) {
  104.         this.listRange = listRange;
  105.     }

  107.     /**
  108.      * @return the listRange
  109.      */
  110.     public ListRange getListRange() {
  111.         return listRange;
  112.     }

  114.     /**
  115.      * Check if this element is consistent according to the business rules in XEP=0122
  116.      * 
  117.      * @param formField
  118.      */
  119.     public abstract void checkConsistency(FormField formField);

  121.     /**
  122.      * Validation only against the datatype itself. Indicates that the value(s) should simply match the field type and
  123.      * datatype constraints.
  124.      * 
  125.      * @see ValidateElement
  126.      */
  127.     public static class BasicValidateElement extends ValidateElement {

  129.         public static final String METHOD = "basic";

  131.         /**
  132.          * @param dataType
  133.          * @see #getDatatype()
  134.          */
  135.         public BasicValidateElement(String dataType) {
  136.             super(dataType);
  137.         }

  139.         @Override
  140.         protected void appendXML(XmlStringBuilder buf) {
  141.             buf.emptyElement(METHOD);
  142.         }

  144.         public void checkConsistency(FormField formField) {
  145.             checkListRangeConsistency(formField);
  146.             if (formField.getType() != null) {
  147.                 switch (formField.getType()) {
  148.                 case hidden:
  149.                 case jid_multi:
  150.                 case jid_single:
  151.                     throw new ValidationConsistencyException(String.format(
  152.                                     "Field type '%1$s' is not consistent with validation method '%2$s'.",
  153.                                     formField.getType(), BasicValidateElement.METHOD));
  154.                 default:
  155.                     break;
  156.                 }
  157.             }
  158.         }

  160.     }

  162.     /**
  163.      * For "list-single" or "list-multi", indicates that the user may enter a custom value (matching the datatype
  164.      * constraints) or choose from the predefined values.
  165.      * 
  166.      * @see ValidateElement
  167.      */
  168.     public static class OpenValidateElement extends ValidateElement {

  170.         public static final String METHOD = "open";

  172.         /**
  173.          * @param dataType
  174.          * @see #getDatatype()
  175.          */
  176.         public OpenValidateElement(String dataType) {
  177.             super(dataType);
  178.         }

  180.         @Override
  181.         protected void appendXML(XmlStringBuilder buf) {
  182.             buf.emptyElement(METHOD);
  183.         }

  185.         public void checkConsistency(FormField formField) {
  186.             checkListRangeConsistency(formField);
  187.             if (formField.getType() != null) {
  188.                 switch (formField.getType()) {
  189.                 case hidden:
  190.                     throw new ValidationConsistencyException(String.format(
  191.                                     "Field type '%1$s' is not consistent with validation method '%2$s'.",
  192.                                     formField.getType(), OpenValidateElement.METHOD));
  193.                 default:
  194.                     break;
  195.                 }
  196.             }
  197.         }

  199.     }

  201.     /**
  202.      * Indicate that the value should fall within a certain range.
  203.      * 
  204.      * @see ValidateElement
  205.      */
  206.     public static class RangeValidateElement extends ValidateElement {

  208.         public static final String METHOD = "range";
  209.         private final String min;
  210.         private final String max;

  212.         /**
  213.          * @param dataType
  214.          * @param min the minimum allowable value. This attribute is OPTIONAL. The value depends on the datatype in use.
  215.          * @param max the maximum allowable value. This attribute is OPTIONAL. The value depends on the datatype in use.
  216.          * @see #getDatatype()
  217.          * 
  218.          */
  219.         public RangeValidateElement(String dataType, String min, String max) {
  220.             super(dataType);
  221.             this.min = min;
  222.             this.max = max;
  223.         }

  225.         @Override
  226.         protected void appendXML(XmlStringBuilder buf) {
  227.             buf.halfOpenElement(METHOD);
  228.             buf.optAttribute("min", getMin());
  229.             buf.optAttribute("max", getMax());
  230.             buf.closeEmptyElement();
  231.         }

  233.         /**
  234.          * The 'min' attribute specifies the minimum allowable value.
  235.          * 
  236.          * @return the minimum allowable value. This attribute is OPTIONAL. The value depends on the datatype in use.
  237.          */
  238.         public String getMin() {
  239.             return min;
  240.         }

  242.         /**
  243.          * The 'max' attribute specifies the maximum allowable value.
  244.          * 
  245.          * @return the maximum allowable value. This attribute is OPTIONAL. The value depends on the datatype in use.
  246.          */
  247.         public String getMax() {
  248.             return max;
  249.         }

  251.         public void checkConsistency(FormField formField) {
  252.             checkNonMultiConsistency(formField, METHOD);
  253.             if (getDatatype().equals(ValidateElement.DATATYPE_XS_STRING)) {
  254.                 throw new ValidationConsistencyException(String.format(
  255.                                 "Field data type '%1$s' is not consistent with validation method '%2$s'.",
  256.                                 getDatatype(), RangeValidateElement.METHOD));
  257.             }
  258.         }

  260.     }

  262.     /**
  263.      * Indicates that the value should be restricted to a regular expression. The regular expression must be that
  264.      * defined for <a href="http://www.xmpp.org/extensions/xep-0122.html#nt-idp1501344"> POSIX extended regular
  265.      * expressions </a> including support for <a
  266.      * href="http://www.xmpp.org/extensions/xep-0122.html#nt-idp1502496">Unicode</a>.
  267.      * 
  268.      * @see ValidateElement
  269.      */
  270.     public static class RegexValidateElement extends ValidateElement {

  272.         public static final String METHOD = "regex";
  273.         private final String regex;

  275.         /**
  276.          * @param dataType
  277.          * @param regex
  278.          * @see #getDatatype()
  279.          */
  280.         public RegexValidateElement(String dataType, String regex) {
  281.             super(dataType);
  282.             this.regex = regex;
  283.         }

  285.         /**
  286.          * the expression is that defined for POSIX extended regular expressions, including support for Unicode.
  287.          * 
  288.          * @return the regex
  289.          */
  290.         public String getRegex() {
  291.             return regex;
  292.         }

  294.         @Override
  295.         protected void appendXML(XmlStringBuilder buf) {
  296.             buf.element("regex", getRegex());
  297.         }

  299.         public void checkConsistency(FormField formField) {
  300.             checkNonMultiConsistency(formField, METHOD);
  301.         }

  303.     }

  305.     /**
  306.      * This element indicates for "list-multi", that a minimum and maximum number of options should be selected and/or
  307.      * entered.
  308.      */
  309.     public static class ListRange implements NamedElement {

  311.         public static final String ELEMENT = "list-range";
  312.         private final Long min;
  313.         private final Long max;

  315.         /**
  316.          * The 'max' attribute specifies the maximum allowable number of selected/entered values. The 'min' attribute
  317.          * specifies the minimum allowable number of selected/entered values. Both attributes are optional, but at
  318.          * least one must bet set, and the value must be within the range of a unsigned 32-bit integer.
  319.          * 
  320.          * @param min
  321.          * @param max
  322.          */
  323.         public ListRange(Long min, Long max) {
  324.             if (min != null) {
  325.                 NumberUtil.checkIfInUInt32Range(min);
  326.             }
  327.             if (max != null) {
  328.                 NumberUtil.checkIfInUInt32Range(max);
  329.             }
  330.             if (max == null && min == null) {
  331.                 throw new IllegalArgumentException("Either min or max must be given");
  332.             }
  333.             this.min = min;
  334.             this.max = max;
  335.         }

  337.         public XmlStringBuilder toXML() {
  338.             XmlStringBuilder buf = new XmlStringBuilder(this);
  339.             buf.optLongAttribute("min", getMin());
  340.             buf.optLongAttribute("max", getMax());
  341.             buf.closeEmptyElement();
  342.             return buf;
  343.         }

  345.         @Override
  346.         public String getElementName() {
  347.             return ELEMENT;
  348.         }

  350.         /**
  351.          * The minimum allowable number of selected/entered values.
  352.          * 
  353.          * @return a positive integer, can be null
  354.          */
  355.         public Long getMin() {
  356.             return min;
  357.         }

  359.         /**
  360.          * The maximum allowable number of selected/entered values.
  361.          * 
  362.          * @return a positive integer, can be null
  363.          */
  364.         public Long getMax() {
  365.             return max;
  366.         }

  368.     }

  370.     /**
  371.      * The <list-range/> element SHOULD be included only when the <field/> is of type "list-multi" and SHOULD be ignored
  372.      * otherwise.
  373.      * 
  374.      * @param formField
  375.      */
  376.     protected void checkListRangeConsistency(FormField formField) {
  377.         ListRange listRange = getListRange();
  378.         if (listRange == null) {
  379.             return;
  380.         }

  382.         Long max = listRange.getMax();
  383.         Long min = listRange.getMin();
  384.         if ((max != null || min != null) && formField.getType() != FormField.Type.list_multi) {
  385.             throw new ValidationConsistencyException(
  386.                             "Field type is not of type 'list-multi' while a 'list-range' is defined.");
  387.         }
  388.     }

  390.     /**
  391.      * @param formField
  392.      * @param method
  393.      */
  394.     protected void checkNonMultiConsistency(FormField formField, String method) {
  395.         checkListRangeConsistency(formField);
  396.         if (formField.getType() != null) {
  397.             switch (formField.getType()) {
  398.             case hidden:
  399.             case jid_multi:
  400.             case list_multi:
  401.             case text_multi:
  402.                 throw new ValidationConsistencyException(String.format(
  403.                                 "Field type '%1$s' is not consistent with validation method '%2$s'.",
  404.                                 formField.getType(), method));
  405.             default:
  406.                 break;
  407.             }
  408.         }
  409.     }
  410. }
Created with JaCoCo 0.7.4.201502262128