/// <summary>
 /// Initializes a new instance of the <see cref="ValidatorDescriptionAttribute" /> class.
 /// </summary>
 /// <param name="tag">The validation tag.</param>
 /// <param name="validationResultType">The validation result type.</param>
 /// <param name="validationType">The validation type.</param>
 public ValidatorDescriptionAttribute(string tag, ValidationResultType validationResultType = ValidationResultType.Error,
     ValidationType validationType = ValidationType.Field)
 {
     Tag = tag;
     ValidationResultType = validationResultType;
     ValidationType = validationType;
 }
        public string Generate(int length, ValidationType validationType)
        {
            var passwordValidation = new PasswordValidationService();

            var wordChar = GenerateChars(length, validationType);
            var word = new String(wordChar);
            var measuredPasswordStrength = passwordValidation.MeasurePasswordStrength(word);

            if (validationType == ValidationType.Strong)
                while (measuredPasswordStrength != 100)
                {
                    wordChar = GenerateChars(length, validationType);
                    word = new String(wordChar);
                    measuredPasswordStrength = passwordValidation.MeasurePasswordStrength(word);
                }
            else if (validationType == ValidationType.Medium)
                while (measuredPasswordStrength != 50)
                {
                    wordChar = GenerateChars(length, validationType);
                    word = new String(wordChar);
                    measuredPasswordStrength = passwordValidation.MeasurePasswordStrength(word);
                }
            else if (validationType == ValidationType.Weak)
                while (measuredPasswordStrength != 20)
                {
                    wordChar = GenerateChars(length, validationType);
                    word = new String(wordChar);
                    measuredPasswordStrength = passwordValidation.MeasurePasswordStrength(word);
                }

            return word ;
        }
 public ValidationResult(string message, string description, ValidationType validationType)
     : this()
 {
     this.Message = message;
     this.Description = description;
     this.ValidationType = validationType;
 }
 public ValidationRule(Func<bool> condition, string message,
     ValidationType validationType = ValidationType.Required)
 {
     Condition = condition;
     Message = message;
     ValidationType = validationType;
 }
        public IHttpActionResult Get(int length, ValidationType validationType)
        {
            var generatePasswordService = new PasswordGenerateService();

            var password = generatePasswordService.Generate(length, validationType);

            return Ok(password);
        }
	public XmlValidatingReader(String xmlFragment, XmlNodeType fragType,
							   XmlParserContext context)
			{
				reader = new XmlTextReader(xmlFragment, fragType, context);
				entityHandling = EntityHandling.ExpandEntities;
				validationType = ValidationType.Auto;
				reader.Normalization = true;
			}
        /// <summary>
        /// Add the Stage validations
        /// </summary>
        /// <param name="validationType">The type of validation to perform. 
        ///     Only the dialog should use the FromDialog type.</param>
        public void addValidations(ValidationType validationType)
        {
            Int32 stageId;
            if (!Int32.TryParse(getId(), out stageId)
                || stageId < 0 || stageId >= m_maxStages)
            {
                DataConfiguration.addValidation("The stage ID must be within 0 and " + (m_maxStages - 1).ToString());
            }
            else if (stageId != 0 && getDescription().Length == 0)
            {
                DataConfiguration.addValidation("The stage description must be specified (Stage: " + getId() + ")");
            }

            if (validationType.Equals(ValidationType.Complete))
            {
                if (!hasCompletions())
                {
                    DataConfiguration.addValidation("Stage completions are mandatory (Stage: " + getId() + ")");
                }
                else
                {
                    int actionCount;
                    int totalActionCount = 0;
                    foreach (Completion completion in getCompletions())
                    {
                        switch (completion.getCompletionType())
                        {
                            case CompletionType.Fight_Mob:
                            case CompletionType.Use_Skill_On_Mob_Type:
                            case CompletionType.Use_Skill_On_Object:
                                actionCount = completion.getCount();
                                if (actionCount == -1)
                                {
                                    // If there is no count then it "counts" as one
                                    actionCount = 1;
                                }
                                totalActionCount += actionCount;
                                break;
                        }
                    }
                    if (totalActionCount >= 32)
                    {
                        DataConfiguration.addValidation("There cannot be more than 32 actions in a stage (Stage: " + getId() + ")");
                    }

                    // Verify CompletionType interdependencies
                    /*if (Completion.contains(getCompletions(), CompletionType.Take_Item_To_Location)
                        && !Completion.contains(getCompletions(), CompletionType.Nearest_Nav))
                    {
                        DataConfiguration.addValidation("The type '"
                                                            + CompletionType.Take_Item_To_Location.ToString()
                                                            + "' requires the '"
                                                            + CompletionType.Nearest_Nav.ToString()
                                                            + "' type (Stage: " + getId() + ").");
                    }*/
                }
            } // ValidationType.Complete
        }
        public static string GetValidationErrorMessage(ValidationType validType)
        {
            string errorMessage, dummy;

            //Get Error Message
            GetValidationDetails(validType, out dummy, out errorMessage);

            return errorMessage;
        }
Exemple #9
0
    public string GetSubmitScript(string formId, RouteValueDictionary routeValues, string actionUrl, ValidationType validation = ValidationType.None)
    {
      if (routeValues == null) throw new ArgumentNullException("routeValues");
      if (String.IsNullOrWhiteSpace(actionUrl)) throw new ArgumentNullException("actionUrl");
      if (String.IsNullOrWhiteSpace(formId)) throw new ArgumentNullException("formId");

      var scriptTemplate = "var param = [{1}]; setFormParams('{0}', param); submitForm(this, event, '{0}', '{2}', '{3}'); return false;";
      return String.Format(scriptTemplate, formId, SafeConvert.ToJSArray(routeValues), actionUrl, validation);
    }
