#
# # minixsv, Release 0.3
# file: xsvalSimpleTypes.py
#
# class for validation of XML schema simple types
#
# history:
# 2004-09-09 rl created
#
# Copyright (c) 2004 by Roland Leuthe. All rights reserved.
#
# --------------------------------------------------------------------
# The minixsv XML schema validator is
#
# Copyright (c) 2004 by Roland Leuthe
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------
import sys
import string
import re
class XsSimpleTypeVal:
def __init__ (self, parent):
self.parent = parent
self.xmlIf = parent.xmlIf
self.xsdNSAlias = parent.xsdNSAlias
self.xsdTree = parent.xsdTree
########################################
# validate given value against simpleType
#
def checkSimpleType (self, attrName, typeName, attributeValue, returnDict):
localTypeName = self.xmlIf.extractLocalName(typeName)
if self.parent.xsdTypeDict.has_key(localTypeName):
typedefNode = self.parent.xsdTypeDict[localTypeName]
if typedefNode.getTagName () == self.xsdNSAlias + "simpleType":
self.checkSimpleTypeDef (typedefNode, attrName, attributeValue, returnDict)
else:
raise SimpleTypeError("Type '%s' must be simple type!" %(typeName))
else:
try:
validateBaseType (typeName, attributeValue, returnDict)
except BaseTypeError, errstr:
raise SimpleTypeError("Value of '%s' (%s) %s" %(attrName, attributeValue, errstr))
########################################
# validate given value against simpleType node
#
def checkSimpleTypeDef (self, xsdElement, attrName, attributeValue, returnDict):
restrictionElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "restriction")
listElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "list")
unionElement = xsdElement.getFirstChildNS(self.xsdNSAlias, "union")
if restrictionElement != None:
self._checkRestrictionTag (restrictionElement, attrName, attributeValue, returnDict)
elif listElement != None:
self._checkListTag (listElement, attrName, attributeValue, returnDict)
elif unionElement != None:
self._checkUnionTag (unionElement, attrName, attributeValue, returnDict)
########################################
# validate given value against restriction node
#
def _checkRestrictionTag (self, xsdElement, attrName, attributeValue, returnDict):
# first check against base type
baseType = xsdElement.getAttribute("base")
if baseType != None:
self.checkSimpleType (attrName, baseType, attributeValue, returnDict)
else:
baseTypeNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "simpleType")
self.checkSimpleTypeDef (baseTypeNode, attrName, attributeValue, returnDict)
minExcl = xsdElement.getFirstChildNS(self.xsdNSAlias, "minExclusive")
minIncl = xsdElement.getFirstChildNS(self.xsdNSAlias, "minInclusive")
maxExcl = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxExclusive")
maxIncl = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxInclusive")
if minExcl != None:
minExclReturnDict = {}
minExclValue = minExcl.getAttribute("value")
self.checkSimpleType (attrName, baseType, minExclValue, minExclReturnDict)
if returnDict.has_key("orderedValue") and minExclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] <= minExclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is <= minExclusive (%s)" %(attrName, attributeValue, minExclValue))
elif minIncl != None:
minInclReturnDict = {}
minInclValue = minIncl.getAttribute("value")
self.checkSimpleType (attrName, baseType, minInclValue, minInclReturnDict)
if returnDict.has_key("orderedValue") and minInclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] < minInclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is < minInclusive (%s)" %(attrName, attributeValue, minInclValue))
if maxExcl != None:
maxExclReturnDict = {}
maxExclValue = maxExcl.getAttribute("value")
self.checkSimpleType (attrName, baseType, maxExclValue, maxExclReturnDict)
if returnDict.has_key("orderedValue") and maxExclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] >= maxExclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is >= maxExclusive (%s)" %(attrName, attributeValue, maxExclValue))
elif maxIncl != None:
maxInclReturnDict = {}
maxInclValue = maxIncl.getAttribute("value")
self.checkSimpleType (attrName, baseType, maxInclValue, maxInclReturnDict)
if returnDict.has_key("orderedValue") and maxInclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] > maxInclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is > maxInclusive (%s)" %(attrName, attributeValue, maxInclValue))
totalDigitsNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "totalDigits")
if totalDigitsNode != None:
totalDigitsValue = totalDigitsNode.getAttribute("value")
if totalDigitsNode.getAttribute("fixed") == "true":
if len(re.findall("\d" ,attributeValue)) != string.atoi(totalDigitsValue):
raise SimpleTypeError ("Total number of digits != %s for %s (%s)" %(totalDigitsValue, attrName, attributeValue))
else:
if len(re.findall("\d" ,attributeValue)) > string.atoi(totalDigitsValue):
raise SimpleTypeError ("Total number of digits > %s for %s (%s)" %(totalDigitsValue, attrName, attributeValue))
fractionDigitsNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "fractionDigits")
if fractionDigitsNode != None:
fractionDigitsValue = fractionDigitsNode.getAttribute("value")
result = re.search("(?P<intDigits>\d+)(?P<dot>\.)(?P<fracDigits>\d+)" ,attributeValue)
if result != None:
numberOfFracDigits = len (result.group('fracDigits'))
else:
numberOfFracDigits = 0
if fractionDigitsNode.getAttribute("fixed") == "true" and numberOfFracDigits != string.atoi(fractionDigitsValue):
raise SimpleTypeError ("Fraction number of digits != %s for %s (%s)" %(fractionDigitsValue, attrName, attributeValue))
elif numberOfFracDigits > string.atoi(fractionDigitsValue):
raise SimpleTypeError ("Fraction number of digits > %s for %s (%s)" %(fractionDigitsValue, attrName, attributeValue))
if returnDict.has_key("length"):
lengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "length")
if lengthNode != None:
length = string.atoi(lengthNode.getAttribute("value"))
if returnDict["length"] != length:
raise SimpleTypeError ("Length of %s (%s) must be %d!" %(attrName, attributeValue, length))
minLengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "minLength")
if minLengthNode != None:
minLength = string.atoi(minLengthNode.getAttribute("value"))
if returnDict["length"] < minLength:
raise SimpleTypeError ("Length of %s (%s) must be >= %d!" %(attrName, attributeValue, minLength))
maxLengthNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "maxLength")
if maxLengthNode != None:
maxLength = string.atoi(maxLengthNode.getAttribute("value"))
if returnDict["length"] > maxLength:
raise SimpleTypeError ("Length of %s (%s) must be <= %d!" %(attrName, attributeValue, maxLength))
enumerationElementList = xsdElement.getChildrenNS(self.xsdNSAlias, "enumeration")
if enumerationElementList != []:
for enumeration in enumerationElementList:
if enumeration.getAttribute ("value") == attributeValue:
break
else:
raise SimpleTypeError ("Enumeration value '%s' not allowed!" %(attributeValue))
patternNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "pattern")
if patternNode != None:
rePattern = patternNode.getAttribute("value")
regexObj = re.match(rePattern, attributeValue)
if not regexObj or regexObj.end() != len(attributeValue):
raise SimpleTypeError ("Attribute value '%s' does not match pattern '%s'!" %(attributeValue, rePattern))
whiteSpace = xsdElement.getFirstChildNS(self.xsdNSAlias, "whiteSpace")
if whiteSpace != None:
wsAction = whiteSpace.getAttribute("value")
if wsAction == "replace":
normalizedValue = self._normalizeString(attributeValue)
if normalizedValue != attributeValue:
returnDict["adaptedAttrValue"] = normalizedValue
elif wsAction == "collapse":
collapsedValue = self._collapseString(attributeValue)
if collapsedValue != attributeValue:
returnDict["adaptedAttrValue"] = collapsedValue
########################################
# validate given value against list node
#
def _checkListTag (self, xsdElement, attrName, attributeValue, returnDict):
if attributeValue != "":
itemType = xsdElement.getAttribute ("itemType")
# substitute multiple whitespace characters by a single ' '
collapsedValue = self._collapseString(attributeValue)
if collapsedValue != attributeValue:
returnDict["adaptedAttrValue"] = collapsedValue
# divide up attributeValue => store it into list
attributeList = string.split(collapsedValue, " ")
for attrValue in attributeList:
elementReturnDict = {}
if itemType != None:
self.checkSimpleType (attrName, itemType, attrValue, elementReturnDict)
else:
itemTypeNode = xsdElement.getFirstChildNS(self.xsdNSAlias, "simpleType")
self.checkSimpleTypeDef (itemTypeNode, attrName, attrValue, elementReturnDict)
returnDict["length"] = len(attributeList)
else:
returnDict["length"] = 0
########################################
# validate given value against union node
#
def _checkUnionTag (self, xsdElement, attrName, attributeValue, returnDict):
memberTypes = xsdElement.getAttribute ("memberTypes")
if memberTypes != None:
# substitute multiple whitespace characters by a single ' '
# divide up attributeValue => store it into list
for memberType in string.split(self._collapseString(memberTypes), " "):
try:
self.checkSimpleType (attrName, memberType, attributeValue, returnDict)
return
except SimpleTypeError, errstr:
pass
# memberTypes and additional type definitions is legal!
for childSimpleType in xsdElement.getChildrenNS(self.xsdNSAlias, "simpleType"):
try:
self.checkSimpleTypeDef (childSimpleType, attrName, attributeValue, returnDict)
return
except SimpleTypeError, errstr:
pass
raise SimpleTypeError ("%s (%s) is no valid union member type (%s)!" %(attrName, attributeValue, memberTypes))
########################################
# substitute multiple whitespace characters by a single ' '
#
def _collapseString (self, strValue):
return re.sub('\s+', ' ', strValue)
########################################
# substitute each whitespace characters by a single ' '
#
def _normalizeString (self, strValue):
return re.sub('\s', ' ', strValue)
def validateBaseType (simpleType, attributeValue, returnDict):
# TODO: Many base types are not completely defined by datatypes.xsd
simpleTypeDict = {"xsd:string": _checkStringType,
"xsd:hexBinary": _checkHexBinaryType,
"xsd:integer": _checkIntegerType,
"xsd:boolean": _checkBooleanType,
"xsd:QName": _checkQNameType,
}
simpleType = string.replace(simpleType, "xs:", "xsd:")
if simpleTypeDict.has_key (simpleType):
simpleTypeDict[simpleType] (simpleType, attributeValue, returnDict)
elif simpleType != "xsd:anySimpleType":
if simpleType in ("xsd:decimal", "xsd:float", "xsd:double", "xsd:base64Binary", "xsd:anyURI", "xsd:NOTATION",
"xsd:duration", "xsd:dateTime", "xsd:time", "xsd:date",
"xsd:gYearMonth", "xsd:gMonthDay", "xsd:gYear", "xsd:gMonth", "xsd:gDay"):
print "INFO: Check of simple type '%s' currently not supported!" %(simpleType)
else:
# TODO: Fehler im XSD-File => Check muss an anderer Stelle erfolgen
raise BaseTypeError("uses unknown type '%s'!" %(simpleType))
def _checkStringType (simpleType, attributeValue, returnDict):
# all valid??
returnDict["length"] = len(attributeValue)
def _checkHexBinaryType (simpleType, attributeValue, returnDict):
_checkIntegerRange (attributeValue, 16, 0, sys.maxint, returnDict)
returnDict["length"] = len(attributeValue)
def _checkIntegerType (simpleType, attributeValue, returnDict):
_checkIntegerRange (attributeValue, 10, -sys.maxint-1, sys.maxint, returnDict)
def _checkBooleanType (simpleType, attributeValue, returnDict):
if attributeValue not in ("true", "false", "1", "0"):
raise BaseTypeError("is not a boolean value!")
def _checkQNameType (simpleType, attributeValue, returnDict):
# TODO: fill
returnDict["length"] = len(attributeValue)
def _checkIntegerRange (attributeValue, base, minBase, maxBase, returnDict):
try:
value = string.atoi (attributeValue, base=base)
except:
if base == 16:
raise BaseTypeError("is not a hexadecimal value!")
else:
raise BaseTypeError("is not an integer!")
if value < minBase or value > maxBase:
raise BaseTypeError("is out of range (%d..%d)!" %(minBase, maxBase))
returnDict["orderedValue"] = value
########################################
# define own exception for XML schema validation errors
#
class SimpleTypeError (StandardError):
pass
class BaseTypeError (StandardError):
pass