| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache 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.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
|
|
| /**
|
| * This is a generated class and is not intended for modification.
|
| */
|
| package valueObjects
|
| {
|
| import com.adobe.fiber.styles.IStyle;
|
| import com.adobe.fiber.styles.Style;
|
| import com.adobe.fiber.styles.StyleValidator;
|
| import com.adobe.fiber.valueobjects.AbstractEntityMetadata;
|
| import com.adobe.fiber.valueobjects.AvailablePropertyIterator;
|
| import com.adobe.fiber.valueobjects.IPropertyIterator;
|
| import mx.events.ValidationResultEvent;
|
| import com.adobe.fiber.core.model_internal;
|
| import com.adobe.fiber.valueobjects.IModelType;
|
| import mx.events.PropertyChangeEvent;
|
|
|
| use namespace model_internal;
|
|
|
| [ExcludeClass]
|
| internal class _EmployeeEntityMetadata extends com.adobe.fiber.valueobjects.AbstractEntityMetadata
|
| {
|
| private static var emptyArray:Array = new Array();
|
|
|
| model_internal static var allProperties:Array = new Array("office", "departmentid", "street", "zipcode", "state", "lastname", "firstname", "photofile", "city", "id", "title", "officephone", "email", "cellphone");
|
| model_internal static var allAssociationProperties:Array = new Array();
|
| model_internal static var allRequiredProperties:Array = new Array("office", "departmentid", "street", "zipcode", "state", "city", "officephone", "email", "cellphone");
|
| model_internal static var allAlwaysAvailableProperties:Array = new Array("office", "departmentid", "street", "zipcode", "state", "lastname", "firstname", "photofile", "city", "id", "title", "officephone", "email", "cellphone");
|
| model_internal static var guardedProperties:Array = new Array();
|
| model_internal static var dataProperties:Array = new Array("office", "departmentid", "street", "zipcode", "state", "lastname", "firstname", "photofile", "city", "id", "title", "officephone", "email", "cellphone");
|
| model_internal static var sourceProperties:Array = emptyArray
|
| model_internal static var nonDerivedProperties:Array = new Array("office", "departmentid", "street", "zipcode", "state", "lastname", "firstname", "photofile", "city", "id", "title", "officephone", "email", "cellphone");
|
| model_internal static var derivedProperties:Array = new Array();
|
| model_internal static var collectionProperties:Array = new Array();
|
| model_internal static var collectionBaseMap:Object;
|
| model_internal static var entityName:String = "Employee";
|
| model_internal static var dependentsOnMap:Object;
|
| model_internal static var dependedOnServices:Array = new Array();
|
| model_internal static var propertyTypeMap:Object;
|
|
|
|
|
| model_internal var _officeIsValid:Boolean;
|
| model_internal var _officeValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _officeIsValidCacheInitialized:Boolean = false;
|
| model_internal var _officeValidationFailureMessages:Array;
|
|
|
| model_internal var _streetIsValid:Boolean;
|
| model_internal var _streetValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _streetIsValidCacheInitialized:Boolean = false;
|
| model_internal var _streetValidationFailureMessages:Array;
|
|
|
| model_internal var _zipcodeIsValid:Boolean;
|
| model_internal var _zipcodeValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _zipcodeIsValidCacheInitialized:Boolean = false;
|
| model_internal var _zipcodeValidationFailureMessages:Array;
|
|
|
| model_internal var _stateIsValid:Boolean;
|
| model_internal var _stateValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _stateIsValidCacheInitialized:Boolean = false;
|
| model_internal var _stateValidationFailureMessages:Array;
|
|
|
| model_internal var _cityIsValid:Boolean;
|
| model_internal var _cityValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _cityIsValidCacheInitialized:Boolean = false;
|
| model_internal var _cityValidationFailureMessages:Array;
|
|
|
| model_internal var _officephoneIsValid:Boolean;
|
| model_internal var _officephoneValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _officephoneIsValidCacheInitialized:Boolean = false;
|
| model_internal var _officephoneValidationFailureMessages:Array;
|
|
|
| model_internal var _emailIsValid:Boolean;
|
| model_internal var _emailValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _emailIsValidCacheInitialized:Boolean = false;
|
| model_internal var _emailValidationFailureMessages:Array;
|
|
|
| model_internal var _cellphoneIsValid:Boolean;
|
| model_internal var _cellphoneValidator:com.adobe.fiber.styles.StyleValidator;
|
| model_internal var _cellphoneIsValidCacheInitialized:Boolean = false;
|
| model_internal var _cellphoneValidationFailureMessages:Array;
|
|
|
| model_internal var _instance:_Super_Employee;
|
| model_internal static var _nullStyle:com.adobe.fiber.styles.Style = new com.adobe.fiber.styles.Style();
|
|
|
| public function _EmployeeEntityMetadata(value : _Super_Employee)
|
| {
|
| // initialize property maps
|
| if (model_internal::dependentsOnMap == null)
|
| {
|
| // dependents map
|
| model_internal::dependentsOnMap = new Object();
|
| model_internal::dependentsOnMap["office"] = new Array();
|
| model_internal::dependentsOnMap["departmentid"] = new Array();
|
| model_internal::dependentsOnMap["street"] = new Array();
|
| model_internal::dependentsOnMap["zipcode"] = new Array();
|
| model_internal::dependentsOnMap["state"] = new Array();
|
| model_internal::dependentsOnMap["lastname"] = new Array();
|
| model_internal::dependentsOnMap["firstname"] = new Array();
|
| model_internal::dependentsOnMap["photofile"] = new Array();
|
| model_internal::dependentsOnMap["city"] = new Array();
|
| model_internal::dependentsOnMap["id"] = new Array();
|
| model_internal::dependentsOnMap["title"] = new Array();
|
| model_internal::dependentsOnMap["officephone"] = new Array();
|
| model_internal::dependentsOnMap["email"] = new Array();
|
| model_internal::dependentsOnMap["cellphone"] = new Array();
|
|
|
| // collection base map
|
| model_internal::collectionBaseMap = new Object();
|
| }
|
|
|
| // Property type Map
|
| model_internal::propertyTypeMap = new Object();
|
| model_internal::propertyTypeMap["office"] = "String";
|
| model_internal::propertyTypeMap["departmentid"] = "int";
|
| model_internal::propertyTypeMap["street"] = "String";
|
| model_internal::propertyTypeMap["zipcode"] = "String";
|
| model_internal::propertyTypeMap["state"] = "String";
|
| model_internal::propertyTypeMap["lastname"] = "String";
|
| model_internal::propertyTypeMap["firstname"] = "String";
|
| model_internal::propertyTypeMap["photofile"] = "String";
|
| model_internal::propertyTypeMap["city"] = "String";
|
| model_internal::propertyTypeMap["id"] = "int";
|
| model_internal::propertyTypeMap["title"] = "String";
|
| model_internal::propertyTypeMap["officephone"] = "String";
|
| model_internal::propertyTypeMap["email"] = "String";
|
| model_internal::propertyTypeMap["cellphone"] = "String";
|
|
|
| model_internal::_instance = value;
|
| model_internal::_officeValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForOffice);
|
| model_internal::_officeValidator.required = true;
|
| model_internal::_officeValidator.requiredFieldError = "office is required";
|
| //model_internal::_officeValidator.source = model_internal::_instance;
|
| //model_internal::_officeValidator.property = "office";
|
| model_internal::_streetValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForStreet);
|
| model_internal::_streetValidator.required = true;
|
| model_internal::_streetValidator.requiredFieldError = "street is required";
|
| //model_internal::_streetValidator.source = model_internal::_instance;
|
| //model_internal::_streetValidator.property = "street";
|
| model_internal::_zipcodeValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForZipcode);
|
| model_internal::_zipcodeValidator.required = true;
|
| model_internal::_zipcodeValidator.requiredFieldError = "zipcode is required";
|
| //model_internal::_zipcodeValidator.source = model_internal::_instance;
|
| //model_internal::_zipcodeValidator.property = "zipcode";
|
| model_internal::_stateValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForState);
|
| model_internal::_stateValidator.required = true;
|
| model_internal::_stateValidator.requiredFieldError = "state is required";
|
| //model_internal::_stateValidator.source = model_internal::_instance;
|
| //model_internal::_stateValidator.property = "state";
|
| model_internal::_cityValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForCity);
|
| model_internal::_cityValidator.required = true;
|
| model_internal::_cityValidator.requiredFieldError = "city is required";
|
| //model_internal::_cityValidator.source = model_internal::_instance;
|
| //model_internal::_cityValidator.property = "city";
|
| model_internal::_officephoneValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForOfficephone);
|
| model_internal::_officephoneValidator.required = true;
|
| model_internal::_officephoneValidator.requiredFieldError = "officephone is required";
|
| //model_internal::_officephoneValidator.source = model_internal::_instance;
|
| //model_internal::_officephoneValidator.property = "officephone";
|
| model_internal::_emailValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForEmail);
|
| model_internal::_emailValidator.required = true;
|
| model_internal::_emailValidator.requiredFieldError = "email is required";
|
| //model_internal::_emailValidator.source = model_internal::_instance;
|
| //model_internal::_emailValidator.property = "email";
|
| model_internal::_cellphoneValidator = new StyleValidator(model_internal::_instance.model_internal::_doValidationForCellphone);
|
| model_internal::_cellphoneValidator.required = true;
|
| model_internal::_cellphoneValidator.requiredFieldError = "cellphone is required";
|
| //model_internal::_cellphoneValidator.source = model_internal::_instance;
|
| //model_internal::_cellphoneValidator.property = "cellphone";
|
| }
|
|
|
| override public function getEntityName():String
|
| {
|
| return model_internal::entityName;
|
| }
|
|
|
| override public function getProperties():Array
|
| {
|
| return model_internal::allProperties;
|
| }
|
|
|
| override public function getAssociationProperties():Array
|
| {
|
| return model_internal::allAssociationProperties;
|
| }
|
|
|
| override public function getRequiredProperties():Array
|
| {
|
| return model_internal::allRequiredProperties;
|
| }
|
|
|
| override public function getDataProperties():Array
|
| {
|
| return model_internal::dataProperties;
|
| }
|
|
|
| public function getSourceProperties():Array
|
| {
|
| return model_internal::sourceProperties;
|
| }
|
|
|
| public function getNonDerivedProperties():Array
|
| {
|
| return model_internal::nonDerivedProperties;
|
| }
|
|
|
| override public function getGuardedProperties():Array
|
| {
|
| return model_internal::guardedProperties;
|
| }
|
|
|
| override public function getUnguardedProperties():Array
|
| {
|
| return model_internal::allAlwaysAvailableProperties;
|
| }
|
|
|
| override public function getDependants(propertyName:String):Array
|
| {
|
| if (model_internal::nonDerivedProperties.indexOf(propertyName) == -1)
|
| throw new Error(propertyName + " is not a data property of entity Employee");
|
|
|
| return model_internal::dependentsOnMap[propertyName] as Array;
|
| }
|
|
|
| override public function getDependedOnServices():Array
|
| {
|
| return model_internal::dependedOnServices;
|
| }
|
|
|
| override public function getCollectionProperties():Array
|
| {
|
| return model_internal::collectionProperties;
|
| }
|
|
|
| override public function getCollectionBase(propertyName:String):String
|
| {
|
| if (model_internal::collectionProperties.indexOf(propertyName) == -1)
|
| throw new Error(propertyName + " is not a collection property of entity Employee");
|
|
|
| return model_internal::collectionBaseMap[propertyName];
|
| }
|
|
|
| override public function getPropertyType(propertyName:String):String
|
| {
|
| if (model_internal::allProperties.indexOf(propertyName) == -1)
|
| throw new Error(propertyName + " is not a property of Employee");
|
|
|
| return model_internal::propertyTypeMap[propertyName];
|
| }
|
|
|
| override public function getAvailableProperties():com.adobe.fiber.valueobjects.IPropertyIterator
|
| {
|
| return new com.adobe.fiber.valueobjects.AvailablePropertyIterator(this);
|
| }
|
|
|
| override public function getValue(propertyName:String):*
|
| {
|
| if (model_internal::allProperties.indexOf(propertyName) == -1)
|
| {
|
| throw new Error(propertyName + " does not exist for entity Employee");
|
| }
|
|
|
| return model_internal::_instance[propertyName];
|
| }
|
|
|
| override public function setValue(propertyName:String, value:*):void
|
| {
|
| if (model_internal::nonDerivedProperties.indexOf(propertyName) == -1)
|
| {
|
| throw new Error(propertyName + " is not a modifiable property of entity Employee");
|
| }
|
|
|
| model_internal::_instance[propertyName] = value;
|
| }
|
|
|
| override public function getMappedByProperty(associationProperty:String):String
|
| {
|
| switch(associationProperty)
|
| {
|
| default:
|
| {
|
| return null;
|
| }
|
| }
|
| }
|
|
|
| override public function getPropertyLength(propertyName:String):int
|
| {
|
| switch(propertyName)
|
| {
|
| default:
|
| {
|
| return 0;
|
| }
|
| }
|
| }
|
|
|
| override public function isAvailable(propertyName:String):Boolean
|
| {
|
| if (model_internal::allProperties.indexOf(propertyName) == -1)
|
| {
|
| throw new Error(propertyName + " does not exist for entity Employee");
|
| }
|
|
|
| if (model_internal::allAlwaysAvailableProperties.indexOf(propertyName) != -1)
|
| {
|
| return true;
|
| }
|
|
|
| switch(propertyName)
|
| {
|
| default:
|
| {
|
| return true;
|
| }
|
| }
|
| }
|
|
|
| override public function getIdentityMap():Object
|
| {
|
| var returnMap:Object = new Object();
|
|
|
| return returnMap;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| override public function get invalidConstraints():Array
|
| {
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| return model_internal::_instance.model_internal::_invalidConstraints;
|
| }
|
| else
|
| {
|
| // recalculate isValid
|
| model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
|
| return model_internal::_instance.model_internal::_invalidConstraints;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| override public function get validationFailureMessages():Array
|
| {
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| return model_internal::_instance.model_internal::_validationFailureMessages;
|
| }
|
| else
|
| {
|
| // recalculate isValid
|
| model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
|
| return model_internal::_instance.model_internal::_validationFailureMessages;
|
| }
|
| }
|
|
|
| override public function getDependantInvalidConstraints(propertyName:String):Array
|
| {
|
| var dependants:Array = getDependants(propertyName);
|
| if (dependants.length == 0)
|
| {
|
| return emptyArray;
|
| }
|
|
|
| var currentlyInvalid:Array = invalidConstraints;
|
| if (currentlyInvalid.length == 0)
|
| {
|
| return emptyArray;
|
| }
|
|
|
| var filterFunc:Function = function(element:*, index:int, arr:Array):Boolean
|
| {
|
| return dependants.indexOf(element) > -1;
|
| }
|
|
|
| return currentlyInvalid.filter(filterFunc);
|
| }
|
|
|
| /**
|
| * isValid
|
| */
|
| [Bindable(event="propertyChange")]
|
| public function get isValid() : Boolean
|
| {
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| return model_internal::_instance.model_internal::_isValid;
|
| }
|
| else
|
| {
|
| // recalculate isValid
|
| model_internal::_instance.model_internal::_isValid = model_internal::_instance.model_internal::calculateIsValid();
|
| return model_internal::_instance.model_internal::_isValid;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isOfficeAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isDepartmentidAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isStreetAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isZipcodeAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isStateAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isLastnameAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isFirstnameAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isPhotofileAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isCityAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isIdAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isTitleAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isOfficephoneAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isEmailAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get isCellphoneAvailable():Boolean
|
| {
|
| return true;
|
| }
|
|
|
|
|
| /**
|
| * derived property recalculation
|
| */
|
| public function invalidateDependentOnOffice():void
|
| {
|
| if (model_internal::_officeIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfOffice = null;
|
| model_internal::calculateOfficeIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnStreet():void
|
| {
|
| if (model_internal::_streetIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfStreet = null;
|
| model_internal::calculateStreetIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnZipcode():void
|
| {
|
| if (model_internal::_zipcodeIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfZipcode = null;
|
| model_internal::calculateZipcodeIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnState():void
|
| {
|
| if (model_internal::_stateIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfState = null;
|
| model_internal::calculateStateIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnCity():void
|
| {
|
| if (model_internal::_cityIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfCity = null;
|
| model_internal::calculateCityIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnOfficephone():void
|
| {
|
| if (model_internal::_officephoneIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfOfficephone = null;
|
| model_internal::calculateOfficephoneIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnEmail():void
|
| {
|
| if (model_internal::_emailIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfEmail = null;
|
| model_internal::calculateEmailIsValid();
|
| }
|
| }
|
| public function invalidateDependentOnCellphone():void
|
| {
|
| if (model_internal::_cellphoneIsValidCacheInitialized )
|
| {
|
| model_internal::_instance.model_internal::_doValidationCacheOfCellphone = null;
|
| model_internal::calculateCellphoneIsValid();
|
| }
|
| }
|
|
|
| model_internal function fireChangeEvent(propertyName:String, oldValue:Object, newValue:Object):void
|
| {
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, propertyName, oldValue, newValue));
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officeStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get officeValidator() : StyleValidator
|
| {
|
| return model_internal::_officeValidator;
|
| }
|
|
|
| model_internal function set _officeIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_officeIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_officeIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "officeIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officeIsValid():Boolean
|
| {
|
| if (!model_internal::_officeIsValidCacheInitialized)
|
| {
|
| model_internal::calculateOfficeIsValid();
|
| }
|
|
|
| return model_internal::_officeIsValid;
|
| }
|
|
|
| model_internal function calculateOfficeIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_officeValidator.validate(model_internal::_instance.office)
|
| model_internal::_officeIsValid_der = (valRes.results == null);
|
| model_internal::_officeIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::officeValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::officeValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officeValidationFailureMessages():Array
|
| {
|
| if (model_internal::_officeValidationFailureMessages == null)
|
| model_internal::calculateOfficeIsValid();
|
|
|
| return _officeValidationFailureMessages;
|
| }
|
|
|
| model_internal function set officeValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_officeValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_officeValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "officeValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get departmentidStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get streetStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get streetValidator() : StyleValidator
|
| {
|
| return model_internal::_streetValidator;
|
| }
|
|
|
| model_internal function set _streetIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_streetIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_streetIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "streetIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get streetIsValid():Boolean
|
| {
|
| if (!model_internal::_streetIsValidCacheInitialized)
|
| {
|
| model_internal::calculateStreetIsValid();
|
| }
|
|
|
| return model_internal::_streetIsValid;
|
| }
|
|
|
| model_internal function calculateStreetIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_streetValidator.validate(model_internal::_instance.street)
|
| model_internal::_streetIsValid_der = (valRes.results == null);
|
| model_internal::_streetIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::streetValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::streetValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get streetValidationFailureMessages():Array
|
| {
|
| if (model_internal::_streetValidationFailureMessages == null)
|
| model_internal::calculateStreetIsValid();
|
|
|
| return _streetValidationFailureMessages;
|
| }
|
|
|
| model_internal function set streetValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_streetValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_streetValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "streetValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get zipcodeStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get zipcodeValidator() : StyleValidator
|
| {
|
| return model_internal::_zipcodeValidator;
|
| }
|
|
|
| model_internal function set _zipcodeIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_zipcodeIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_zipcodeIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "zipcodeIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get zipcodeIsValid():Boolean
|
| {
|
| if (!model_internal::_zipcodeIsValidCacheInitialized)
|
| {
|
| model_internal::calculateZipcodeIsValid();
|
| }
|
|
|
| return model_internal::_zipcodeIsValid;
|
| }
|
|
|
| model_internal function calculateZipcodeIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_zipcodeValidator.validate(model_internal::_instance.zipcode)
|
| model_internal::_zipcodeIsValid_der = (valRes.results == null);
|
| model_internal::_zipcodeIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::zipcodeValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::zipcodeValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get zipcodeValidationFailureMessages():Array
|
| {
|
| if (model_internal::_zipcodeValidationFailureMessages == null)
|
| model_internal::calculateZipcodeIsValid();
|
|
|
| return _zipcodeValidationFailureMessages;
|
| }
|
|
|
| model_internal function set zipcodeValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_zipcodeValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_zipcodeValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "zipcodeValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get stateStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get stateValidator() : StyleValidator
|
| {
|
| return model_internal::_stateValidator;
|
| }
|
|
|
| model_internal function set _stateIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_stateIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_stateIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "stateIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get stateIsValid():Boolean
|
| {
|
| if (!model_internal::_stateIsValidCacheInitialized)
|
| {
|
| model_internal::calculateStateIsValid();
|
| }
|
|
|
| return model_internal::_stateIsValid;
|
| }
|
|
|
| model_internal function calculateStateIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_stateValidator.validate(model_internal::_instance.state)
|
| model_internal::_stateIsValid_der = (valRes.results == null);
|
| model_internal::_stateIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::stateValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::stateValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get stateValidationFailureMessages():Array
|
| {
|
| if (model_internal::_stateValidationFailureMessages == null)
|
| model_internal::calculateStateIsValid();
|
|
|
| return _stateValidationFailureMessages;
|
| }
|
|
|
| model_internal function set stateValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_stateValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_stateValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "stateValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get lastnameStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get firstnameStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get photofileStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cityStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get cityValidator() : StyleValidator
|
| {
|
| return model_internal::_cityValidator;
|
| }
|
|
|
| model_internal function set _cityIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_cityIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_cityIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "cityIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cityIsValid():Boolean
|
| {
|
| if (!model_internal::_cityIsValidCacheInitialized)
|
| {
|
| model_internal::calculateCityIsValid();
|
| }
|
|
|
| return model_internal::_cityIsValid;
|
| }
|
|
|
| model_internal function calculateCityIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_cityValidator.validate(model_internal::_instance.city)
|
| model_internal::_cityIsValid_der = (valRes.results == null);
|
| model_internal::_cityIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::cityValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::cityValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cityValidationFailureMessages():Array
|
| {
|
| if (model_internal::_cityValidationFailureMessages == null)
|
| model_internal::calculateCityIsValid();
|
|
|
| return _cityValidationFailureMessages;
|
| }
|
|
|
| model_internal function set cityValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_cityValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_cityValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "cityValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get idStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get titleStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officephoneStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get officephoneValidator() : StyleValidator
|
| {
|
| return model_internal::_officephoneValidator;
|
| }
|
|
|
| model_internal function set _officephoneIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_officephoneIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_officephoneIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "officephoneIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officephoneIsValid():Boolean
|
| {
|
| if (!model_internal::_officephoneIsValidCacheInitialized)
|
| {
|
| model_internal::calculateOfficephoneIsValid();
|
| }
|
|
|
| return model_internal::_officephoneIsValid;
|
| }
|
|
|
| model_internal function calculateOfficephoneIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_officephoneValidator.validate(model_internal::_instance.officephone)
|
| model_internal::_officephoneIsValid_der = (valRes.results == null);
|
| model_internal::_officephoneIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::officephoneValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::officephoneValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get officephoneValidationFailureMessages():Array
|
| {
|
| if (model_internal::_officephoneValidationFailureMessages == null)
|
| model_internal::calculateOfficephoneIsValid();
|
|
|
| return _officephoneValidationFailureMessages;
|
| }
|
|
|
| model_internal function set officephoneValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_officephoneValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_officephoneValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "officephoneValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get emailStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get emailValidator() : StyleValidator
|
| {
|
| return model_internal::_emailValidator;
|
| }
|
|
|
| model_internal function set _emailIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_emailIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_emailIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "emailIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get emailIsValid():Boolean
|
| {
|
| if (!model_internal::_emailIsValidCacheInitialized)
|
| {
|
| model_internal::calculateEmailIsValid();
|
| }
|
|
|
| return model_internal::_emailIsValid;
|
| }
|
|
|
| model_internal function calculateEmailIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_emailValidator.validate(model_internal::_instance.email)
|
| model_internal::_emailIsValid_der = (valRes.results == null);
|
| model_internal::_emailIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::emailValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::emailValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get emailValidationFailureMessages():Array
|
| {
|
| if (model_internal::_emailValidationFailureMessages == null)
|
| model_internal::calculateEmailIsValid();
|
|
|
| return _emailValidationFailureMessages;
|
| }
|
|
|
| model_internal function set emailValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_emailValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_emailValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "emailValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cellphoneStyle():com.adobe.fiber.styles.Style
|
| {
|
| return model_internal::_nullStyle;
|
| }
|
|
|
| public function get cellphoneValidator() : StyleValidator
|
| {
|
| return model_internal::_cellphoneValidator;
|
| }
|
|
|
| model_internal function set _cellphoneIsValid_der(value:Boolean):void
|
| {
|
| var oldValue:Boolean = model_internal::_cellphoneIsValid;
|
| if (oldValue !== value)
|
| {
|
| model_internal::_cellphoneIsValid = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "cellphoneIsValid", oldValue, value));
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cellphoneIsValid():Boolean
|
| {
|
| if (!model_internal::_cellphoneIsValidCacheInitialized)
|
| {
|
| model_internal::calculateCellphoneIsValid();
|
| }
|
|
|
| return model_internal::_cellphoneIsValid;
|
| }
|
|
|
| model_internal function calculateCellphoneIsValid():void
|
| {
|
| var valRes:ValidationResultEvent = model_internal::_cellphoneValidator.validate(model_internal::_instance.cellphone)
|
| model_internal::_cellphoneIsValid_der = (valRes.results == null);
|
| model_internal::_cellphoneIsValidCacheInitialized = true;
|
| if (valRes.results == null)
|
| model_internal::cellphoneValidationFailureMessages_der = emptyArray;
|
| else
|
| {
|
| var _valFailures:Array = new Array();
|
| for (var a:int = 0 ; a<valRes.results.length ; a++)
|
| {
|
| _valFailures.push(valRes.results[a].errorMessage);
|
| }
|
| model_internal::cellphoneValidationFailureMessages_der = _valFailures;
|
| }
|
| }
|
|
|
| [Bindable(event="propertyChange")]
|
| public function get cellphoneValidationFailureMessages():Array
|
| {
|
| if (model_internal::_cellphoneValidationFailureMessages == null)
|
| model_internal::calculateCellphoneIsValid();
|
|
|
| return _cellphoneValidationFailureMessages;
|
| }
|
|
|
| model_internal function set cellphoneValidationFailureMessages_der(value:Array) : void
|
| {
|
| var oldValue:Array = model_internal::_cellphoneValidationFailureMessages;
|
|
|
| var needUpdate : Boolean = false;
|
| if (oldValue == null)
|
| needUpdate = true;
|
|
|
| // avoid firing the event when old and new value are different empty arrays
|
| if (!needUpdate && (oldValue !== value && (oldValue.length > 0 || value.length > 0)))
|
| {
|
| if (oldValue.length == value.length)
|
| {
|
| for (var a:int=0; a < oldValue.length; a++)
|
| {
|
| if (oldValue[a] !== value[a])
|
| {
|
| needUpdate = true;
|
| break;
|
| }
|
| }
|
| }
|
| else
|
| {
|
| needUpdate = true;
|
| }
|
| }
|
|
|
| if (needUpdate)
|
| {
|
| model_internal::_cellphoneValidationFailureMessages = value;
|
| this.dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this, "cellphoneValidationFailureMessages", oldValue, value));
|
| // Only execute calculateIsValid if it has been called before, to update the validationFailureMessages for
|
| // the entire entity.
|
| if (model_internal::_instance.model_internal::_cacheInitialized_isValid)
|
| {
|
| model_internal::_instance.model_internal::isValid_der = model_internal::_instance.model_internal::calculateIsValid();
|
| }
|
| }
|
| }
|
|
|
|
|
| /**
|
| *
|
| * @inheritDoc
|
| */
|
| override public function getStyle(propertyName:String):com.adobe.fiber.styles.IStyle
|
| {
|
| switch(propertyName)
|
| {
|
| default:
|
| {
|
| return null;
|
| }
|
| }
|
| }
|
|
|
| /**
|
| *
|
| * @inheritDoc
|
| *
|
| */
|
| override public function getPropertyValidationFailureMessages(propertyName:String):Array
|
| {
|
| switch(propertyName)
|
| {
|
| case("office"):
|
| {
|
| return officeValidationFailureMessages;
|
| }
|
| case("street"):
|
| {
|
| return streetValidationFailureMessages;
|
| }
|
| case("zipcode"):
|
| {
|
| return zipcodeValidationFailureMessages;
|
| }
|
| case("state"):
|
| {
|
| return stateValidationFailureMessages;
|
| }
|
| case("city"):
|
| {
|
| return cityValidationFailureMessages;
|
| }
|
| case("officephone"):
|
| {
|
| return officephoneValidationFailureMessages;
|
| }
|
| case("email"):
|
| {
|
| return emailValidationFailureMessages;
|
| }
|
| case("cellphone"):
|
| {
|
| return cellphoneValidationFailureMessages;
|
| }
|
| default:
|
| {
|
| return emptyArray;
|
| }
|
| }
|
| }
|
|
|
| }
|
|
|
| }
|