Exemple #10
0
        public static string GetValidationExpression(ValidationType validType)
        {
            string regularExpression, dummy;

            //Get regular Expression
            GetValidationDetails(validType, out regularExpression, out dummy);

            return regularExpression;
        }
        public static ValidationMessage AddValidationMessage(this Controller controller, string title, string message, ValidationType validationtType = ValidationType.Info)
        {
            Validator validator = controller.TempData["Validator"] as Validator;
            validator = validator ?? new Validator();

            var validationMessage = validator.AddValidationMessage(title, message, validationtType);
            controller.TempData["Validator"] = validator;
            return validationMessage;
        }
		public XmlValidatingReader (XmlReader reader)
		{
			sourceReader = reader;
			xmlTextReader = reader as XmlTextReader;
			if (xmlTextReader == null)
				resolver = new XmlUrlResolver ();
			entityHandling = EntityHandling.ExpandEntities;
			validationType = ValidationType.Auto;
			storedCharacters = new StringBuilder ();
		}
 public ValidationMessage AddValidationMessage(string title, string message, ValidationType messageType)
 {
     var validation = new ValidationMessage()
     {
         Title = title,
         Message = message,
         MessageType = messageType
     };
     ValidationMessages.Add(validation);
     return validation;
 }
	// Constructors.
	public XmlValidatingReader(XmlReader reader)
			{
				this.reader = (reader as XmlTextReader);
				if(this.reader == null)
				{
					throw new ArgumentException
						(S._("Xml_NotTextReader"), "reader");
				}
				entityHandling = EntityHandling.ExpandEntities;
				validationType = ValidationType.Auto;
				this.reader.Normalization = true;
			}
        private static void HeightLessThanTwo_ThrowsException(ValidationType validationType)
        {
            ExceptionAssert.Throws(
                () =>
                    {
                        // Arrange
                        BoardValidationError[] errors;

                        // Act
                        BoardValidator.Validate(5, 1, new[] { 1, 2, 3, 4, 0 }, validationType, out errors);
                    },
                typeof(ArgumentException));
        }
        // SxS: This method resolves an Uri but does not expose it to caller. It's OK to suppress the SxS warning.
        private void SetupValidation(ValidationType valType)
        {
            _validator = BaseValidator.CreateInstance(valType, this, _schemaCollection, _eventHandling, _processIdentityConstraints);

            XmlResolver resolver = GetResolver();

            _validator.XmlResolver = resolver;

            if (_outerReader.BaseURI.Length > 0)
            {
                _validator.BaseUri = (resolver == null) ? new Uri(_outerReader.BaseURI, UriKind.RelativeOrAbsolute) : resolver.ResolveUri(null, _outerReader.BaseURI);
            }
            _coreReaderImpl.ValidationEventHandling = (_validationType == ValidationType.None) ? null : _eventHandling;
        }
Exemple #17
0
        public static bool Validate(ValidationType type,string input)
        {
            string regex = string.Empty;
            switch (type)
            {
                case ValidationType.Email:
                    regex = EmailPattern;
                    break;
                default:
                    throw new Exception("没有找到验证类型!");
            }

            return Regex.IsMatch(input, regex);
        }
        public static void CheckTypeValid(Type type, ValidationType valType, string key)
        {
            switch (valType)
            {
            case ValidationType.Select:
            {
                if (!type.IsPrimitive && !_validNonPrimitive.Contains(type) &&
                    !typeof(IEnumerable).IsAssignableFrom(type))
                {
                    throw new InvalidValidationBuilderException($"Registered property ({key})" +
                                                                $" can not be of type {type}.");
                }
            } break;

            case ValidationType.OrderBy:
            {
                if (!type.IsPrimitive && !_validNonPrimitive.Contains(type))
                {
                    throw new InvalidValidationBuilderException
                              ($"Registered property: {key} can not be of type {type}.");
                }
                ;
            } break;

            case ValidationType.Filter:
            {
                if (!type.IsPrimitive && !_validNonPrimitive.Contains(type))
                {
                    throw new InvalidValidationBuilderException
                              ($"Registered property: {key} can not be of type {type}.");
                }
                ;
            } break;

            case ValidationType.Expand:
            {
                if (type.IsValueType)
                {
                    throw new InvalidValidationBuilderException
                              ($"Registered property: {key} can not be of type: {type}. Expand is limited to classes.");
                }
            } break;

            default:
            {
                throw new ArgumentOutOfRangeException(nameof(valType), valType, null);
            }
            }
        }
Exemple #19
0
        // Initializes a new instance of XmlValidatingReaderImpl class with the specified arguments.
        // This constructor is used when creating XmlValidatingReaderImpl reader via "XmlReader.Create(..)"
        internal XmlValidatingReaderImpl(XmlReader reader, ValidationEventHandler?settingsEventHandler, bool processIdentityConstraints)
        {
            XmlAsyncCheckReader?asyncCheckReader = reader as XmlAsyncCheckReader;

            if (asyncCheckReader != null)
            {
                reader = asyncCheckReader.CoreReader;
            }

            _outerReader    = this;
            _coreReader     = reader;
            _coreReaderImpl = (reader as XmlTextReaderImpl) !;
            if (_coreReaderImpl == null)
            {
                XmlTextReader?tr = reader as XmlTextReader;
                if (tr != null)
                {
                    _coreReaderImpl = tr.Impl;
                }
            }

            if (_coreReaderImpl == null)
            {
                throw new ArgumentException(SR.Arg_ExpectingXmlTextReader, nameof(reader));
            }

            _coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
            _coreReaderNSResolver       = reader as IXmlNamespaceResolver;
            _processIdentityConstraints = processIdentityConstraints;

#pragma warning disable 618

            _schemaCollection = new XmlSchemaCollection(_coreReader.NameTable);

#pragma warning restore 618

            _schemaCollection.XmlResolver = GetResolver();

            _eventHandling = new ValidationEventHandling(this);
            if (settingsEventHandler != null)
            {
                _eventHandling.AddHandler(settingsEventHandler);
            }
            _coreReaderImpl.ValidationEventHandling = _eventHandling;
            _coreReaderImpl.OnDefaultAttributeUse   = new XmlTextReaderImpl.OnDefaultAttributeUseDelegate(ValidateDefaultAttributeOnUse);

            _validationType = ValidationType.DTD;
            SetupValidation(ValidationType.DTD);
        }
