home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / validators / EmailValidator.as next >
Encoding:
Text File  |  2010-06-23  |  12.3 KB  |  368 lines
  1. package mx.validators
  2. {
  3.    import mx.core.mx_internal;
  4.    
  5.    use namespace mx_internal;
  6.    
  7.    public class EmailValidator extends Validator
  8.    {
  9.       mx_internal static const VERSION:String = "3.5.0.12683";
  10.       
  11.       private static const DISALLOWED_LOCALNAME_CHARS:String = "()<>,;:\\\"[] `~!#$%^&*={}|/?\'";
  12.       
  13.       private static const DISALLOWED_DOMAIN_CHARS:String = "()<>,;:\\\"[] `~!#$%^&*+={}|/?\'";
  14.       
  15.       private var _missingUsernameError:String;
  16.       
  17.       private var tooManyAtSignsErrorOverride:String;
  18.       
  19.       private var _invalidIPDomainError:String;
  20.       
  21.       private var invalidCharErrorOverride:String;
  22.       
  23.       private var invalidPeriodsInDomainErrorOverride:String;
  24.       
  25.       private var invalidIPDomainErrorOverride:String;
  26.       
  27.       private var _invalidDomainError:String;
  28.       
  29.       private var _missingPeriodInDomainError:String;
  30.       
  31.       private var invalidDomainErrorOverride:String;
  32.       
  33.       private var missingPeriodInDomainErrorOverride:String;
  34.       
  35.       private var _invalidPeriodsInDomainError:String;
  36.       
  37.       private var _tooManyAtSignsError:String;
  38.       
  39.       private var _missingAtSignError:String;
  40.       
  41.       private var _invalidCharError:String;
  42.       
  43.       private var missingAtSignErrorOverride:String;
  44.       
  45.       private var missingUsernameErrorOverride:String;
  46.       
  47.       public function EmailValidator()
  48.       {
  49.          super();
  50.       }
  51.       
  52.       public static function validateEmail(param1:EmailValidator, param2:Object, param3:String) : Array
  53.       {
  54.          var _loc8_:int = 0;
  55.          var _loc9_:int = 0;
  56.          var _loc13_:int = 0;
  57.          var _loc14_:int = 0;
  58.          var _loc15_:String = null;
  59.          var _loc4_:Array = [];
  60.          var _loc5_:String = String(param2);
  61.          var _loc6_:String = "";
  62.          var _loc7_:String = "";
  63.          var _loc10_:int = int(_loc5_.indexOf("@"));
  64.          if(_loc10_ == -1)
  65.          {
  66.             _loc4_.push(new ValidationResult(true,param3,"missingAtSign",param1.missingAtSignError));
  67.             return _loc4_;
  68.          }
  69.          if(_loc5_.indexOf("@",_loc10_ + 1) != -1)
  70.          {
  71.             _loc4_.push(new ValidationResult(true,param3,"tooManyAtSigns",param1.tooManyAtSignsError));
  72.             return _loc4_;
  73.          }
  74.          _loc6_ = _loc5_.substring(0,_loc10_);
  75.          _loc7_ = _loc5_.substring(_loc10_ + 1);
  76.          var _loc11_:int = _loc6_.length;
  77.          if(_loc11_ == 0)
  78.          {
  79.             _loc4_.push(new ValidationResult(true,param3,"missingUsername",param1.missingUsernameError));
  80.             return _loc4_;
  81.          }
  82.          _loc9_ = 0;
  83.          while(_loc9_ < _loc11_)
  84.          {
  85.             if(DISALLOWED_LOCALNAME_CHARS.indexOf(_loc6_.charAt(_loc9_)) != -1)
  86.             {
  87.                _loc4_.push(new ValidationResult(true,param3,"invalidChar",param1.invalidCharError));
  88.                return _loc4_;
  89.             }
  90.             _loc9_++;
  91.          }
  92.          var _loc12_:int = _loc7_.length;
  93.          if(_loc7_.charAt(0) == "[" && _loc7_.charAt(_loc12_ - 1) == "]")
  94.          {
  95.             if(!isValidIPAddress(_loc7_.substring(1,_loc12_ - 1)))
  96.             {
  97.                _loc4_.push(new ValidationResult(true,param3,"invalidIPDomain",param1.invalidIPDomainError));
  98.                return _loc4_;
  99.             }
  100.          }
  101.          else
  102.          {
  103.             _loc13_ = int(_loc7_.indexOf("."));
  104.             _loc14_ = 0;
  105.             _loc15_ = "";
  106.             if(_loc13_ == -1)
  107.             {
  108.                _loc4_.push(new ValidationResult(true,param3,"missingPeriodInDomain",param1.missingPeriodInDomainError));
  109.                return _loc4_;
  110.             }
  111.             while(true)
  112.             {
  113.                _loc14_ = int(_loc7_.indexOf(".",_loc13_ + 1));
  114.                if(_loc14_ == -1)
  115.                {
  116.                   break;
  117.                }
  118.                if(_loc14_ == _loc13_ + 1)
  119.                {
  120.                   _loc4_.push(new ValidationResult(true,param3,"invalidPeriodsInDomain",param1.invalidPeriodsInDomainError));
  121.                   return _loc4_;
  122.                }
  123.                _loc13_ = _loc14_;
  124.             }
  125.             _loc15_ = _loc7_.substring(_loc13_ + 1);
  126.             if(_loc15_.length != 3 && _loc15_.length != 2 && _loc15_.length != 4 && _loc15_.length != 6)
  127.             {
  128.                _loc4_.push(new ValidationResult(true,param3,"invalidDomain",param1.invalidDomainError));
  129.                return _loc4_;
  130.             }
  131.             _loc9_ = 0;
  132.             while(_loc9_ < _loc12_)
  133.             {
  134.                if(DISALLOWED_DOMAIN_CHARS.indexOf(_loc7_.charAt(_loc9_)) != -1)
  135.                {
  136.                   _loc4_.push(new ValidationResult(true,param3,"invalidChar",param1.invalidCharError));
  137.                   return _loc4_;
  138.                }
  139.                _loc9_++;
  140.             }
  141.             if(_loc7_.charAt(0) == ".")
  142.             {
  143.                _loc4_.push(new ValidationResult(true,param3,"invalidDomain",param1.invalidDomainError));
  144.                return _loc4_;
  145.             }
  146.          }
  147.          return _loc4_;
  148.       }
  149.       
  150.       private static function isValidIPAddress(param1:String) : Boolean
  151.       {
  152.          var _loc5_:Number = NaN;
  153.          var _loc6_:int = 0;
  154.          var _loc7_:int = 0;
  155.          var _loc8_:* = false;
  156.          var _loc9_:* = false;
  157.          var _loc2_:Array = [];
  158.          var _loc3_:int = 0;
  159.          var _loc4_:int = 0;
  160.          if(param1.indexOf(":") != -1)
  161.          {
  162.             _loc8_ = param1.indexOf("::") != -1;
  163.             if(_loc8_)
  164.             {
  165.                param1 = param1.replace(/^::/,"");
  166.                param1 = param1.replace(/::/g,":");
  167.             }
  168.             while(true)
  169.             {
  170.                _loc4_ = int(param1.indexOf(":",_loc3_));
  171.                if(_loc4_ == -1)
  172.                {
  173.                   break;
  174.                }
  175.                _loc2_.push(param1.substring(_loc3_,_loc4_));
  176.                _loc3_ = _loc4_ + 1;
  177.             }
  178.             _loc2_.push(param1.substring(_loc3_));
  179.             _loc6_ = int(_loc2_.length);
  180.             _loc9_ = _loc2_[_loc6_ - 1].indexOf(".") != -1;
  181.             if(_loc9_)
  182.             {
  183.                if(_loc2_.length != 7 && !_loc8_ || _loc2_.length > 7)
  184.                {
  185.                   return false;
  186.                }
  187.                _loc7_ = 0;
  188.                while(_loc7_ < _loc6_)
  189.                {
  190.                   if(_loc7_ == _loc6_ - 1)
  191.                   {
  192.                      return isValidIPAddress(_loc2_[_loc7_]);
  193.                   }
  194.                   _loc5_ = parseInt(_loc2_[_loc7_],16);
  195.                   if(_loc5_ != 0)
  196.                   {
  197.                      return false;
  198.                   }
  199.                   _loc7_++;
  200.                }
  201.             }
  202.             else
  203.             {
  204.                if(_loc2_.length != 8 && !_loc8_ || _loc2_.length > 8)
  205.                {
  206.                   return false;
  207.                }
  208.                _loc7_ = 0;
  209.                while(_loc7_ < _loc6_)
  210.                {
  211.                   _loc5_ = parseInt(_loc2_[_loc7_],16);
  212.                   if(isNaN(_loc5_) || _loc5_ < 0 || _loc5_ > 65535)
  213.                   {
  214.                      return false;
  215.                   }
  216.                   _loc7_++;
  217.                }
  218.             }
  219.             return true;
  220.          }
  221.          if(param1.indexOf(".") != -1)
  222.          {
  223.             while(true)
  224.             {
  225.                _loc4_ = int(param1.indexOf(".",_loc3_));
  226.                if(_loc4_ == -1)
  227.                {
  228.                   break;
  229.                }
  230.                _loc2_.push(param1.substring(_loc3_,_loc4_));
  231.                _loc3_ = _loc4_ + 1;
  232.             }
  233.             _loc2_.push(param1.substring(_loc3_));
  234.             if(_loc2_.length != 4)
  235.             {
  236.                return false;
  237.             }
  238.             _loc6_ = int(_loc2_.length);
  239.             _loc7_ = 0;
  240.             while(_loc7_ < _loc6_)
  241.             {
  242.                _loc5_ = Number(_loc2_[_loc7_]);
  243.                if(isNaN(_loc5_) || _loc5_ < 0 || _loc5_ > 255)
  244.                {
  245.                   return false;
  246.                }
  247.                _loc7_++;
  248.             }
  249.             return true;
  250.          }
  251.          return false;
  252.       }
  253.       
  254.       public function set missingAtSignError(param1:String) : void
  255.       {
  256.          missingAtSignErrorOverride = param1;
  257.          _missingAtSignError = param1 != null ? param1 : resourceManager.getString("validators","missingAtSignError");
  258.       }
  259.       
  260.       public function set invalidPeriodsInDomainError(param1:String) : void
  261.       {
  262.          invalidPeriodsInDomainErrorOverride = param1;
  263.          _invalidPeriodsInDomainError = param1 != null ? param1 : resourceManager.getString("validators","invalidPeriodsInDomainError");
  264.       }
  265.       
  266.       public function set invalidIPDomainError(param1:String) : void
  267.       {
  268.          invalidIPDomainErrorOverride = param1;
  269.          _invalidIPDomainError = param1 != null ? param1 : resourceManager.getString("validators","invalidIPDomainError");
  270.       }
  271.       
  272.       override protected function doValidation(param1:Object) : Array
  273.       {
  274.          var _loc2_:Array = super.doValidation(param1);
  275.          var _loc3_:String = !!param1 ? String(param1) : "";
  276.          if(_loc2_.length > 0 || _loc3_.length == 0 && !required)
  277.          {
  278.             return _loc2_;
  279.          }
  280.          return EmailValidator.validateEmail(this,param1,null);
  281.       }
  282.       
  283.       public function set invalidDomainError(param1:String) : void
  284.       {
  285.          invalidDomainErrorOverride = param1;
  286.          _invalidDomainError = param1 != null ? param1 : resourceManager.getString("validators","invalidDomainErrorEV");
  287.       }
  288.       
  289.       public function get invalidCharError() : String
  290.       {
  291.          return _invalidCharError;
  292.       }
  293.       
  294.       override protected function resourcesChanged() : void
  295.       {
  296.          super.resourcesChanged();
  297.          invalidCharError = invalidCharErrorOverride;
  298.          invalidDomainError = invalidDomainErrorOverride;
  299.          invalidIPDomainError = invalidIPDomainErrorOverride;
  300.          invalidPeriodsInDomainError = invalidPeriodsInDomainErrorOverride;
  301.          missingAtSignError = missingAtSignErrorOverride;
  302.          missingPeriodInDomainError = missingPeriodInDomainErrorOverride;
  303.          missingUsernameError = missingUsernameErrorOverride;
  304.          tooManyAtSignsError = tooManyAtSignsErrorOverride;
  305.       }
  306.       
  307.       public function set missingUsernameError(param1:String) : void
  308.       {
  309.          missingUsernameErrorOverride = param1;
  310.          _missingUsernameError = param1 != null ? param1 : resourceManager.getString("validators","missingUsernameError");
  311.       }
  312.       
  313.       public function get missingAtSignError() : String
  314.       {
  315.          return _missingAtSignError;
  316.       }
  317.       
  318.       public function get invalidIPDomainError() : String
  319.       {
  320.          return _invalidIPDomainError;
  321.       }
  322.       
  323.       public function get tooManyAtSignsError() : String
  324.       {
  325.          return _tooManyAtSignsError;
  326.       }
  327.       
  328.       public function set tooManyAtSignsError(param1:String) : void
  329.       {
  330.          tooManyAtSignsErrorOverride = param1;
  331.          _tooManyAtSignsError = param1 != null ? param1 : resourceManager.getString("validators","tooManyAtSignsError");
  332.       }
  333.       
  334.       public function get invalidPeriodsInDomainError() : String
  335.       {
  336.          return _invalidPeriodsInDomainError;
  337.       }
  338.       
  339.       public function get invalidDomainError() : String
  340.       {
  341.          return _invalidDomainError;
  342.       }
  343.       
  344.       public function set missingPeriodInDomainError(param1:String) : void
  345.       {
  346.          missingPeriodInDomainErrorOverride = param1;
  347.          _missingPeriodInDomainError = param1 != null ? param1 : resourceManager.getString("validators","missingPeriodInDomainError");
  348.       }
  349.       
  350.       public function set invalidCharError(param1:String) : void
  351.       {
  352.          invalidCharErrorOverride = param1;
  353.          _invalidCharError = param1 != null ? param1 : resourceManager.getString("validators","invalidCharErrorEV");
  354.       }
  355.       
  356.       public function get missingPeriodInDomainError() : String
  357.       {
  358.          return _missingPeriodInDomainError;
  359.       }
  360.       
  361.       public function get missingUsernameError() : String
  362.       {
  363.          return _missingUsernameError;
  364.       }
  365.    }
  366. }
  367.  
  368.