svn commit: r509273 [29/50] - in /ofbiz/trunk/framework/images/
Locked
svn commit: r509273 [29/50] - in /ofbiz/trunk/framework/images/
 
|
Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js
URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,355 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.uuid.TimeBasedGenerator"); +dojo.require("dojo.lang.common"); +dojo.require("dojo.lang.type"); +dojo.require("dojo.lang.assert"); + +dojo.uuid.TimeBasedGenerator = new function() { + + // -------------------------------------------------- + // Public constants: + // Number of hours between October 15, 1582 and January 1, 1970: + this.GREGORIAN_CHANGE_OFFSET_IN_HOURS = 3394248; + // Number of seconds between October 15, 1582 and January 1, 1970: + // this.GREGORIAN_CHANGE_OFFSET_IN_SECONDS = 12219292800; + + // -------------------------------------------------- + // Private variables: + var _uuidPseudoNodeString = null; + var _uuidClockSeqString = null; + var _dateValueOfPreviousUuid = null; + var _nextIntraMillisecondIncrement = 0; + var _cachedMillisecondsBetween1582and1970 = null; + var _cachedHundredNanosecondIntervalsPerMillisecond = null; + var _uniformNode = null; + + // -------------------------------------------------- + // Private constants: + var HEX_RADIX = 16; + + function _carry(/* array */ arrayA) { + // summary: + // Given an array which holds a 64-bit number broken into 4 16-bit + // elements, this method carries any excess bits (greater than 16-bits) + // from each array element into the next. + // arrayA: An array with 4 elements, each of which is a 16-bit number. + arrayA[2] += arrayA[3] >>> 16; + arrayA[3] &= 0xFFFF; + arrayA[1] += arrayA[2] >>> 16; + arrayA[2] &= 0xFFFF; + arrayA[0] += arrayA[1] >>> 16; + arrayA[1] &= 0xFFFF; + dojo.lang.assert((arrayA[0] >>> 16) === 0); + } + + function _get64bitArrayFromFloat(/* float */ x) { + // summary: + // Given a floating point number, this method returns an array which + // holds a 64-bit number broken into 4 16-bit elements. + var result = new Array(0, 0, 0, 0); + result[3] = x % 0x10000; + x -= result[3]; + x /= 0x10000; + result[2] = x % 0x10000; + x -= result[2]; + x /= 0x10000; + result[1] = x % 0x10000; + x -= result[1]; + x /= 0x10000; + result[0] = x; + return result; // Array with 4 elements, each of which is a 16-bit number. + } + + function _addTwo64bitArrays(/* array */ arrayA, /* array */ arrayB) { + // summary: + // Takes two arrays, each of which holds a 64-bit number broken into 4 + // 16-bit elements, and returns a new array that holds a 64-bit number + // that is the sum of the two original numbers. + // arrayA: An array with 4 elements, each of which is a 16-bit number. + // arrayB: An array with 4 elements, each of which is a 16-bit number. + dojo.lang.assertType(arrayA, Array); + dojo.lang.assertType(arrayB, Array); + dojo.lang.assert(arrayA.length == 4); + dojo.lang.assert(arrayB.length == 4); + + var result = new Array(0, 0, 0, 0); + result[3] = arrayA[3] + arrayB[3]; + result[2] = arrayA[2] + arrayB[2]; + result[1] = arrayA[1] + arrayB[1]; + result[0] = arrayA[0] + arrayB[0]; + _carry(result); + return result; // Array with 4 elements, each of which is a 16-bit number. + } + + function _multiplyTwo64bitArrays(/* array */ arrayA, /* array */ arrayB) { + // summary: + // Takes two arrays, each of which holds a 64-bit number broken into 4 + // 16-bit elements, and returns a new array that holds a 64-bit number + // that is the product of the two original numbers. + // arrayA: An array with 4 elements, each of which is a 16-bit number. + // arrayB: An array with 4 elements, each of which is a 16-bit number. + dojo.lang.assertType(arrayA, Array); + dojo.lang.assertType(arrayB, Array); + dojo.lang.assert(arrayA.length == 4); + dojo.lang.assert(arrayB.length == 4); + + var overflow = false; + if (arrayA[0] * arrayB[0] !== 0) { overflow = true; } + if (arrayA[0] * arrayB[1] !== 0) { overflow = true; } + if (arrayA[0] * arrayB[2] !== 0) { overflow = true; } + if (arrayA[1] * arrayB[0] !== 0) { overflow = true; } + if (arrayA[1] * arrayB[1] !== 0) { overflow = true; } + if (arrayA[2] * arrayB[0] !== 0) { overflow = true; } + dojo.lang.assert(!overflow); + + var result = new Array(0, 0, 0, 0); + result[0] += arrayA[0] * arrayB[3]; + _carry(result); + result[0] += arrayA[1] * arrayB[2]; + _carry(result); + result[0] += arrayA[2] * arrayB[1]; + _carry(result); + result[0] += arrayA[3] * arrayB[0]; + _carry(result); + result[1] += arrayA[1] * arrayB[3]; + _carry(result); + result[1] += arrayA[2] * arrayB[2]; + _carry(result); + result[1] += arrayA[3] * arrayB[1]; + _carry(result); + result[2] += arrayA[2] * arrayB[3]; + _carry(result); + result[2] += arrayA[3] * arrayB[2]; + _carry(result); + result[3] += arrayA[3] * arrayB[3]; + _carry(result); + return result; // Array with 4 elements, each of which is a 16-bit number. + } + + function _padWithLeadingZeros(/* string */ string, /* int */ desiredLength) { + // summary: + // Pads a string with leading zeros and returns the result. + // string: A string to add padding to. + // desiredLength: The number of characters the return string should have. + + // examples: + // result = _padWithLeadingZeros("abc", 6); + // dojo.lang.assert(result == "000abc"); + while (string.length < desiredLength) { + string = "0" + string; + } + return string; // string + } + + function _generateRandomEightCharacterHexString() { + // summary: + // Returns a randomly generated 8-character string of hex digits. + + // FIXME: This probably isn't a very high quality random number. + + // Make random32bitNumber be a randomly generated floating point number + // between 0 and (4,294,967,296 - 1), inclusive. + var random32bitNumber = Math.floor( (Math.random() % 1) * Math.pow(2, 32) ); + + var eightCharacterString = random32bitNumber.toString(HEX_RADIX); + while (eightCharacterString.length < 8) { + eightCharacterString = "0" + eightCharacterString; + } + return eightCharacterString; // String (an 8-character hex string) + } + + function _generateUuidString(/* string? */ node) { + // summary: + // Generates a time-based UUID, meaning a version 1 UUID. + // description: + // JavaScript code running in a browser doesn't have access to the + // IEEE 802.3 address of the computer, so if a node value isn't + // supplied, we generate a random pseudonode value instead. + // node: An optional 12-character string to use as the node in the new UUID. + dojo.lang.assertType(node, String, {optional: true}); + if (node) { + dojo.lang.assert(node.length == 12); + } else { + if (_uniformNode) { + node = _uniformNode; + } else { + if (!_uuidPseudoNodeString) { + var pseudoNodeIndicatorBit = 0x8000; + var random15bitNumber = Math.floor( (Math.random() % 1) * Math.pow(2, 15) ); + var leftmost4HexCharacters = (pseudoNodeIndicatorBit | random15bitNumber).toString(HEX_RADIX); + _uuidPseudoNodeString = leftmost4HexCharacters + _generateRandomEightCharacterHexString(); + } + node = _uuidPseudoNodeString; + } + } + if (!_uuidClockSeqString) { + var variantCodeForDCEUuids = 0x8000; // 10--------------, i.e. uses only first two of 16 bits. + var random14bitNumber = Math.floor( (Math.random() % 1) * Math.pow(2, 14) ); + _uuidClockSeqString = (variantCodeForDCEUuids | random14bitNumber).toString(HEX_RADIX); + } + + // Maybe we should think about trying to make the code more readable to + // newcomers by creating a class called "WholeNumber" that encapsulates + // the methods and data structures for working with these arrays that + // hold 4 16-bit numbers? And then these variables below have names + // like "wholeSecondsPerHour" rather than "arraySecondsPerHour"? + var now = new Date(); + var millisecondsSince1970 = now.valueOf(); // milliseconds since midnight 01 January, 1970 UTC. + var nowArray = _get64bitArrayFromFloat(millisecondsSince1970); + if (!_cachedMillisecondsBetween1582and1970) { + var arraySecondsPerHour = _get64bitArrayFromFloat(60 * 60); + var arrayHoursBetween1582and1970 = _get64bitArrayFromFloat(dojo.uuid.TimeBasedGenerator.GREGORIAN_CHANGE_OFFSET_IN_HOURS); + var arraySecondsBetween1582and1970 = _multiplyTwo64bitArrays(arrayHoursBetween1582and1970, arraySecondsPerHour); + var arrayMillisecondsPerSecond = _get64bitArrayFromFloat(1000); + _cachedMillisecondsBetween1582and1970 = _multiplyTwo64bitArrays(arraySecondsBetween1582and1970, arrayMillisecondsPerSecond); + _cachedHundredNanosecondIntervalsPerMillisecond = _get64bitArrayFromFloat(10000); + } + var arrayMillisecondsSince1970 = nowArray; + var arrayMillisecondsSince1582 = _addTwo64bitArrays(_cachedMillisecondsBetween1582and1970, arrayMillisecondsSince1970); + var arrayHundredNanosecondIntervalsSince1582 = _multiplyTwo64bitArrays(arrayMillisecondsSince1582, _cachedHundredNanosecondIntervalsPerMillisecond); + + if (now.valueOf() == _dateValueOfPreviousUuid) { + arrayHundredNanosecondIntervalsSince1582[3] += _nextIntraMillisecondIncrement; + _carry(arrayHundredNanosecondIntervalsSince1582); + _nextIntraMillisecondIncrement += 1; + if (_nextIntraMillisecondIncrement == 10000) { + // If we've gotten to here, it means we've already generated 10,000 + // UUIDs in this single millisecond, which is the most that the UUID + // timestamp field allows for. So now we'll just sit here and wait + // for a fraction of a millisecond, so as to ensure that the next + // time this method is called there will be a different millisecond + // value in the timestamp field. + while (now.valueOf() == _dateValueOfPreviousUuid) { + now = new Date(); + } + } + } else { + _dateValueOfPreviousUuid = now.valueOf(); + _nextIntraMillisecondIncrement = 1; + } + + var hexTimeLowLeftHalf = arrayHundredNanosecondIntervalsSince1582[2].toString(HEX_RADIX); + var hexTimeLowRightHalf = arrayHundredNanosecondIntervalsSince1582[3].toString(HEX_RADIX); + var hexTimeLow = _padWithLeadingZeros(hexTimeLowLeftHalf, 4) + _padWithLeadingZeros(hexTimeLowRightHalf, 4); + var hexTimeMid = arrayHundredNanosecondIntervalsSince1582[1].toString(HEX_RADIX); + hexTimeMid = _padWithLeadingZeros(hexTimeMid, 4); + var hexTimeHigh = arrayHundredNanosecondIntervalsSince1582[0].toString(HEX_RADIX); + hexTimeHigh = _padWithLeadingZeros(hexTimeHigh, 3); + var hyphen = "-"; + var versionCodeForTimeBasedUuids = "1"; // binary2hex("0001") + var resultUuid = hexTimeLow + hyphen + hexTimeMid + hyphen + + versionCodeForTimeBasedUuids + hexTimeHigh + hyphen + + _uuidClockSeqString + hyphen + node; + resultUuid = resultUuid.toLowerCase(); + return resultUuid; // String (a 36 character string, which will look something like "b4308fb0-86cd-11da-a72b-0800200c9a66") + } + + this.setNode = function(/* string? */ node) { + // summary: + // Sets the 'node' value that will be included in generated UUIDs. + // node: A 12-character hex string representing a pseudoNode or hardwareNode. + dojo.lang.assert((node === null) || (node.length == 12)); + _uniformNode = node; + }; + + this.getNode = function() { + // summary: + // Returns the 'node' value that will be included in generated UUIDs. + return _uniformNode; // String (a 12-character hex string representing a pseudoNode or hardwareNode) + }; + + this.generate = function(/* misc? */ input) { + // summary: + // This function generates time-based UUIDs, meaning "version 1" UUIDs. + // description: + // For more info, see + // http://www.webdav.org/specs/draft-leach-uuids-guids-01.txt + // http://www.infonuovo.com/dma/csdocs/sketch/instidid.htm + // http://kruithof.xs4all.nl/uuid/uuidgen + // http://www.opengroup.org/onlinepubs/009629399/apdxa.htm#tagcjh_20 + // http://jakarta.apache.org/commons/sandbox/id/apidocs/org/apache/commons/id/uuid/clock/Clock.html + + // examples: + // var generate = dojo.uuid.TimeBasedGenerator.generate; + // var uuid; // an instance of dojo.uuid.Uuid + // var string; // a simple string literal + // string = generate(); + // string = generate(String); + // uuid = generate(dojo.uuid.Uuid); + // string = generate("017bf397618a"); + // string = generate({node: "017bf397618a"}); // hardwareNode + // string = generate({node: "f17bf397618a"}); // pseudoNode + // string = generate({hardwareNode: "017bf397618a"}); + // string = generate({pseudoNode: "f17bf397618a"}); + // string = generate({node: "017bf397618a", returnType: String}); + // uuid = generate({node: "017bf397618a", returnType: dojo.uuid.Uuid}); + // dojo.uuid.TimeBasedGenerator.setNode("017bf397618a"); + // string = generate(); // the generated UUID has node == "017bf397618a" + // uuid = generate(dojo.uuid.Uuid); // the generated UUID has node == "017bf397618a" + var nodeString = null; + var returnType = null; + + if (input) { + if (dojo.lang.isObject(input) && !dojo.lang.isBuiltIn(input)) { + // input: object {node: string, hardwareNode: string, pseudoNode: string} + // node: A 12-character hex string representing a pseudoNode or hardwareNode. + // hardwareNode: A 12-character hex string containing an IEEE 802.3 network node identificator. + // pseudoNode: A 12-character hex string representing a pseudoNode. + var namedParameters = input; + dojo.lang.assertValidKeywords(namedParameters, ["node", "hardwareNode", "pseudoNode", "returnType"]); + var node = namedParameters["node"]; + var hardwareNode = namedParameters["hardwareNode"]; + var pseudoNode = namedParameters["pseudoNode"]; + nodeString = (node || pseudoNode || hardwareNode); + if (nodeString) { + var firstCharacter = nodeString.charAt(0); + var firstDigit = parseInt(firstCharacter, HEX_RADIX); + if (hardwareNode) { + dojo.lang.assert((firstDigit >= 0x0) && (firstDigit <= 0x7)); + } + if (pseudoNode) { + dojo.lang.assert((firstDigit >= 0x8) && (firstDigit <= 0xF)); + } + } + returnType = namedParameters["returnType"]; + dojo.lang.assertType(returnType, Function, {optional: true}); + } else { + if (dojo.lang.isString(input)) { + // input: string A 12-character hex string representing a pseudoNode or hardwareNode. + nodeString = input; + returnType = null; + } else { + if (dojo.lang.isFunction(input)) { + // input: constructor The type of object to return. Usually String or dojo.uuid.Uuid + nodeString = null; + returnType = input; + } + } + } + if (nodeString) { + dojo.lang.assert(nodeString.length == 12); + var integer = parseInt(nodeString, HEX_RADIX); + dojo.lang.assert(isFinite(integer)); + } + dojo.lang.assertType(returnType, Function, {optional: true}); + } + + var uuidString = _generateUuidString(nodeString); + var returnValue; + if (returnType && (returnType != String)) { + returnValue = new returnType(uuidString); + } else { + returnValue = uuidString; + } + return returnValue; // object + }; +}(); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/TimeBasedGenerator.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,379 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.uuid.Uuid"); +dojo.require("dojo.lang.common"); +dojo.require("dojo.lang.assert"); + +dojo.uuid.Uuid = function(/* string || generator */ input) { + // summary: + // This is the constructor for the Uuid class. The Uuid class offers + // methods for inspecting existing UUIDs. + + // examples: + // var uuid; + // uuid = new dojo.uuid.Uuid("3b12f1df-5232-4804-897e-917bf397618a"); + // uuid = new dojo.uuid.Uuid(); // "00000000-0000-0000-0000-000000000000" + // uuid = new dojo.uuid.Uuid(dojo.uuid.RandomGenerator); + // uuid = new dojo.uuid.Uuid(dojo.uuid.TimeBasedGenerator); + // dojo.uuid.Uuid.setGenerator(dojo.uuid.RandomGenerator); + // uuid = new dojo.uuid.Uuid(); + // dojo.lang.assert(!uuid.isEqual(dojo.uuid.Uuid.NIL_UUID)); + this._uuidString = dojo.uuid.Uuid.NIL_UUID; + if (input) { + if (dojo.lang.isString(input)) { + // input: string? A 36-character string that conforms to the UUID spec. + this._uuidString = input.toLowerCase(); + dojo.lang.assert(this.isValid()); + } else { + if (dojo.lang.isObject(input) && input.generate) { + // input: generator A UUID generator, such as dojo.uuid.TimeBasedGenerator. + var generator = input; + this._uuidString = generator.generate(); + dojo.lang.assert(this.isValid()); + } else { + // we got passed something other than a string + dojo.lang.assert(false, "The dojo.uuid.Uuid() constructor must be initializated with a UUID string."); + } + } + } else { + var ourGenerator = dojo.uuid.Uuid.getGenerator(); + if (ourGenerator) { + this._uuidString = ourGenerator.generate(); + dojo.lang.assert(this.isValid()); + } + } +}; + +// ------------------------------------------------------------------- +// Public constants +// ------------------------------------------------------------------- +dojo.uuid.Uuid.NIL_UUID = "00000000-0000-0000-0000-000000000000"; +dojo.uuid.Uuid.Version = { + UNKNOWN: 0, + TIME_BASED: 1, + DCE_SECURITY: 2, + NAME_BASED_MD5: 3, + RANDOM: 4, + NAME_BASED_SHA1: 5 }; +dojo.uuid.Uuid.Variant = { + NCS: "0", + DCE: "10", + MICROSOFT: "110", + UNKNOWN: "111" }; +dojo.uuid.Uuid.HEX_RADIX = 16; + +dojo.uuid.Uuid.compare = function(/* dojo.uuid.Uuid */ uuidOne, /* dojo.uuid.Uuid */ uuidTwo) { + // summary: + // Given two UUIDs to compare, this method returns 0, 1, or -1. + // description: + // This method is designed to be used by sorting routines, like the + // JavaScript built-in Array sort() method. This implementation is + // intended to match the sample implementation in IETF RFC 4122: + // http://www.ietf.org/rfc/rfc4122.txt + // uuidOne: Any object that has toString() method that returns a 36-character string that conforms to the UUID spec. + // uuidTwo: Any object that has toString() method that returns a 36-character string that conforms to the UUID spec. + + // examples: + // var uuid; + // var generator = dojo.uuid.TimeBasedGenerator; + // var a = new dojo.uuid.Uuid(generator); + // var b = new dojo.uuid.Uuid(generator); + // var c = new dojo.uuid.Uuid(generator); + // var array = new Array(a, b, c); + // array.sort(dojo.uuid.Uuid.compare); + var uuidStringOne = uuidOne.toString(); + var uuidStringTwo = uuidTwo.toString(); + if (uuidStringOne > uuidStringTwo) return 1; // integer + if (uuidStringOne < uuidStringTwo) return -1; // integer + return 0; // integer (either 0, 1, or -1) +}; + +dojo.uuid.Uuid.setGenerator = function(/* generator? */ generator) { + // summary: + // Sets the default generator, which will be used by the + // "new dojo.uuid.Uuid()" constructor if no parameters + // are passed in. + // generator: A UUID generator, such as dojo.uuid.TimeBasedGenerator. + dojo.lang.assert(!generator || (dojo.lang.isObject(generator) && generator.generate)); + dojo.uuid.Uuid._ourGenerator = generator; +}; + +dojo.uuid.Uuid.getGenerator = function() { + // summary: + // Returns the default generator. See setGenerator(). + return dojo.uuid.Uuid._ourGenerator; // generator (A UUID generator, such as dojo.uuid.TimeBasedGenerator). +}; + +dojo.uuid.Uuid.prototype.toString = function(/* string? */format) { + // summary: + // By default this method returns a standard 36-character string representing + // the UUID, such as "3b12f1df-5232-4804-897e-917bf397618a". You can also + // pass in an optional format specifier to request the output in any of + // a half dozen slight variations. + // format: One of these strings: '{}', '()', '""', "''", 'urn', '!-' + + // examples: + // var uuid = new dojo.uuid.Uuid(dojo.uuid.TimeBasedGenerator); + // var s; + // s = uuid.toString(); // eb529fec-6498-11d7-b236-000629ba5445 + // s = uuid.toString('{}'); // {eb529fec-6498-11d7-b236-000629ba5445} + // s = uuid.toString('()'); // (eb529fec-6498-11d7-b236-000629ba5445) + // s = uuid.toString('""'); // "eb529fec-6498-11d7-b236-000629ba5445" + // s = uuid.toString("''"); // 'eb529fec-6498-11d7-b236-000629ba5445' + // s = uuid.toString('!-'); // eb529fec649811d7b236000629ba5445 + // s = uuid.toString('urn'); // urn:uuid:eb529fec-6498-11d7-b236-000629ba5445 + if (format) { + switch (format) { + case '{}': + return '{' + this._uuidString + '}'; + break; + case '()': + return '(' + this._uuidString + ')'; + break; + case '""': + return '"' + this._uuidString + '"'; + break; + case "''": + return "'" + this._uuidString + "'"; + break; + case 'urn': + return 'urn:uuid:' + this._uuidString; + break; + case '!-': + return this._uuidString.split('-').join(''); + break; + default: + // we got passed something other than what we expected + dojo.lang.assert(false, "The toString() method of dojo.uuid.Uuid was passed a bogus format."); + } + } else { + return this._uuidString; // string + } +}; + +dojo.uuid.Uuid.prototype.compare = function(/* dojo.uuid.Uuid */ otherUuid) { + // summary: + // Compares this UUID to another UUID, and returns 0, 1, or -1. + // description: + // This implementation is intended to match the sample implementation + // in IETF RFC 4122: http://www.ietf.org/rfc/rfc4122.txt + // otherUuid: Any object that has toString() method that returns a 36-character string that conforms to the UUID spec. + return dojo.uuid.Uuid.compare(this, otherUuid); // integer (either 0, 1, or -1) +}; + +dojo.uuid.Uuid.prototype.isEqual = function(/* dojo.uuid.Uuid */ otherUuid) { + // summary: + // Returns true if this UUID is equal to the otherUuid, or false otherwise. + // otherUuid: Any object that has toString() method that returns a 36-character string that conforms to the UUID spec. + return (this.compare(otherUuid) == 0); // boolean +}; + +dojo.uuid.Uuid.prototype.isValid = function() { + // summary: + // Returns true if the UUID was initialized with a valid value. + try { + dojo.lang.assertType(this._uuidString, String); + dojo.lang.assert(this._uuidString.length == 36); + dojo.lang.assert(this._uuidString == this._uuidString.toLowerCase()); + var arrayOfParts = this._uuidString.split("-"); + dojo.lang.assert(arrayOfParts.length == 5); + dojo.lang.assert(arrayOfParts[0].length == 8); + dojo.lang.assert(arrayOfParts[1].length == 4); + dojo.lang.assert(arrayOfParts[2].length == 4); + dojo.lang.assert(arrayOfParts[3].length == 4); + dojo.lang.assert(arrayOfParts[4].length == 12); + for (var i in arrayOfParts) { + var part = arrayOfParts[i]; + var integer = parseInt(part, dojo.uuid.Uuid.HEX_RADIX); + dojo.lang.assert(isFinite(integer)); + } + return true; // boolean + } catch (e) { + return false; // boolean + } +}; + +dojo.uuid.Uuid.prototype.getVariant = function() { + // summary: + // Returns a variant code that indicates what type of UUID this is. + // Returns one of the enumerated dojo.uuid.Uuid.Variant values. + + // example: + // var uuid = new dojo.uuid.Uuid("3b12f1df-5232-4804-897e-917bf397618a"); + // var variant = uuid.getVariant(); + // dojo.lang.assert(variant == dojo.uuid.Uuid.Variant.DCE); + // example: + // "3b12f1df-5232-4804-897e-917bf397618a" + // ^ + // | + // (variant "10__" == DCE) + var variantCharacter = this._uuidString.charAt(19); + var variantNumber = parseInt(variantCharacter, dojo.uuid.Uuid.HEX_RADIX); + dojo.lang.assert((variantNumber >= 0) && (variantNumber <= 16)); + + if (!dojo.uuid.Uuid._ourVariantLookupTable) { + var Variant = dojo.uuid.Uuid.Variant; + var lookupTable = []; + + lookupTable[0x0] = Variant.NCS; // 0000 + lookupTable[0x1] = Variant.NCS; // 0001 + lookupTable[0x2] = Variant.NCS; // 0010 + lookupTable[0x3] = Variant.NCS; // 0011 + + lookupTable[0x4] = Variant.NCS; // 0100 + lookupTable[0x5] = Variant.NCS; // 0101 + lookupTable[0x6] = Variant.NCS; // 0110 + lookupTable[0x7] = Variant.NCS; // 0111 + + lookupTable[0x8] = Variant.DCE; // 1000 + lookupTable[0x9] = Variant.DCE; // 1001 + lookupTable[0xA] = Variant.DCE; // 1010 + lookupTable[0xB] = Variant.DCE; // 1011 + + lookupTable[0xC] = Variant.MICROSOFT; // 1100 + lookupTable[0xD] = Variant.MICROSOFT; // 1101 + lookupTable[0xE] = Variant.UNKNOWN; // 1110 + lookupTable[0xF] = Variant.UNKNOWN; // 1111 + + dojo.uuid.Uuid._ourVariantLookupTable = lookupTable; + } + + return dojo.uuid.Uuid._ourVariantLookupTable[variantNumber]; // dojo.uuid.Uuid.Variant +}; + +dojo.uuid.Uuid.prototype.getVersion = function() { + // summary: + // Returns a version number that indicates what type of UUID this is. + // Returns one of the enumerated dojo.uuid.Uuid.Version values. + + // example: + // var uuid = new dojo.uuid.Uuid("b4308fb0-86cd-11da-a72b-0800200c9a66"); + // var version = uuid.getVersion(); + // dojo.lang.assert(version == dojo.uuid.Uuid.Version.TIME_BASED); + // exceptions: + // Throws an Error if this is not a DCE Variant UUID. + if (!this._versionNumber) { + var errorMessage = "Called getVersion() on a dojo.uuid.Uuid that was not a DCE Variant UUID."; + dojo.lang.assert(this.getVariant() == dojo.uuid.Uuid.Variant.DCE, errorMessage); + + // "b4308fb0-86cd-11da-a72b-0800200c9a66" + // ^ + // | + // (version 1 == TIME_BASED) + var versionCharacter = this._uuidString.charAt(14); + this._versionNumber = parseInt(versionCharacter, dojo.uuid.Uuid.HEX_RADIX); + } + return this._versionNumber; // dojo.uuid.Uuid.Version +}; + +dojo.uuid.Uuid.prototype.getNode = function() { + // summary: + // If this is a version 1 UUID (a time-based UUID), getNode() returns a + // 12-character string with the "node" or "pseudonode" portion of the UUID, + // which is the rightmost 12 characters. + + // exceptions: + // Throws an Error if this is not a version 1 UUID. + if (!this._nodeString) { + var errorMessage = "Called getNode() on a dojo.uuid.Uuid that was not a TIME_BASED UUID."; + dojo.lang.assert(this.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED, errorMessage); + + var arrayOfStrings = this._uuidString.split('-'); + this._nodeString = arrayOfStrings[4]; + } + return this._nodeString; // String (a 12-character string, which will look something like "917bf397618a") +}; + +dojo.uuid.Uuid.prototype.getTimestamp = function(/* misc. */ returnType) { + // summary: + // If this is a version 1 UUID (a time-based UUID), this method returns + // the timestamp value encoded in the UUID. The caller can ask for the + // timestamp to be returned either as a JavaScript Date object or as a + // 15-character string of hex digits. + // returnType: Any of these five values: "string", String, "hex", "date", Date + + // returns: + // Returns the timestamp value as a JavaScript Date object or a 15-character string of hex digits. + // examples: + // var uuid = new dojo.uuid.Uuid("b4308fb0-86cd-11da-a72b-0800200c9a66"); + // var date, string, hexString; + // date = uuid.getTimestamp(); // returns a JavaScript Date + // date = uuid.getTimestamp(Date); // + // string = uuid.getTimestamp(String); // "Mon, 16 Jan 2006 20:21:41 GMT" + // hexString = uuid.getTimestamp("hex"); // "1da86cdb4308fb0" + // exceptions: + // Throws an Error if this is not a version 1 UUID. + var errorMessage = "Called getTimestamp() on a dojo.uuid.Uuid that was not a TIME_BASED UUID."; + dojo.lang.assert(this.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED, errorMessage); + + if (!returnType) {returnType = null}; + switch (returnType) { + case "string": + case String: + return this.getTimestamp(Date).toUTCString(); // String (e.g. "Mon, 16 Jan 2006 20:21:41 GMT") + break; + case "hex": + // Return a 15-character string of hex digits containing the + // timestamp for this UUID, with the high-order bits first. + if (!this._timestampAsHexString) { + var arrayOfStrings = this._uuidString.split('-'); + var hexTimeLow = arrayOfStrings[0]; + var hexTimeMid = arrayOfStrings[1]; + var hexTimeHigh = arrayOfStrings[2]; + + // Chop off the leading "1" character, which is the UUID + // version number for time-based UUIDs. + hexTimeHigh = hexTimeHigh.slice(1); + + this._timestampAsHexString = hexTimeHigh + hexTimeMid + hexTimeLow; + dojo.lang.assert(this._timestampAsHexString.length == 15); + } + return this._timestampAsHexString; // String (e.g. "1da86cdb4308fb0") + break; + case null: // no returnType was specified, so default to Date + case "date": + case Date: + // Return a JavaScript Date object. + if (!this._timestampAsDate) { + var GREGORIAN_CHANGE_OFFSET_IN_HOURS = 3394248; + + var arrayOfParts = this._uuidString.split('-'); + var timeLow = parseInt(arrayOfParts[0], dojo.uuid.Uuid.HEX_RADIX); + var timeMid = parseInt(arrayOfParts[1], dojo.uuid.Uuid.HEX_RADIX); + var timeHigh = parseInt(arrayOfParts[2], dojo.uuid.Uuid.HEX_RADIX); + var hundredNanosecondIntervalsSince1582 = timeHigh & 0x0FFF; + hundredNanosecondIntervalsSince1582 <<= 16; + hundredNanosecondIntervalsSince1582 += timeMid; + // What we really want to do next is shift left 32 bits, but the + // result will be too big to fit in an int, so we'll multiply by 2^32, + // and the result will be a floating point approximation. + hundredNanosecondIntervalsSince1582 *= 0x100000000; + hundredNanosecondIntervalsSince1582 += timeLow; + var millisecondsSince1582 = hundredNanosecondIntervalsSince1582 / 10000; + + // Again, this will be a floating point approximation. + // We can make things exact later if we need to. + var secondsPerHour = 60 * 60; + var hoursBetween1582and1970 = GREGORIAN_CHANGE_OFFSET_IN_HOURS; + var secondsBetween1582and1970 = hoursBetween1582and1970 * secondsPerHour; + var millisecondsBetween1582and1970 = secondsBetween1582and1970 * 1000; + var millisecondsSince1970 = millisecondsSince1582 - millisecondsBetween1582and1970; + + this._timestampAsDate = new Date(millisecondsSince1970); + } + return this._timestampAsDate; // Date + break; + default: + // we got passed something other than a valid returnType + dojo.lang.assert(false, "The getTimestamp() method dojo.uuid.Uuid was passed a bogus returnType: " + returnType); + break; + } +}; Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/Uuid.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,22 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.kwCompoundRequire({ + common: [ + "dojo.uuid.Uuid", + "dojo.uuid.LightweightGenerator", + "dojo.uuid.RandomGenerator", + "dojo.uuid.TimeBasedGenerator", + "dojo.uuid.NameBasedGenerator", + "dojo.uuid.NilGenerator" + ] +}); +dojo.provide("dojo.uuid.*"); + Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/uuid/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,12 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.validate"); +dojo.require("dojo.validate.common"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,21 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.require("dojo.validate"); +dojo.kwCompoundRequire({ + common: ["dojo.validate.check", + "dojo.validate.datetime", + "dojo.validate.de", + "dojo.validate.jp", + "dojo.validate.us", + "dojo.validate.web" + ] +}); +dojo.provide("dojo.validate.*"); Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/__package__.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,267 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.validate.check"); +dojo.require("dojo.validate.common"); +dojo.require("dojo.lang.common"); + +dojo.validate.check = function(/*HTMLFormElement*/form, /*Object*/profile){ + // summary: validates user input of an HTML form based on input profile + // + // description: + // returns an object that contains several methods summarizing the results of the validation + // + // form: form to be validated + // profile: specifies how the form fields are to be validated + // {trim:Array, uppercase:Array, lowercase:Array, ucfirst:Array, digit:Array, + // required:Array, dependencies:Object, constraints:Object, confirm:Object} + + // Essentially private properties of results object + var missing = []; + var invalid = []; + + // results object summarizes the validation + var results = { + isSuccessful: function() {return ( !this.hasInvalid() && !this.hasMissing() );}, + hasMissing: function() {return ( missing.length > 0 );}, + getMissing: function() {return missing;}, + isMissing: function(elemname) { + for(var i = 0; i < missing.length; i++){ + if(elemname == missing[i]){ return true; } + } + return false; + }, + hasInvalid: function() {return ( invalid.length > 0 );}, + getInvalid: function() {return invalid;}, + isInvalid: function(elemname){ + for(var i = 0; i < invalid.length; i++){ + if(elemname == invalid[i]){ return true; } + } + return false; + } + }; + + // Filters are applied before fields are validated. + // Trim removes white space at the front and end of the fields. + if(profile.trim instanceof Array){ + for(var i = 0; i < profile.trim.length; i++){ + var elem = form[profile.trim[i]]; + if(dj_undef("type", elem) || elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } + elem.value = elem.value.replace(/(^\s*|\s*$)/g, ""); + } + } + // Convert to uppercase + if(profile.uppercase instanceof Array){ + for(var i = 0; i < profile.uppercase.length; i++){ + var elem = form[profile.uppercase[i]]; + if(dj_undef("type", elem) || elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } + elem.value = elem.value.toUpperCase(); + } + } + // Convert to lowercase + if(profile.lowercase instanceof Array){ + for (var i = 0; i < profile.lowercase.length; i++){ + var elem = form[profile.lowercase[i]]; + if(dj_undef("type", elem) || elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } + elem.value = elem.value.toLowerCase(); + } + } + // Uppercase first letter + if(profile.ucfirst instanceof Array){ + for(var i = 0; i < profile.ucfirst.length; i++){ + var elem = form[profile.ucfirst[i]]; + if(dj_undef("type", elem) || elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } + elem.value = elem.value.replace(/\b\w+\b/g, function(word) { return word.substring(0,1).toUpperCase() + word.substring(1).toLowerCase(); }); + } + } + // Remove non digits characters from the input. + if(profile.digit instanceof Array){ + for(var i = 0; i < profile.digit.length; i++){ + var elem = form[profile.digit[i]]; + if(dj_undef("type", elem) || elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } + elem.value = elem.value.replace(/\D/g, ""); + } + } + + // See if required input fields have values missing. + if(profile.required instanceof Array){ + for(var i = 0; i < profile.required.length; i++){ + if(!dojo.lang.isString(profile.required[i])){ continue; } + var elem = form[profile.required[i]]; + // Are textbox, textarea, or password fields blank. + if(!dj_undef("type", elem) && (elem.type == "text" || elem.type == "textarea" || elem.type == "password") && /^\s*$/.test(elem.value)){ + missing[missing.length] = elem.name; + } + // Does drop-down box have option selected. + else if(!dj_undef("type", elem) && (elem.type == "select-one" || elem.type == "select-multiple") + && (elem.selectedIndex == -1 + || /^\s*$/.test(elem.options[elem.selectedIndex].value))){ + missing[missing.length] = elem.name; + } + // Does radio button group (or check box group) have option checked. + else if(elem instanceof Array){ + var checked = false; + for(var j = 0; j < elem.length; j++){ + if (elem[j].checked) { checked = true; } + } + if(!checked){ + missing[missing.length] = elem[0].name; + } + } + } + } + + // See if checkbox groups and select boxes have x number of required values. + if(profile.required instanceof Array){ + for (var i = 0; i < profile.required.length; i++){ + if(!dojo.lang.isObject(profile.required[i])){ continue; } + var elem, numRequired; + for(var name in profile.required[i]){ + elem = form[name]; + numRequired = profile.required[i][name]; + } + // case 1: elem is a check box group + if(elem instanceof Array){ + var checked = 0; + for(var j = 0; j < elem.length; j++){ + if(elem[j].checked){ checked++; } + } + if(checked < numRequired){ + missing[missing.length] = elem[0].name; + } + } + // case 2: elem is a select box + else if(!dj_undef("type", elem) && elem.type == "select-multiple" ){ + var selected = 0; + for(var j = 0; j < elem.options.length; j++){ + if (elem.options[j].selected && !/^\s*$/.test(elem.options[j].value)) { selected++; } + } + if(selected < numRequired){ + missing[missing.length] = elem.name; + } + } + } + } + + // Dependent fields are required when the target field is present (not blank). + // Todo: Support dependent and target fields that are radio button groups, or select drop-down lists. + // Todo: Make the dependency based on a specific value of the target field. + // Todo: allow dependent fields to have several required values, like {checkboxgroup: 3}. + if(dojo.lang.isObject(profile.dependencies) || dojo.lang.isObject(profile.dependancies)){ + if(profile["dependancies"]){ + dojo.deprecated("dojo.validate.check", "profile 'dependancies' is deprecated, please use " + + "'dependencies'", "0.5"); + profile.dependencies=profile.dependancies; + } + // properties of dependencies object are the names of dependent fields to be checked + for(name in profile.dependencies){ + var elem = form[name]; // the dependent element + if(dj_undef("type", elem)){continue;} + if(elem.type != "text" && elem.type != "textarea" && elem.type != "password"){ continue; } // limited support + if(/\S+/.test(elem.value)){ continue; } // has a value already + if(results.isMissing(elem.name)){ continue; } // already listed as missing + var target = form[profile.dependencies[name]]; + if(target.type != "text" && target.type != "textarea" && target.type != "password"){ continue; } // limited support + if(/^\s*$/.test(target.value)){ continue; } // skip if blank + missing[missing.length] = elem.name; // ok the dependent field is missing + } + } + + // Find invalid input fields. + if(dojo.lang.isObject(profile.constraints)){ + // constraint properties are the names of fields to bevalidated + for(name in profile.constraints){ + var elem = form[name]; + if(!elem) {continue;} + + // skip if blank - its optional unless required, in which case it + // is already listed as missing. + if(!dj_undef("tagName",elem) + && (elem.tagName.toLowerCase().indexOf("input") >= 0 + || elem.tagName.toLowerCase().indexOf("textarea") >= 0) + && /^\s*$/.test(elem.value)){ + continue; + } + + var isValid = true; + // case 1: constraint value is validation function + if(dojo.lang.isFunction(profile.constraints[name])){ + isValid = profile.constraints[name](elem.value); + }else if(dojo.lang.isArray(profile.constraints[name])){ + + // handle nested arrays for multiple constraints + if(dojo.lang.isArray(profile.constraints[name][0])){ + for (var i=0; i<profile.constraints[name].length; i++){ + isValid = dojo.validate.evaluateConstraint(profile, profile.constraints[name][i], name, elem); + if(!isValid){ break; } + } + }else{ + // case 2: constraint value is array, first elem is function, + // tail is parameters + isValid = dojo.validate.evaluateConstraint(profile, profile.constraints[name], name, elem); + } + } + + if(!isValid){ + invalid[invalid.length] = elem.name; + } + } + } + + // Find unequal confirm fields and report them as Invalid. + if(dojo.lang.isObject(profile.confirm)){ + for(name in profile.confirm){ + var elem = form[name]; // the confirm element + var target = form[profile.confirm[name]]; + if (dj_undef("type", elem) || dj_undef("type", target) || (elem.type != "text" && elem.type != "textarea" && elem.type != "password") + ||(target.type != elem.type) + ||(target.value == elem.value) // it's valid + ||(results.isInvalid(elem.name))// already listed as invalid + ||(/^\s*$/.test(target.value))) // skip if blank - only confirm if target has a value + { + continue; + } + invalid[invalid.length] = elem.name; + } + } + + return results; // Object +}; + +//TODO: evaluateConstraint doesn't use profile or fieldName args? +dojo.validate.evaluateConstraint=function(profile, /*Array*/constraint, fieldName, elem){ + // summary: + // Evaluates dojo.validate.check() constraints that are specified as array + // arguments + // + // description: The arrays are expected to be in the format of: + // constraints:{ + // fieldName: [functionToCall, param1, param2, etc.], + // fieldName: [[functionToCallFirst, param1],[functionToCallSecond,param2]] + // } + // + // This function evaluates a single array function in the format of: + // [functionName, argument1, argument2, etc] + // + // The function will be parsed out and evaluated against the incoming parameters. + // + // profile: The dojo.validate.check() profile that this evaluation is against. + // constraint: The single [] array of function and arguments for the function. + // fieldName: The form dom name of the field being validated. + // elem: The form element field. + + var isValidSomething = constraint[0]; + var params = constraint.slice(1); + params.unshift(elem.value); + if(typeof isValidSomething != "undefined"){ + return isValidSomething.apply(null, params); + } + return false; // Boolean +} Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/check.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,249 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide("dojo.validate.common"); + +dojo.require("dojo.regexp"); + + +dojo.validate.isText = function(/*String*/value, /*Object?*/flags){ +// summary: +// Checks if a string has non whitespace characters. +// Parameters allow you to constrain the length. +// +// value: A string +// flags: {length: Number, minlength: Number, maxlength: Number} +// flags.length If set, checks if there are exactly flags.length number of characters. +// flags.minlength If set, checks if there are at least flags.minlength number of characters. +// flags.maxlength If set, checks if there are at most flags.maxlength number of characters. + + flags = (typeof flags == "object") ? flags : {}; + + // test for text + if(/^\s*$/.test(value)){ return false; } // Boolean + + // length tests + if(typeof flags.length == "number" && flags.length != value.length){ return false; } // Boolean + if(typeof flags.minlength == "number" && flags.minlength > value.length){ return false; } // Boolean + if(typeof flags.maxlength == "number" && flags.maxlength < value.length){ return false; } // Boolean + + return true; // Boolean +} + +dojo.validate.isInteger = function(/*String*/value, /*Object?*/flags){ +// summary: +// Validates whether a string is in an integer format +// +// value A string +// flags {signed: Boolean|[true,false], separator: String} +// flags.signed The leading plus-or-minus sign. Can be true, false, or [true, false]. +// Default is [true, false], (i.e. sign is optional). +// flags.separator The character used as the thousands separator. Default is no separator. +// For more than one symbol use an array, e.g. [",", ""], makes ',' optional. + + var re = new RegExp("^" + dojo.regexp.integer(flags) + "$"); + return re.test(value); // Boolean +} + +dojo.validate.isRealNumber = function(/*String*/value, /*Object?*/flags){ +// summary: +// Validates whether a string is a real valued number. +// Format is the usual exponential notation. +// +// value: A string +// flags: {places: Number, decimal: String, exponent: Boolean|[true,false], eSigned: Boolean|[true,false], ...} +// flags.places The integer number of decimal places. +// If not given, the decimal part is optional and the number of places is unlimited. +// flags.decimal The character used for the decimal point. Default is ".". +// flags.exponent Express in exponential notation. Can be true, false, or [true, false]. +// Default is [true, false], (i.e. the exponential part is optional). +// flags.eSigned The leading plus-or-minus sign on the exponent. Can be true, false, +// or [true, false]. Default is [true, false], (i.e. sign is optional). +// flags in regexp.integer can be applied. + + var re = new RegExp("^" + dojo.regexp.realNumber(flags) + "$"); + return re.test(value); // Boolean +} + +dojo.validate.isCurrency = function(/*String*/value, /*Object?*/flags){ +// summary: +// Validates whether a string denotes a monetary value. +// value: A string +// flags: {signed:Boolean|[true,false], symbol:String, placement:String, separator:String, +// fractional:Boolean|[true,false], decimal:String} +// flags.signed The leading plus-or-minus sign. Can be true, false, or [true, false]. +// Default is [true, false], (i.e. sign is optional). +// flags.symbol A currency symbol such as Yen "�", Pound "�", or the Euro sign "�". +// Default is "$". For more than one symbol use an array, e.g. ["$", ""], makes $ optional. +// flags.placement The symbol can come "before" the number or "after". Default is "before". +// flags.separator The character used as the thousands separator. The default is ",". +// flags.fractional The appropriate number of decimal places for fractional currency (e.g. cents) +// Can be true, false, or [true, false]. Default is [true, false], (i.e. cents are optional). +// flags.decimal The character used for the decimal point. Default is ".". + + var re = new RegExp("^" + dojo.regexp.currency(flags) + "$"); + return re.test(value); // Boolean +} + +dojo.validate.isInRange = function(/*String*/value, /*Object?*/flags){ +//summary: +// Validates whether a string denoting an integer, +// real number, or monetary value is between a max and min. +// +// value: A string +// flags: {max:Number, min:Number, decimal:String} +// flags.max A number, which the value must be less than or equal to for the validation to be true. +// flags.min A number, which the value must be greater than or equal to for the validation to be true. +// flags.decimal The character used for the decimal point. Default is ".". + + //stripping the separator allows NaN to perform as expected, if no separator, we assume ',' + //once i18n support is ready for this, instead of assuming, we default to i18n's recommended value + value = value.replace(dojo.lang.has(flags,'separator')?flags.separator:',', '', 'g'). + replace(dojo.lang.has(flags,'symbol')?flags.symbol:'$', ''); + if(isNaN(value)){ + return false; // Boolean + } + // assign default values to missing paramters + flags = (typeof flags == "object") ? flags : {}; + var max = (typeof flags.max == "number") ? flags.max : Infinity; + var min = (typeof flags.min == "number") ? flags.min : -Infinity; + var dec = (typeof flags.decimal == "string") ? flags.decimal : "."; + + // splice out anything not part of a number + var pattern = "[^" + dec + "\\deE+-]"; + value = value.replace(RegExp(pattern, "g"), ""); + + // trim ends of things like e, E, or the decimal character + value = value.replace(/^([+-]?)(\D*)/, "$1"); + value = value.replace(/(\D*)$/, ""); + + // replace decimal with ".". The minus sign '-' could be the decimal! + pattern = "(\\d)[" + dec + "](\\d)"; + value = value.replace(RegExp(pattern, "g"), "$1.$2"); + + value = Number(value); + if ( value < min || value > max ) { return false; } // Boolean + + return true; // Boolean +} + +dojo.validate.isNumberFormat = function(/*String*/value, /*Object?*/flags){ +// summary: +// Validates any sort of number based format +// +// description: +// Use it for phone numbers, social security numbers, zip-codes, etc. +// The value can be validated against one format or one of multiple formats. +// +// Format +// # Stands for a digit, 0-9. +// ? Stands for an optional digit, 0-9 or nothing. +// All other characters must appear literally in the expression. +// +// Example +// "(###) ###-####" -> (510) 542-9742 +// "(###) ###-#### x#???" -> (510) 542-9742 x153 +// "###-##-####" -> 506-82-1089 i.e. social security number +// "#####-####" -> 98225-1649 i.e. zip code +// +// value: A string +// flags: {format:String} +// flags.format A string or an Array of strings for multiple formats. + + var re = new RegExp("^" + dojo.regexp.numberFormat(flags) + "$", "i"); + return re.test(value); // Boolean +} + +dojo.validate.isValidLuhn = function(/*String*/value){ +//summary: Compares value against the Luhn algorithm to verify its integrity + var sum, parity, curDigit; + if(typeof value!='string'){ + value = String(value); + } + value = value.replace(/[- ]/g,''); //ignore dashes and whitespaces + parity = value.length%2; + sum=0; + for(var i=0;i<value.length;i++){ + curDigit = parseInt(value.charAt(i)); + if(i%2==parity){ + curDigit*=2; + } + if(curDigit>9){ + curDigit-=9; + } + sum+=curDigit; + } + return !(sum%10); //Boolean +} + +/** + Procedural API Description + + The main aim is to make input validation expressible in a simple format. + You define profiles which declare the required and optional fields and any constraints they might have. + The results are provided as an object that makes it easy to handle missing and invalid input. + + Usage + + var results = dojo.validate.check(form, profile); + + Profile Object + + var profile = { + // filters change the field value and are applied before validation. + trim: ["tx1", "tx2"], + uppercase: ["tx9"], + lowercase: ["tx5", "tx6", "tx7"], + ucfirst: ["tx10"], + digit: ["tx11"], + + // required input fields that are blank will be reported missing. + // required radio button groups and drop-down lists with no selection will be reported missing. + // checkbox groups and selectboxes can be required to have more than one value selected. + // List required fields by name and use this notation to require more than one value: {checkboxgroup: 2}, {selectboxname: 3}. + required: ["tx7", "tx8", "pw1", "ta1", "rb1", "rb2", "cb3", "s1", {"doubledip":2}, {"tripledip":3}], + + // dependant/conditional fields are required if the target field is present and not blank. + // At present only textbox, password, and textarea fields are supported. + dependencies: { + cc_exp: "cc_no", + cc_type: "cc_no", + }, + + // Fields can be validated using any boolean valued function. + // Use arrays to specify parameters in addition to the field value. + constraints: { + field_name1: myValidationFunction, + field_name2: dojo.validate.isInteger, + field_name3: [myValidationFunction, additional parameters], + field_name4: [dojo.validate.isValidDate, "YYYY.MM.DD"], + field_name5: [dojo.validate.isEmailAddress, false, true], + }, + + // Confirm is a sort of conditional validation. + // It associates each field in its property list with another field whose value should be equal. + // If the values are not equal, the field in the property list is reported as Invalid. Unless the target field is blank. + confirm: { + email_confirm: "email", + pw2: "pw1", + } + }; + + Results Object + + isSuccessful(): Returns true if there were no invalid or missing fields, else it returns false. + hasMissing(): Returns true if the results contain any missing fields. + getMissing(): Returns a list of required fields that have values missing. + isMissing(field): Returns true if the field is required and the value is missing. + hasInvalid(): Returns true if the results contain fields with invalid data. + getInvalid(): Returns a list of fields that have invalid values. + isInvalid(field): Returns true if the field has an invalid value. + +*/ Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js ------------------------------------------------------------------------------ svn:eol-style = native Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js ------------------------------------------------------------------------------ svn:keywords = "Date Rev Author URL Id" Propchange: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/common.js ------------------------------------------------------------------------------ svn:mime-type = text/plain Added: ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/creditCard.js URL: http://svn.apache.org/viewvc/ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/creditCard.js?view=auto&rev=509273 ============================================================================== --- ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/creditCard.js (added) +++ ofbiz/trunk/framework/images/webapp/images/dojo/src/validate/creditCard.js Mon Feb 19 09:56:06 2007 @@ -0,0 +1,102 @@ +/* + Copyright (c) 2004-2006, The Dojo Foundation + All Rights Reserved. + + Licensed under the Academic Free License version 2.1 or above OR the + modified BSD license. For more information on Dojo licensing, see: + + http://dojotoolkit.org/community/licensing.shtml +*/ + +dojo.provide('dojo.validate.creditCard'); + +dojo.require("dojo.lang.common"); +dojo.require("dojo.validate.common"); + +/* + Validates Credit Cards using account number rules in conjunction with the Luhn algorigthm + + */ + +dojo.validate.isValidCreditCard = function(/*String|Int*/value, /*String*/ccType){ + //Summary: + // checks if type ma |
«
Return to OFBiz - Commits
|
1 view|%1 views
| Free forum by Nabble | Edit this page |