Exemple #20
0
        private void SetupValidation(ValidationType valType)
        {
            validator = BaseValidator.CreateInstance(valType, this, schemaCollection, eventHandler, processIdentityConstraints);

            XmlResolver resolver = GetResolver();

            validator.XmlResolver = resolver;

            if (outerReader.BaseURI.Length > 0)
            {
                validator.BaseUri = (resolver == null) ? new Uri(outerReader.BaseURI, UriKind.RelativeOrAbsolute) : resolver.ResolveUri(null, outerReader.BaseURI);
            }

            UpdateHandlers();
        }
        public static ResponseStatus ToResponseStatus(this ValidationType type)
        {
            switch (type)
            {
            case ValidationType.Unauthorized:
                return(ResponseStatus.Unauthorised);

            case ValidationType.NotFound:
                return(ResponseStatus.NotFound);

            case ValidationType.Invalid:
            default:
                return(ResponseStatus.Invalid);
            }
        }
    protected bool RoomVisibleInput => roomVisibilityDropdown != null ? roomVisibilityDropdown.options[roomVisibilityDropdown.value].text == "PUBLIC" ? true : false : true; // If there is no dropdown then the default value is TRUE

    protected override bool ValidateInput(ValidationType validationType)
    {
        bool validated = true;

        if (validationType == ValidationType.Create)
        {
            if (string.IsNullOrWhiteSpace(RoomNameInput))
            {
                Debug.LogWarning("Room name is empty");
                validated = false;
            }
        }

        return(base.ValidateInput(validationType) && validated);
    }
Exemple #23
0
        public void SetAllGivenProperties()
        {
            // Arrange.
            bool           isMatch        = true;
            string         message        = "message";
            ValidationType validationType = ValidationType.Range;

            // Act.
            ValidationPredicateResult result = new ValidationPredicateResult(isMatch, message, validationType);

            // Assert.
            Assert.AreEqual(isMatch, result.IsMatch);
            Assert.AreEqual(message, result.Message);
            Assert.AreEqual(validationType, result.ValidationType);
        }
Exemple #24
0
        /// <summary>
        /// Validierung eines XML-Dokument
        /// </summary>
        /// <param name="xmlDoc">Referenz auf das Dokument</param>
        /// <param name="validationType">Angabe des Validierung-Typs</param>
        /// <param name="schemaUri">URI der Schemadatei, falls gegen eine solche Validierung werden soll</param>
        /// <returns>Gibt einen Wert der XmlValidatorResult-Auflistung zurück</returns>
        public XmlValidatorResult ValidateXmlDocument(XmlDocument xmlDoc,
                                                      ValidationType validationType, string schemaUri)
        {
            //MemoryStream aus dem Xml-Dokument erzeugen
            //MemoryStream xmlStream = new MemoryStream();
            //xmlDoc.Save(xmlStream);
            //xmlStream.Seek(0, SeekOrigin.Begin);
            StringReader xmlStream = new StringReader(xmlDoc.InnerXml);
            // Mit dem MemoryStream eine XmlReader-Instanz erzeugen
            XmlReader xrdr = XmlReader.Create(xmlStream);

            // xmlStream.Seek(0, SeekOrigin.Begin);

            return(ValidateXml(xrdr, validationType, schemaUri));
        }
 /// <summary>
 /// 初始化 HtmlDocumentValidation 的新实例。
 /// </summary>
 /// <param name="name">此验证的名称信息(用于向用户界面显示)。</param>
 /// <param name="documentValidation">一个委托,用于验证 HtmlDocument 是否符合规则。</param>
 /// <param name="errorMessage">验证不符合规则时的提示信息。</param>
 public ValidationDelegateTaken(String name, ValidationType validationType, System.Func<HtmlAgilityPack.HtmlDocument, bool> documentValidation, String errorMessage)
 {
     this.documentValidation = documentValidation;
     this.errorMessage = errorMessage;
     this.Name = name;
     this.Type = validationType;
     if (documentValidation == null)
     {
         throw new ArgumentNullException("documentValidation");
     }
     if (errorMessage == null)
     {
         throw new ArgumentNullException("errorMessage");
     }
 }
        /// <summary>
        /// Validate a package for the given validation context.
        /// </summary>
        /// <param name="packageId">Package Id in the format of [package name]@[package version].</param>
        /// <param name="validationType">The type of validation to assess.</param>
        /// <returns>True if the validation successfully completed.</returns>
        public static bool ValidatePackage(string packageId, ValidationType validationType)
        {
            if (string.IsNullOrEmpty(packageId))
            {
                throw new ArgumentNullException(packageId);
            }

            var packageIdParts = packageId.Split('@');

            if (packageIdParts.Length != 2)
            {
                throw new ArgumentException("Malformed package Id " + packageId);
            }

            return(ValidatePackage(packageIdParts[0], packageIdParts[1], validationType));
        }
        public static void Should(this IValidationResult source, ValidationType type, Guid guid)
        {
            switch (type)
            {
            case ValidationType.Pass:
                ShouldPass(source, guid);
                break;

            case ValidationType.Fail:
                ShouldFail(source, guid);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Exemple #28
0
        /// <summary>
        /// Constructs the validator with a XSD schema.
        /// </summary>
        /// <param name="xsd">XSD schema.</param>
        public Validator(string xsd)
        {
            //validate arguments
            if (xsd == null)
            {
                throw new ArgumentNullException("xsd");
            }
            else if (xsd.Length == 0)
            {
                throw new ArgumentOutOfRangeException("xsd");
            }

            //store schema
            m_schema         = xsd;
            m_validationType = ValidationType.Schema;
        }
Exemple #29
0
        /// <summary>
        /// 验证
        /// </summary>
        /// <param name="info"></param>
        /// <param name="type"></param>
        /// <param name="propertys"></param>
        /// <returns></returns>
        public virtual IList <ErrorInfo> ValidateInfo(object info, ValidationType type, IList <string> propertys = null)
        {
            var results = new List <ErrorInfo>();

            if (!CheckInfo(info))
            {
                return(results);
            }
            var valids = GetValidations(info.GetType());

            foreach (var validInfo in valids)
            {
                ValidPorpertyValue(results, info, type, validInfo, propertys);
            }
            return(results);
        }
Exemple #30
0
        /* Methode zum Validieren eines XML-Dokuments */
        public XmlValidatorResult ValidateXmlDocument(XmlDocument xmlDoc,
                                                      ValidationType validationType, string schemaFileName)
        {
            // MemoryStream aus dem Xml-Dokument erzeugen
            MemoryStream xmlStream = new MemoryStream();

            xmlDoc.Save(xmlStream);
            xmlStream.Seek(0, SeekOrigin.Begin);

            // Mit dem MemoryStream eine XmlTextReader-Instanz erzeugen
            XmlTextReader xmlTextReader = new XmlTextReader(xmlStream);

            xmlStream.Seek(0, SeekOrigin.Begin);

            return(ValidateXml(xmlTextReader, validationType, schemaFileName));
        }
        private static void Duplication_IsInvalid(ValidationType validationType)
        {
            // Arrange
            BoardValidationError[] errors;

            // Act
            bool isValid = BoardValidator.Validate(3, 3, new[] { 1, 2, 3, 4, 5, 6, 7, 7, 0 }, validationType, out errors);

            // Assert
            Assert.IsFalse(isValid);
            Assert.IsTrue(errors.Length > 0);
            Assert.AreEqual(BoardValidationErrorType.Duplication, errors[0].ErrorType);
            Assert.IsNotNull(errors[0].Position);
            Assert.AreEqual(1, errors[0].Position.X);
            Assert.AreEqual(2, errors[0].Position.Y);
        }
        public ValidationPredicateResult(bool isMatch, string message, ValidationType validationType)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            if (message.Length == 0)
            {
                throw new ArgumentException(ValidationPredicateMessages.NullOrEmptyStringMessage, "message");
            }

            this.isMatch = isMatch;
            this.message = message;
            this.validationType = validationType;
        }
        public ValidationPredicateResult(bool isMatch, string message, ValidationType validationType)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            if (message.Length == 0)
            {
                throw new ArgumentException(ValidationPredicateMessages.NullOrEmptyStringMessage, "message");
            }

            this.isMatch        = isMatch;
            this.message        = message;
            this.validationType = validationType;
        }
Exemple #34
0
        private void Add <T, P>(
            Expression <Func <T, P> > expression, string message,
            string reference, ValidationType type, Exception exception = null)
        {
            string display = expression.PropertyDisplay();

            reference = reference ?? expression.PropertyPath();

            message = message ?? (ValidationMessage.IsTypeError(type) ? Resource.XNotValid : Resource.XValid);
            message = Regex.Replace(message, @"\{0\}", display);

            Messages.Add(new ValidationMessage(message, reference, type)
            {
                Exception = exception
            });
        }
 /// <summary>
 ///     This method checks data to see if it is valid as well as allowing you to specify a minimum/maximum length.
 ///     (Overrides Password minimum length.)
 /// </summary>
 /// <param name="strVal">The string data to check.</param>
 /// <param name="typeValid">This specifies the type of validation to use.</param>
 /// <param name="minLength">This is the minimum length that the string must be to pass validation.</param>
 /// <param name="maxLength">This is the maximum length that the string must be to pass validation.</param>
 /// <returns></returns>
 public static bool RegExCheck(this string strVal, ValidationType typeValid, int minLength, int maxLength)
 {
     if (minLength == 0 && strVal.Length == 0)
     {
         return(true);
     }
     if (strVal.Length < minLength || strVal.Length > maxLength)
     {
         return(false);
     }
     if (typeValid == ValidationType.Password)
     {
         return(RegExMatch(strVal, $@"^[a-zA-Z0-9 !#$@%&*+=?^_{{|}}~-]{{{minLength},{maxLength}}}$"));
     }
     return(RegExCheck(strVal, typeValid));
 }
        public virtual string GetErrorMessage(string propertyName, ValidationType validation)
        {
            var mp = _m.GetProperty(propertyName);

            if (mp == null)
            {
                return(string.Empty);
            }
            var mpv = new ObjectDefPropertyValidation(); // mp.GetValidation(validation);

            if (mpv == null)
            {
                return(string.Empty);
            }
            return(mpv.ValidationMessage);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="type"></param>
        /// <param name="expiresMinute"></param>
        /// <returns></returns>
        public SmsContent GetSmsContent(ValidationType type, int expiresMinute = 5)
        {
            var code = new Random(Guid.NewGuid().GetHashCode()).Next(100000, 999999);

            if (_appSettings.DeveloperMode)
            {
                code = 123456;
            }

            string content;

            switch (type)
            {
            case ValidationType.Register:
                content = $"您正在使用手机号注册福禄通行证账号,验证码:{code},{expiresMinute}分钟内有效。如非本人操作,请忽略本短信。";
                break;

            case ValidationType.ChangePhoneNo:
                content = $"您正在修改手机号,验证码:{code},{expiresMinute}分钟内有效。请勿将验证码泄露给他人使用。";
                break;

            case ValidationType.ResetPassword:
                content = $"您正在使用手机号进行修改密码操作,验证码:{code},{expiresMinute}分钟内有效。验证码提供给让人可能导致账号被盗,请勿泄露,谨防被骗。";
                break;

            case ValidationType.Login:
                content = $"您正在使用短信验证码登录功能,验证码:{code},{expiresMinute}分钟内有效。请勿将验证码泄露给他人使用。";
                break;

            case ValidationType.Validate:
                expiresMinute = 15;
                content       = $"您正在使用手机验证操作,验证码:{code},{expiresMinute}分钟内有效。如非本人操作,请忽略本短信。";
                break;

            default:
                content = $"验证码:{code},{expiresMinute}分钟内有效。请勿将验证码泄露给他人使用。";
                break;
            }

            return(new SmsContent
            {
                Code = code.ToString(),
                Content = content,
                ExpiresMinute = expiresMinute,
                ValidationType = type
            });
        }
        public virtual bool IsValid(string propertyName, ValidationType validation)
        {
            var mp = _m.GetProperty(propertyName);

            if (mp == null)
            {
                return(false);
            }
            var mpv = _m.Validations.Where(p => p.ValidationType == validation).FirstOrDefault();

            if (mpv == null)
            {
                return(true);             //if no such validation, continue
            }
            var bResult = false;

            switch (mpv.ValidationType)
            {
            case ValidationType.Required:
                bResult = ValidateRequired(propertyName);
                break;

            case ValidationType.Range:
                bResult = ValidateRange(propertyName, mpv);
                break;

            case ValidationType.StringLength:
                bResult = ValidateStringLength(propertyName, mpv);
                break;

            case ValidationType.RegularExpression:
                bResult = ValidateRegularExpression(propertyName, mpv);
                break;

            case ValidationType.Identifier:
                bResult = ValidateIdentifier(propertyName, mpv);
                break;

            case ValidationType.Email:
                bResult = ValidateEmail(propertyName, mpv);
                break;

            default:
                break;
            }
            return(bResult);
        }
Exemple #39
0
 public ValidateItem(string text, string message, ValidationType validationtype, string regexmessageonfail = "")
 {
     Text    = text;
     Message = message;
     Type    = validationtype;
     Regex   = "";
     if (validationtype == ValidationType.Email)
     {
         Regex = "@";
     }
     else if (validationtype == ValidationType.Phone)
     {
         Regex = @"^(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:\(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9])\s*\)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\s*(?:[.-]\s*)?)?([2-9]1[02-9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})(?:\s*(?:#|x\.?|ext\.?|extension)\s*(\d+))?$";
     }
     RegExpression = new Regex(Regex);
     RegexMessage  = regexmessageonfail;
 }
Exemple #40
0
        public void Check_exception_values(
            string message, string stackTrace,
            string reference, ValidationType type, string expected)
        {
            try
            {
                throw new CustonException(message, stackTrace);
            }
            catch (CustonException ex)
            {
                ValidationMessage result = new(ex, reference, type);

                Assert.Equal(result.Message, expected);
                Assert.Equal(result.Type, type);
                Assert.Equal(result.Reference, reference);
            }
        }
Exemple #41
0
 /// <summary>Resets the members of the settings class to their default values.</summary>
 public void Reset()
 {
     this.checkCharacters = true;
     this.closeInput      = false;
     this.conformance     = ConformanceLevel.Document;
     this.ignoreComments  = false;
     this.ignoreProcessingInstructions = false;
     this.ignoreWhitespace             = false;
     this.lineNumberOffset             = 0;
     this.linePositionOffset           = 0;
     this.prohibitDtd = true;
     this.schemas     = null;
     this.schemasNeedsInitialization = true;
     this.validationFlags            = (XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.AllowXmlAttributes);
     this.validationType             = ValidationType.None;
     this.xmlResolver = new XmlUrlResolver();
 }
        // Initializes a new instance of XmlValidatingReaderImpl class with the specified arguments.
        // This constructor is used when creating XmlValidatingReaderImpl reader via "XmlReader.Create(..)"
        internal XmlValidatingReaderImpl(XmlReader reader, ValidationEventHandler settingsEventHandler, bool processIdentityConstraints)
        {
            XmlAsyncCheckReader asyncCheckReader = reader as XmlAsyncCheckReader;

            if (asyncCheckReader != null)
            {
                reader = asyncCheckReader.CoreReader;
            }
            outerReader    = this;
            coreReader     = reader;
            coreReaderImpl = reader as XmlTextReaderImpl;
            if (coreReaderImpl == null)
            {
                XmlTextReader tr = reader as XmlTextReader;
                if (tr != null)
                {
                    coreReaderImpl = tr.Impl;
                }
            }
            if (coreReaderImpl == null)
            {
                throw new ArgumentException(Res.GetString(Res.Arg_ExpectingXmlTextReader), "reader");
            }
            coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
            coreReaderNSResolver            = reader as IXmlNamespaceResolver;
            this.processIdentityConstraints = processIdentityConstraints;

#pragma warning disable 618

            schemaCollection = new XmlSchemaCollection(coreReader.NameTable);

#pragma warning restore 618

            schemaCollection.XmlResolver = GetResolver();

            eventHandling = new ValidationEventHandling(this);
            if (settingsEventHandler != null)
            {
                eventHandling.AddHandler(settingsEventHandler);
            }
            coreReaderImpl.ValidationEventHandling = eventHandling;
            coreReaderImpl.OnDefaultAttributeUse   = new XmlTextReaderImpl.OnDefaultAttributeUseDelegate(ValidateDefaultAttributeOnUse);

            validationType = ValidationType.DTD;
            SetupValidation(ValidationType.DTD);
        }
Exemple #43
0
    private void Validate(String filename, ValidationType vt)
    {
        try
        {
            //Implement the readers.  Set the ValidationType.
            txtreader             = new XmlTextReader(filename);
            reader                = new XmlValidatingReader(txtreader);
            reader.ValidationType = vt;

            //If the reader is set to validate, set the event handler.
            if (vt == ValidationType.None)
            {
                Console.WriteLine("\nParsing XML file " + filename.ToString());
            }
            else
            {
                Console.WriteLine("\nValidating XML file " + filename.ToString());
                m_success = true;
                //Set the validation event handler.
                reader.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
            }

            // Read XML data
            while (reader.Read())
            {
            }

            if (vt == ValidationType.None)
            {
                Console.WriteLine("Finished parsing file.");
            }
            else
            {
                Console.WriteLine("Validation finished. Validation {0}", (m_success == true ? "successful" : "failed"));
            }
        }

        finally
        {
            //Close the reader.
            if (reader != null)
            {
                reader.Close();
            }
        }
    }
Exemple #44
0
        void Initialize(XmlResolver resolver)
        {
            nameTable = null;
#if !SILVERLIGHT
            if (!EnableLegacyXmlSettings())
            {
                xmlResolver = resolver;
                // limit the entity resolving to 10 million character. the caller can still
                // override it to any other value or set it to zero for unlimiting it
                maxCharactersFromEntities = (long)1e7;
            }
            else
#endif
            {
                xmlResolver = (resolver == null ? CreateDefaultResolver() : resolver);
                maxCharactersFromEntities = 0;
            }
            lineNumberOffset   = 0;
            linePositionOffset = 0;
            checkCharacters    = true;
            conformanceLevel   = ConformanceLevel.Document;

            ignoreWhitespace = false;
            ignorePIs        = false;
            ignoreComments   = false;
            dtdProcessing    = DtdProcessing.Prohibit;
            closeInput       = false;

            maxCharactersInDocument = 0;

#if !SILVERLIGHT
            schemas          = null;
            validationType   = ValidationType.None;
            validationFlags  = XmlSchemaValidationFlags.ProcessIdentityConstraints;
            validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
#endif

#if ASYNC || FEATURE_NETCORE
            useAsync = false;
#endif

            isReadOnly = false;
#if !SILVERLIGHT
            IsXmlResolverSet = false;
#endif
        }
        /// <summary>
        ///
        /// </summary>
        public async Task SaveLog(int appId, string content, ValidationType type, string phone, string ip,
                                  bool isSuccess, string code, int expiresMinute, string smsMsgId, string smsMsg)
        {
            var smsRecordEntity = new SmsRecordEntity
            {
                SendTime   = DateTime.Now,
                ClientId   = appId,
                Content    = content,
                SendType   = type.ToString(),
                Receiver   = phone,
                IpAddress  = ip,
                SendResult = isSuccess,
                Remark     = isSuccess ? $"发送成功,msg_id:{smsMsgId}" : $"发送失败,错误描述:{smsMsg},msg_id:{smsMsgId}"
            };
            await _smsRecordRepository.InsertAsync(smsRecordEntity);

            await _unitOfWork.SaveChangesAsync();
        }
    private static void PerformValidation(this TextBox tbx, ValidationType validationType)
    {
        char[] enteredString = tbx.Text.ToCharArray();
        switch (validationType)
        {
        case ValidationType.Amount:
            tbx.Text = AmountValidation(enteredString);
            break;

        case ValidationType.Integer:
            tbx.Text = IntegerValidation(enteredString);
            break;

        default:
            break;
        }
        tbx.SelectionStart = tbx.Text.Length;
    }
    protected virtual bool ValidateInput(ValidationType validationType)
    {
        if (validationType == ValidationType.Create)
        {
            if (string.IsNullOrWhiteSpace(SaveNameInput))
            {
                Debug.LogWarning("Invalid player input, save name is empty!");
                return(false);
            }
            if (!SaveDataManager.Instance.ValidateNewSaveName(SaveNameInput))
            {
                Debug.LogWarning("Invalid player input, a save file with the same name already exists!");
                return(false);
            }
        }

        return(true);
    }
        public static int Validate(ValidationType validationType, List <string> passwordDatabaseList)
        {
            var numberOfValidPasswords = 0;
            var passwordObjects        = CreatePasswordObjects(passwordDatabaseList);

            switch (validationType)
            {
            case ValidationType.MinMaxAmountOfRequiredCharacter:
                numberOfValidPasswords = GetNumberOfValidPasswordsByMinMaxAmountOfRequiredCharacter(passwordObjects);
                break;

            case ValidationType.PositionOfRequiredCharacter:
                numberOfValidPasswords = GetNumberOfValidPasswordsByPositionOfRequiredCharacter(passwordObjects);
                break;
            }

            return(numberOfValidPasswords);
        }
Exemple #49
0
        // Initializes a new instance of XmlValidatingReaderImpl class with the specified arguments.
        // This constructor is used when creating XmlValidatingReaderImpl reader via "XmlReader.Create(..)"
        internal XmlValidatingReaderImpl(XmlReader reader, ValidationEventHandler settingsEventHandler, bool processIdentityConstraints)
        {
            outerReader    = this;
            coreReader     = reader;
            coreReaderImpl = reader as XmlTextReaderImpl;
            if (coreReaderImpl == null)
            {
                XmlTextReader tr = reader as XmlTextReader;
                if (tr != null)
                {
                    coreReaderImpl = tr.Impl;
                }
            }
            if (coreReaderImpl == null)
            {
                throw new ArgumentException(Res.GetString(Res.Arg_ExpectingXmlTextReader), "reader");
            }
            coreReaderImpl.XmlValidatingReaderCompatibilityMode = true;
            coreReaderNSResolver            = reader as IXmlNamespaceResolver;
            this.processIdentityConstraints = processIdentityConstraints;

#pragma warning disable 618

            schemaCollection = new XmlSchemaCollection(coreReader.NameTable);

#pragma warning restore 618

            schemaCollection.XmlResolver = GetResolver();

            if (settingsEventHandler == null)
            {
                internalEventHandler = new ValidationEventHandler(InternalValidationCallback);
                eventHandler         = internalEventHandler;
                coreReaderImpl.ValidationEventHandler = internalEventHandler;
            }
            else
            {
                eventHandler = settingsEventHandler;
                coreReaderImpl.ValidationEventHandler = settingsEventHandler;
            }

            validationType = ValidationType.DTD;
            SetupValidation(ValidationType.DTD);
        }
        public DateValidationAttribute(ValidationType validationType,  string compareWith = "", string fromDate = "")
        {
            _validationType = validationType;
            switch (validationType)
            {
                case ValidationType.Compare:
                    {
                        _propertyNameToCompare = compareWith;
                        break;
                    }
                case ValidationType.RangeValidation:
                    {
                        _fromDate = new DateTime(2000, 1, 1);
                        _toDate = DateTime.Today;

                        break;
                    }

            }
        }
 public bool IsValid(ValidationType validationType = ValidationType.Time)
 {
     switch (validationType)
     {
         case ValidationType.Time:
             return validTill > DateTime.Now;
         case ValidationType.Strict:
             if (validTill > DateTime.Now) 
                 User.Login(creditals);
             else
             {
                 throw new SecurityException("Time validation failed");
             }
             break;  
         default:
             Trace.Write("Unexpectedly got to validationTypes default close");
             throw new Exception("unexpected");
     }
     return true;
 }
        public static BaseValidator CreateInstance(ValidationType valType, XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, IValidationEventHandling eventHandling, bool processIdentityConstraints)
        {
            switch (valType)
            {
                case ValidationType.None:
                    return new BaseValidator(reader, schemaCollection, eventHandling);

                case ValidationType.Auto:
                    return new AutoValidator(reader, schemaCollection, eventHandling);

                case ValidationType.DTD:
                    return new DtdValidator(reader, eventHandling, processIdentityConstraints);

                case ValidationType.XDR:
                    return new XdrValidator(reader, schemaCollection, eventHandling);

                case ValidationType.Schema:
                    return new XsdValidator(reader, schemaCollection, eventHandling);
            }
            return null;
        }
Exemple #53
0
 private static void GetValidationDetails(ValidationType validationType, out string regularExpression,
                                          out string errorMessage)
 {
     //Set ValidationHelper Type
     switch (validationType)
     {
         case ValidationType.Numbers:
             regularExpression = RegularExpression.NUMBERS;
             errorMessage = "Value must only contain numbers";
             break;
         case ValidationType.AlphaNumeric:
             regularExpression = RegularExpression.ALPHANUMERIC;
             errorMessage = "Value must only contain character and alphabets";
             break;
         case ValidationType.Characters:
             regularExpression = RegularExpression.CHARACTERS;
             errorMessage = "Value must only contain characters";
             break;
         case ValidationType.Decimals:
             regularExpression = RegularExpression.DECIMAL;
             errorMessage = "Value is not the right format";
             break;
         case ValidationType.Name:
             regularExpression = RegularExpression.NAME;
             errorMessage = "Name is not valid";
             break;
         case ValidationType.Email:
             regularExpression = RegularExpression.EMAIL;
             errorMessage = "Email is invalid";
             break;
         case ValidationType.PostalCode:
             regularExpression = RegularExpression.POSTAL_CODE;
             errorMessage = "Postal Code is invalid";
             break;
         default:
             regularExpression = string.Empty;
             errorMessage = string.Empty;
             break;
     }
 }
        private char[] GenerateChars(int length, ValidationType validationType)
        {
            var word = new char[length];
            var random = new Random();
            for (var i = 0; i < length; i++)
            {
                _generators = new List<IGenerateCommand>()
                {
                    new LowerCaseGenerate(),
                    new UpperCaseGenerate(),
                    new NumberGenerate()
                };

                if (validationType == ValidationType.Strong)
                    _generators.Add(new SpecialCharGenerate());

                Thread.Sleep(10);
                word[i] = _generators[random.Next(0, _generators.Count)].Generate();
            }

            return word;
        }
Exemple #55
0
		public static MvcHtmlString SubmitLink(this HtmlHelper helper, string title, string formId, string actionName, string controllerName, ValidationType validationType = ValidationType.All, object htmlAttributes = null, object submitParams = null)
		{
			var url = GetActionUrl(helper.ViewContext.RequestContext, actionName, controllerName);
			var paramsDictionary = new RouteValueDictionary(submitParams);
			var linkTag = GetSubmitTag("a", title, htmlAttributes);
			linkTag.Attributes.Add("href", "#");

			if (paramsDictionary.Count > 0)
			{
				var key = paramsDictionary.GetHashCode();
				var scriptTag = GetWrapperScriptTag(paramsDictionary, key);
				var script = String.Format("submitFormWithParams_{3}(this, event, '#{0}', '{1}', '{2}'); return false;", formId, url, validationType.ToString(), key);
				linkTag.Attributes.Add("onclick", script);
				return MvcHtmlString.Create(scriptTag.ToString(TagRenderMode.Normal) + linkTag.ToString(TagRenderMode.Normal));
			}
			else
			{
				var script = String.Format("submitFormWithoutParams(this, event, '#{0}', '{1}', '{2}'); return false;", formId, url, validationType.ToString());
				linkTag.Attributes.Add("onclick", script);
				return MvcHtmlString.Create(linkTag.ToString(TagRenderMode.Normal));
			}
		}
        public string ApplyXSL(string content, string title, XmlResolver resolver, ValidationType validate)
        {
            StringReader reader = new StringReader(content);
            XmlReaderSettings rsettings = new XmlReaderSettings();
            if (validate != ValidationType.None)
            {
                rsettings.ValidationType = validate;
                if (validate == ValidationType.DTD)
                {
                    rsettings.ProhibitDtd = false;
                }
                rsettings.ValidationEventHandler += MyValidationEventHandler;
            }
            XmlReader doc = XmlReader.Create(reader, rsettings);
            XsltArgumentList args = new XsltArgumentList();
            args.AddParam("root-note", "", title);

            args.AddExtensionObject("http://beatniksoftware.com/tomboy",
                                    new TransformExtension());

            StringWriter outWriter = new StringWriter();
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.ConformanceLevel = ConformanceLevel.Auto;
            settings.OmitXmlDeclaration = true;

            XmlWriter writer = XmlWriter.Create(outWriter, settings);

            if (writer == null)
            {
                Logger.Error("XmlWriter was null");
                throw new NullReferenceException("xmlWriter was null");
            }
            _xsl.Transform(doc, args, writer, resolver);

            doc.Close();
            outWriter.Close();
            return outWriter.ToString();
        }
        public void SetType(Control control, ValidationType type)
        {
            if (this.infos.ContainsKey(control))
            {
                // Especially, in design mode and type is none, ask whether remove validation information.
                if ((DesignMode)
                 && (type == ValidationType.None))
                {
                    // Set right to left message box options.
                    MessageBoxOptions options = (MessageBoxOptions)0;
                    if (this.RightToLeft)
                    {
                        options = MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign;
                    }

                    if (MessageBox.Show(
                            Resources.VALIDATOR_REMOVEWARNING,
                            Resources.VALIDATOR_NAME,
                            MessageBoxButtons.YesNo,
                            MessageBoxIcon.Question,
                            MessageBoxDefaultButton.Button1,
                            options) == DialogResult.Yes)
                    {
                        this.RemoveValidationInfo(control);
                    }
                }
                else
                {
                    this.infos[control].Type = type;
                }
            }
            else
            {
                this.AddValidationInfo(control);
                ValidationInfo info = this.infos[control];
                info.Type = type;
            }
        }
Exemple #58
0
        private void Initialize(XmlResolver resolver)
        {
            _nameTable = null;
            if (!EnableLegacyXmlSettings())
            {
                _xmlResolver = resolver;
                // limit the entity resolving to 10 million character. the caller can still
                // override it to any other value or set it to zero for unlimiting it
                _maxCharactersFromEntities = (long)1e7;
            }
            else
            {
                _xmlResolver = (resolver == null ? CreateDefaultResolver() : resolver);
                _maxCharactersFromEntities = 0;
            }
            _lineNumberOffset = 0;
            _linePositionOffset = 0;
            _checkCharacters = true;
            _conformanceLevel = ConformanceLevel.Document;

            _ignoreWhitespace = false;
            _ignorePIs = false;
            _ignoreComments = false;
            _dtdProcessing = DtdProcessing.Prohibit;
            _closeInput = false;

            _maxCharactersInDocument = 0;

            _schemas = null;
            _validationType = ValidationType.None;
            _validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
            _validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;

            _useAsync = false;

            _isReadOnly = false;
            IsXmlResolverSet = false;
        }
Exemple #59
0
        /// <summary>
        /// Instantiates a new validating XML reader.
        /// </summary>
        /// <param name="xmlReader"></param>
        /// <param name="validationType"></param>
        /// <param name="xsdResourceName"></param>
        /// <returns></returns>
        public static XmlReader NewValidatingReader(XmlReader xmlReader, ValidationType validationType, params string[] xsdResourceName)
        {
            if (Logger.IsUtilVerbose) Logger.UtilSource.TraceEvent(TraceEventType.Verbose, 0, "Instantiating new validating reader with validation: " + validationType + " and XSDs " + Misc.ArrayToString(xsdResourceName));

            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();

            if (validationType == ValidationType.DTD) {
                xmlReaderSettings.ProhibitDtd = false;
            }
            else if ((validationType == ValidationType.Schema) && (xsdResourceName != null)) {
                XmlSchemaSet sc = new XmlSchemaSet();
                sc.Add(XmlSchema.Read(Parameter.GetEmbeddedResourceStream(xsdResourceName[0]),	null));
                xmlReaderSettings.Schemas.Add(sc);
            }
            else if (validationType != ValidationType.None) {
                throw new BREException("Validation type should be DTD, Schema or None. If Schema, a schema resource name must be passed.");
            }

            xmlReaderSettings.ValidationType = validationType;

            return XmlReader.Create(xmlReader, xmlReaderSettings);
        }
Exemple #60
0
 /// <summary>
 /// Instantiates a new validating XML reader.
 /// </summary>
 /// <param name="xmlReader"></param>
 /// <param name="validationType"></param>
 /// <returns></returns>
 public static XmlReader NewValidatingReader(XmlReader xmlReader, ValidationType validationType)
 {
     return NewValidatingReader(xmlReader, validationType, null);
 }