public INodeVisitor Validate(ValidationContext context) { var knownFragments = new Dictionary<string, FragmentDefinition>(); return new EnterLeaveListener(_ => { _.Match<FragmentDefinition>(fragmentDefinition => { var fragmentName = fragmentDefinition.Name; if (knownFragments.ContainsKey(fragmentName)) { var error = new ValidationError( context.OriginalQuery, "5.4.1.1", DuplicateFragmentNameMessage(fragmentName), knownFragments[fragmentName], fragmentDefinition); context.ReportError(error); } else { knownFragments[fragmentName] = fragmentDefinition; } }); }); }
public INodeVisitor Validate(ValidationContext context) { var operationDefs = new List<Operation>(); var fragmentDefs = new List<FragmentDefinition>(); return new EnterLeaveListener(_ => { _.Match<Operation>(node => operationDefs.Add(node)); _.Match<FragmentDefinition>(node => fragmentDefs.Add(node)); _.Match<Document>( leave: document => { var fragmentNameUsed = new List<string>(); operationDefs.Apply(operation => { context.GetRecursivelyReferencedFragments(operation).Apply(fragment => { fragmentNameUsed.Add(fragment.Name); }); }); fragmentDefs.Apply(fragmentDef => { var fragName = fragmentDef.Name; if (!fragmentNameUsed.Contains(fragName)) { var error = new ValidationError(context.OriginalQuery, "5.4.1.4", UnusedFragMessage(fragName), fragmentDef); context.ReportError(error); } }); }); }); }
protected ValidationError CreateError(string message, ErrorType errorType, JSchema schema, object value, IList<ValidationError> childErrors, IJsonLineInfo lineInfo, string path) { if (_schemaDiscovery == null) { _schemaDiscovery = new JSchemaDiscovery(); _schemaDiscovery.Discover(Schema, null); } ValidationError error = new ValidationError(); error.Message = message; error.ErrorType = errorType; error.Path = path; if (lineInfo != null) { error.LineNumber = lineInfo.LineNumber; error.LinePosition = lineInfo.LinePosition; } error.Schema = schema; error.SchemaId = _schemaDiscovery.KnownSchemas.Single(s => s.Schema == schema).Id; error.SchemaBaseUri = schema.BaseUri; error.Value = value; error.ChildErrors = childErrors; return error; }
public INodeVisitor Validate(ValidationContext context) { var frequency = new Dictionary<string, string>(); return new EnterLeaveListener(_ => { _.Match<Operation>( enter: op => { if (context.Document.Operations.Count < 2) { return; } if (string.IsNullOrWhiteSpace(op.Name)) { return; } if (frequency.ContainsKey(op.Name)) { var error = new ValidationError( context.OriginalQuery, "5.1.1.1", DuplicateOperationNameMessage(op.Name), op); context.ReportError(error); } else { frequency[op.Name] = op.Name; } }); }); }
public EntityError Resolve(EntityManager em) { IsServerError = true; try { EntityType entityType = null; if (EntityTypeName != null) { var stName = StructuralType.ClrTypeNameToStructuralTypeName(EntityTypeName); entityType = MetadataStore.Instance.GetEntityType(stName); var ek = new EntityKey(entityType, KeyValues); Entity = em.FindEntityByKey(ek); } if (PropertyName != null) { PropertyName = MetadataStore.Instance.NamingConvention.ServerPropertyNameToClient(PropertyName); } if (Entity != null) { Property = entityType.GetProperty(PropertyName); var vc = new ValidationContext(this.Entity); vc.Property = this.Property; var veKey = (ErrorName ?? ErrorMessage) + (PropertyName ?? ""); var ve = new ValidationError(null, vc, ErrorMessage, veKey); ve.IsServerError = true; this.Entity.EntityAspect.ValidationErrors.Add(ve); } } catch (Exception e) { ErrorMessage = ( ErrorMessage ?? "") + ": Unable to Resolve this error: " + e.Message; } return this; }
public INodeVisitor Validate(ValidationContext context) { var variableNameDefined = new Dictionary<string, bool>(); return new EnterLeaveListener(_ => { _.Match<VariableDefinition>(varDef => variableNameDefined[varDef.Name] = true); _.Match<Operation>( enter: op => variableNameDefined = new Dictionary<string, bool>(), leave: op => { var usages = context.GetRecursiveVariables(op); usages.Apply(usage => { var varName = usage.Node.Name; bool found; if (!variableNameDefined.TryGetValue(varName, out found)) { var error = new ValidationError( context.OriginalQuery, "5.7.4", UndefinedVarMessage(varName, op.Name), usage.Node, op); context.ReportError(error); } }); }); }); }
public void TestInitialize() { node = new ConfigurationApplicationNode(ConfigurationApplicationFile.FromCurrentAppDomain()); message = "Test"; propertyInfo = node.GetType().GetProperty("ConfigurationFile"); error = new ValidationError(node, propertyInfo.Name, message); }
public INodeVisitor Validate(ValidationContext context) { var variableDefs = new List<VariableDefinition>(); return new EnterLeaveListener(_ => { _.Match<VariableDefinition>(def => variableDefs.Add(def)); _.Match<Operation>( enter: op => variableDefs = new List<VariableDefinition>(), leave: op => { var usages = context.GetRecursiveVariables(op).Select(usage => usage.Node.Name); variableDefs.Apply(variableDef => { var variableName = variableDef.Name; if (!usages.Contains(variableName)) { var error = new ValidationError(context.OriginalQuery, "5.7.5", UnusedVariableMessage(variableName, op.Name), variableDef); context.ReportError(error); } }); }); }); }
public INodeVisitor Validate(ValidationContext context) { var knownArgs = new Dictionary<string, Argument>(); return new EnterLeaveListener(_ => { _.Match<Field>(field => knownArgs = new Dictionary<string, Argument>()); _.Match<Directive>(field => knownArgs = new Dictionary<string, Argument>()); _.Match<Argument>(argument => { var argName = argument.Name; if (knownArgs.ContainsKey(argName)) { var error = new ValidationError(context.OriginalQuery, "5.3.2", DuplicateArgMessage(argName), knownArgs[argName], argument); context.ReportError(error); } else { knownArgs[argName] = argument; } }); }); }
public void OnField_WorksWithAllCommonCasing() { ValidationError fieldError = new ValidationError("", "1", ""); ValidationErrors errors = new ValidationErrors(); errors.AddError("country_name", fieldError); Assert.AreEqual(fieldError, errors.OnField("country_name")[0]); Assert.AreEqual(fieldError, errors.OnField("country-name")[0]); Assert.AreEqual(fieldError, errors.OnField("countryName")[0]); Assert.AreEqual(fieldError, errors.OnField("CountryName")[0]); }
/// <summary> /// Adds a new <b>ValidationError</b> to the collection of errors. /// </summary> /// <param name="error">The <b>ValidationError</b> to add.</param> public void AddError( ValidationError error) { if (error != null) { if (Errors == null) { Errors = new ValidationErrorCollection(); } Errors.Add(error); } }
private void PopulateSchemaId(ValidationError error) { Uri schemaId = Schema.KnownSchemas.Single(s => s.Schema == error.Schema).Id; error.SchemaId = schemaId; foreach (ValidationError validationError in error.ChildErrors) { PopulateSchemaId(validationError); } }
public override void Validate() { var value = Value.Trim(); double num; bool isNum = double.TryParse(value, out num); IsValid = isNum; if (!IsValid) { Error = new ValidationError(ValidationErrorCode.ERROR_NOT_NUMBER, "Value must be number"); } }
/// <summary> /// Creates a <see cref="ValidationError"/> and adds it to the collection. /// </summary> /// <param name="collection">The target collection to add to.</param> /// <param name="message">The associated message.</param> /// <param name="targetFieldKeys">The list of fields to flag with the message.</param> public static void Add(this ICollection<IError> collection, string errorKey, string message, params string[] targetFieldKeys) { foreach (var fieldKey in targetFieldKeys) { var err = new ValidationError(fieldKey, errorKey, message); if (!collection.Contains(err)) { collection.Add(new ValidationError(fieldKey, errorKey, message)); } } }
public void ShouldBuildAnElementFromErrors() { var error = new ValidationError("some error"); var errors = new ValidationErrors<ParentInput>().Add(x => x.Child, error); var elementProvider = new Testable(typeof(NodeProvider<ParentInput>)).Create(); var node = (NodeElement)elementProvider.With(errors).Build(); Assert.That(node.Id, Is.Empty); var childElement = (LeafElement)node.Elements["Child"]; Assert.That(childElement.Error, Is.EqualTo(error)); }
public INodeVisitor Validate(ValidationContext context) { var varDefMap = new Dictionary<string, VariableDefinition>(); return new EnterLeaveListener(_ => { _.Match<VariableDefinition>( varDefAst => varDefMap[varDefAst.Name] = varDefAst ); _.Match<Operation>( enter: op => varDefMap = new Dictionary<string, VariableDefinition>(), leave: op => { var usages = context.GetRecursiveVariables(op); usages.Apply(usage => { var varName = usage.Node.Name; VariableDefinition varDef; if (!varDefMap.TryGetValue(varName, out varDef)) { return; } if (varDef != null && usage.Type != null) { var varType = varDef.Type.GraphTypeFromType(context.Schema); if (varType != null && !effectiveType(varType, varDef).IsSubtypeOf(usage.Type, context.Schema)) { var error = new ValidationError( context.OriginalQuery, "5.7.6", BadVarPosMessage(varName, context.Print(varType), context.Print(usage.Type))); var source = new Source(context.OriginalQuery); var varDefPos = new Location(source, varDef.SourceLocation.Start); var usagePos = new Location(source, usage.Node.SourceLocation.Start); error.AddLocation(varDefPos.Line, varDefPos.Column); error.AddLocation(usagePos.Line, usagePos.Column); context.ReportError(error); } } }); } ); }); }
public void SerializeError() { ValidationError error = new ValidationError { LineNumber = 11, LinePosition = 5, Value = "A value!", Message = "A message!", Path = "sdf.sdf", ErrorType = ErrorType.MinimumLength, SchemaId = new Uri("test.xml", UriKind.RelativeOrAbsolute), SchemaBaseUri = new Uri("test.xml", UriKind.RelativeOrAbsolute), Schema = new JSchema { Type = JSchemaType.Number }, ChildErrors = { new ValidationError { Message = "Child message!" } } }; string json = JsonConvert.SerializeObject(error, Formatting.Indented); StringAssert.AreEqual(@"{ ""Message"": ""A message!"", ""LineNumber"": 11, ""LinePosition"": 5, ""Path"": ""sdf.sdf"", ""Value"": ""A value!"", ""SchemaId"": ""test.xml"", ""SchemaBaseUri"": ""test.xml"", ""ErrorType"": ""minLength"", ""ChildErrors"": [ { ""Message"": ""Child message!"", ""LineNumber"": 0, ""LinePosition"": 0, ""Path"": null, ""Value"": null, ""SchemaId"": null, ""SchemaBaseUri"": null, ""ErrorType"": ""none"", ""ChildErrors"": [] } ] }", json); }
public INodeVisitor Validate(ValidationContext context) { return new EnterLeaveListener(_ => { _.Match<FragmentSpread>(node => { var fragmentName = node.Name; var fragment = context.GetFragment(fragmentName); if (fragment == null) { var error = new ValidationError(context.OriginalQuery, "5.4.2.1", UnknownFragmentMessage(fragmentName), node); context.ReportError(error); } }); }); }
/// <summary> /// Returns a <see cref="bool"/> value indicating whether the resource is valid along with the associated /// collection of errors. /// </summary> /// <param name="resource">The resource.</param> /// <param name="errors">A read-only collection of the validation errors.</param> /// <returns>true if the resource is valid; otherwise, false.</returns> public virtual bool IsValid(object resource, out IReadOnlyCollection<ValidationError> errors) { if (resource == null || resource is DynamicObject || resource is JObject) { errors = new ValidationError[0]; return true; } var context = new ValidationContext(resource, null, null); var results = new List<ValidationResult>(); bool isValid = Validator.TryValidateObject(resource, context, results, true); errors = PopulateValidationErrors(results); return isValid; }
public void Should_execute_all_rules_and_aggregate_results() { var record1 = new ValidationError(string.Empty); var record2 = new ValidationError(string.Empty); var record3 = new ValidationError(string.Empty); var xmlDocument = new HtmlDocument(); var rule1 = MockRepository.GenerateStub<IHtmlRule>(); var rule2 = MockRepository.GenerateStub<IHtmlRule>(); var rule3 = MockRepository.GenerateStub<IHtmlRule>(); rule1.Stub(rule => rule.ValidateHtml(xmlDocument)).Return(new[] {record1}); rule2.Stub(rule => rule.ValidateHtml(xmlDocument)).Return(new ValidationError[0]); rule3.Stub(rule => rule.ValidateHtml(xmlDocument)).Return(new[] {record2, record3}); ValidationError[] errors = null; Assert.That(errors, Is.EqualTo(new[] {record1, record2, record3})); }
public INodeVisitor Validate(ValidationContext context) { var operationCount = context.Document.Operations.Count; return new EnterLeaveListener(_ => { _.Match<Operation>(op => { if (string.IsNullOrWhiteSpace(op.Name) && operationCount > 1) { var error = new ValidationError( context.OriginalQuery, "5.1.2.1", AnonOperationNotAloneMessage(), op); context.ReportError(error); } }); }); }
private void Field(GraphType type, Field field, ValidationContext context) { if (type == null) { return; } if (type.IsLeafType(context.Schema)) { if (field.SelectionSet != null && field.SelectionSet.Selections.Any()) { var error = new ValidationError(context.OriginalQuery, "5.2.3", NoSubselectionAllowedMessage(field.Name, context.Print(type)), field.SelectionSet); context.ReportError(error); } } else if(field.SelectionSet == null || !field.SelectionSet.Selections.Any()) { var error = new ValidationError(context.OriginalQuery, "5.2.3", RequiredSubselectionMessage(field.Name, context.Print(type)), field); context.ReportError(error); } }
public INodeVisitor Validate(ValidationContext context) { return new EnterLeaveListener(_ => { _.Match<Argument>(argAst => { var argDef = context.TypeInfo.GetArgument(); if (argDef == null) return; var type = context.Schema.FindType(argDef.Type); var errors = type.IsValidLiteralValue(argAst.Value, context.Schema).ToList(); if (errors.Any()) { var error = new ValidationError( context.OriginalQuery, "5.3.3.1", BadValueMessage(argAst.Name, type, context.Print(argAst.Value), errors), argAst); context.ReportError(error); } }); }); }
ValidationErrorEventArgs CreateValidationErrorEventArgs(ValidationError error, ValidationErrorEventAction action) { ConstructorInfo constructor = typeof(ValidationErrorEventArgs).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(ValidationError), typeof(ValidationErrorEventAction) }, null); return((ValidationErrorEventArgs)constructor.Invoke(new object[] { error, action })); }
private ValidationError AddValidationError(XmlNode n, ValidationErrorType type) { ValidationError ve=new ValidationError(n, type); AddValidationError(n, ve); return ve; }
internal override RuleExpressionInfo Validate(CodeExpression expression, RuleValidation validation, bool isWritten) { CodeArrayCreateExpression newParent = (CodeArrayCreateExpression)expression; if (isWritten) { ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.CannotWriteToExpression, new object[] { typeof(CodeObjectCreateExpression).ToString() }), 0x17a); item.UserData["ErrorObject"] = newParent; validation.Errors.Add(item); return(null); } if (newParent.CreateType == null) { ValidationError error2 = new ValidationError(Messages.NullTypeType, 0x53d); error2.UserData["ErrorObject"] = newParent; validation.Errors.Add(error2); return(null); } Type lhsType = validation.ResolveType(newParent.CreateType); if (lhsType == null) { return(null); } if (lhsType.IsArray) { ValidationError error3 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArrayTypeInvalid, new object[] { lhsType.Name }), 0x53d); error3.UserData["ErrorObject"] = newParent; validation.Errors.Add(error3); return(null); } try { if (!validation.PushParentExpression(newParent)) { return(null); } if (newParent.Size < 0) { ValidationError error4 = new ValidationError(Messages.ArraySizeInvalid, 0x53d); error4.UserData["ErrorObject"] = newParent; validation.Errors.Add(error4); return(null); } if (newParent.SizeExpression != null) { RuleExpressionInfo info = RuleExpressionWalker.Validate(validation, newParent.SizeExpression, false); if (info == null) { return(null); } if (((info.ExpressionType != typeof(int)) && (info.ExpressionType != typeof(uint))) && ((info.ExpressionType != typeof(long)) && (info.ExpressionType != typeof(ulong)))) { ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ArraySizeTypeInvalid, new object[] { info.ExpressionType.Name }), 0x53d); error5.UserData["ErrorObject"] = newParent; validation.Errors.Add(error5); return(null); } } bool flag = false; for (int i = 0; i < newParent.Initializers.Count; i++) { CodeExpression expression3 = newParent.Initializers[i]; if (expression3 == null) { ValidationError error6 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.MissingInitializer, new object[] { lhsType.Name }), 0x53d); error6.UserData["ErrorObject"] = newParent; validation.Errors.Add(error6); return(null); } RuleExpressionInfo info2 = RuleExpressionWalker.Validate(validation, expression3, false); if (info2 == null) { flag = true; } else { ValidationError error7; if (!RuleValidation.StandardImplicitConversion(info2.ExpressionType, lhsType, expression3, out error7)) { if (error7 != null) { error7.UserData["ErrorObject"] = newParent; validation.Errors.Add(error7); } error7 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InitializerMismatch, new object[] { i, lhsType.Name }), 0x545); error7.UserData["ErrorObject"] = newParent; validation.Errors.Add(error7); return(null); } } } if (flag) { return(null); } double size = -1.0; if (newParent.SizeExpression != null) { CodePrimitiveExpression sizeExpression = newParent.SizeExpression as CodePrimitiveExpression; if ((sizeExpression != null) && (sizeExpression.Value != null)) { size = (double)Executor.AdjustType(sizeExpression.Value.GetType(), sizeExpression.Value, typeof(double)); } if (newParent.Size > 0) { ValidationError error8 = new ValidationError(Messages.ArraySizeBoth, 0x53d); error8.UserData["ErrorObject"] = newParent; validation.Errors.Add(error8); return(null); } } else if (newParent.Size > 0) { size = newParent.Size; } if ((size >= 0.0) && (newParent.Initializers.Count > size)) { ValidationError error9 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InitializerCountMismatch, new object[] { newParent.Initializers.Count, size }), 0x545); error9.UserData["ErrorObject"] = newParent; validation.Errors.Add(error9); return(null); } } finally { validation.PopParentExpression(); } return(new RuleExpressionInfo(lhsType.MakeArrayType())); }
public virtual IHttpActionResult UpdateContent(string path, [FromBody] Dictionary <string, object> newProperties, EPiServer.DataAccess.SaveAction action = EPiServer.DataAccess.SaveAction.Save) { path = path ?? ""; var contentRef = FindContentReference(path); if (contentRef == ContentReference.EmptyReference) { return(NotFound()); } if (contentRef == ContentReference.RootPage) { return(BadRequestErrorCode("UPDATE_ROOT_NOT_ALLOWED")); } if (!TryGetCultureInfo(out string language, out CultureInfo cultureInfo)) { return(BadRequestInvalidLanguage(language)); } if (!_repo.TryGet(contentRef, cultureInfo, out IContent originalContent)) { return(NotFound()); } if (newProperties == null) { return(BadRequestErrorCode("BODY_EMPTY")); } foreach (String property in NonCreatingProperties) { if (newProperties.ContainsKey(property)) { newProperties.Remove(property); } } foreach (String property in NonUpdatingProperties) { if (newProperties.ContainsKey(property)) { newProperties.Remove(property); } } var content = (originalContent as IReadOnly).CreateWritableClone() as IContent; EPiServer.DataAccess.SaveAction saveaction = action; if (newProperties.ContainsKey("SaveAction") && ((string)newProperties["SaveAction"]) == "Publish") { saveaction = EPiServer.DataAccess.SaveAction.Publish; newProperties.Remove("SaveAction"); } if (newProperties.ContainsKey("SaveAction") && ((string)newProperties["SaveAction"]) == "RequestApproval") { saveaction = EPiServer.DataAccess.SaveAction.RequestApproval; newProperties.Remove("SaveAction"); } if (newProperties.ContainsKey("SaveAction") && ((string)newProperties["SaveAction"]) == "CheckIn") { saveaction = EPiServer.DataAccess.SaveAction.CheckIn; newProperties.Remove("SaveAction"); } IContent moveTo = null; if (newProperties.ContainsKey(MoveEntityToPropertyKey)) { if (!(newProperties[MoveEntityToPropertyKey] is string)) { return(BadRequestValidationErrors(ValidationError.InvalidType(MoveEntityToPropertyKey, typeof(string)))); } var moveToPath = (string)newProperties[MoveEntityToPropertyKey]; if (!moveToPath.StartsWith("/")) { return(BadRequestValidationErrors(ValidationError.CustomError(MoveEntityToPropertyKey, "FIELD_INVALID_FORMAT", $"{MoveEntityToPropertyKey} should start with a /"))); } if (!_repo.TryGet(FindContentReference(moveToPath.Substring(1)), out moveTo)) { return(BadRequestValidationErrors(ValidationError.CustomError(MoveEntityToPropertyKey, "TARGET_CONTAINER_NOT_FOUND", "The target container was not found"))); } newProperties.Remove(MoveEntityToPropertyKey); } if (newProperties.ContainsKey("Name")) { content.Name = newProperties["Name"].ToString(); newProperties.Remove("Name"); } // Store the new information in the object. var errors = UpdateContentProperties(newProperties, content); if (errors.Any()) { return(BadRequestValidationErrors(errors.ToArray())); } var validationErrors = _validationService.Validate(content); if (validationErrors.Any()) { return(BadRequestValidationErrors(validationErrors.Select(ValidationError.FromEpiserver).ToArray())); } if (!HasAccess(content, EPiServer.Security.AccessLevel.Edit | EPiServer.Security.AccessLevel.Publish)) { return(StatusCode(HttpStatusCode.Forbidden)); } if (moveTo != null) { if (!HasAccess(content, EPiServer.Security.AccessLevel.Read | EPiServer.Security.AccessLevel.Delete)) { return(StatusCode(HttpStatusCode.Forbidden)); } if (!HasAccess(moveTo, EPiServer.Security.AccessLevel.Create | EPiServer.Security.AccessLevel.Publish)) { return(StatusCode(HttpStatusCode.Forbidden)); } } //from here on we're going to try to save things to the database, we have tried to optimize the chance of succeeding above if (moveTo != null) { try { _repo.Move(contentRef, moveTo.ContentLink); } catch (ContentNotFoundException) { //even though we already check for this above, we still handle it here for cases that we might not have foreseen return(BadRequestValidationErrors(ValidationError.CustomError(MoveEntityToPropertyKey, "TARGET_CONTAINER_NOT_FOUND", "The target container was not found"))); } catch (AccessDeniedException) { //even though we already check for this above, we still handle it here for cases that we might not have foreseen return(StatusCode(HttpStatusCode.Forbidden)); } } try { var updatedReference = _repo.Save(content, saveaction); if (TryGetProject(out int projectId, out Project project)) { ProjectItem projectItem = new ProjectItem(projectId, content); _projectrepo.SaveItems(new ProjectItem[] { projectItem }); } return(Ok(new { reference = updatedReference.ToString() })); } catch (Exception) { if (moveTo != null) { //try to undo the move. We've tried using TransactionScope for this, but it doesn't play well with Episerver (caching, among other problems) _repo.Move(contentRef, originalContent.ParentLink); } throw; } }
protected override void Simpan() { var total = SumGrid(this._listOfItemPengeluaran); if (!(total > 0)) { MsgHelper.MsgWarning("Anda belum melengkapi inputan data produk !"); return; } if (!MsgHelper.MsgKonfirmasi("Apakah proses ingin dilanjutkan ?")) { return; } if (_isNewData) { _pengeluaran = new PengeluaranBiaya(); } _pengeluaran.pengguna_id = this._pengguna.pengguna_id; _pengeluaran.Pengguna = this._pengguna; _pengeluaran.nota = txtNota.Text; _pengeluaran.tanggal = dtpTanggal.Value; _pengeluaran.keterangan = txtKeterangan.Text; _pengeluaran.item_pengeluaran_biaya = this._listOfItemPengeluaran.Where(f => f.JenisPengeluaran != null).ToList(); if (!_isNewData) // update { _pengeluaran.item_pengeluaran_biaya_deleted = _listOfItemPengeluaranDeleted; } var result = 0; var validationError = new ValidationError(); using (new StCursor(Cursors.WaitCursor, new TimeSpan(0, 0, 0, 0))) { if (_isNewData) { result = _bll.Save(_pengeluaran, ref validationError); } else { result = _bll.Update(_pengeluaran, ref validationError); } if (result > 0) { Listener.Ok(this, _isNewData, _pengeluaran); _listOfItemPengeluaran.Clear(); _listOfItemPengeluaranDeleted.Clear(); this.Close(); } else { if (validationError.Message.Length > 0) { MsgHelper.MsgWarning(validationError.Message); base.SetFocusObject(validationError.PropertyName, this); } else { MsgHelper.MsgUpdateError(); } } } }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection validationErrors = base.Validate(manager, obj); InvokeWebServiceActivity invokeWebService = obj as InvokeWebServiceActivity; if (invokeWebService == null) { throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(InvokeWebServiceActivity).FullName), "obj"); } if (invokeWebService.ProxyClass == null) { ValidationError error = new ValidationError(SR.GetString(SR.Error_TypePropertyInvalid, "ProxyClass"), ErrorNumbers.Error_PropertyNotSet); error.PropertyName = "ProxyClass"; validationErrors.Add(error); } else { ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider)); if (typeProvider == null) { throw new InvalidOperationException(SR.GetString(SR.General_MissingService, typeof(ITypeProvider).FullName)); } Type proxyClassType = invokeWebService.ProxyClass; // Validate method if (invokeWebService.MethodName == null || invokeWebService.MethodName.Length == 0) { validationErrors.Add(ValidationError.GetNotSetValidationError("MethodName")); } else { MethodInfo methodInfo = proxyClassType.GetMethod(invokeWebService.MethodName); if (methodInfo == null) { ValidationError error = new ValidationError(SR.GetString(SR.Error_MethodNotExists, "MethodName", invokeWebService.MethodName), ErrorNumbers.Error_MethodNotExists); error.PropertyName = "MethodName"; validationErrors.Add(error); } else { ArrayList paramInfos = new ArrayList(methodInfo.GetParameters()); if (methodInfo.ReturnType != typeof(void)) { paramInfos.Add(methodInfo.ReturnParameter); } foreach (ParameterInfo paramInfo in paramInfos) { string paramName = paramInfo.Name; if (paramInfo.Position == -1) { paramName = "(ReturnValue)"; } object paramValue = null; if (invokeWebService.ParameterBindings.Contains(paramName)) { if (invokeWebService.ParameterBindings[paramName].IsBindingSet(WorkflowParameterBinding.ValueProperty)) { paramValue = invokeWebService.ParameterBindings[paramName].GetBinding(WorkflowParameterBinding.ValueProperty); } else { paramValue = invokeWebService.ParameterBindings[paramName].GetValue(WorkflowParameterBinding.ValueProperty); } } if (!invokeWebService.ParameterBindings.Contains(paramName) || paramValue == null) { ValidationError validationError = ValidationError.GetNotSetValidationError(paramName); if (InvokeWebServiceActivity.ReservedParameterNames.Contains(paramName)) { validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWebService.GetType(), paramName); } validationError.PropertyName = paramName; validationErrors.Add(validationError); } else { AccessTypes access = AccessTypes.Read; if (paramInfo.IsOut || paramInfo.IsRetval) { access = AccessTypes.Write; } else if (paramInfo.ParameterType.IsByRef) { access |= AccessTypes.Write; } ValidationErrorCollection variableErrors = ValidationHelpers.ValidateProperty(manager, invokeWebService, paramValue, new PropertyValidationContext(invokeWebService.ParameterBindings[paramName], null, paramName), new BindValidationContext(paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType, access)); if (InvokeWebServiceActivity.ReservedParameterNames.Contains(paramName)) { foreach (ValidationError validationError in variableErrors) { validationError.PropertyName = ParameterInfoBasedPropertyDescriptor.GetParameterPropertyName(invokeWebService.GetType(), paramName); } } validationErrors.AddRange(variableErrors); } } if (invokeWebService.ParameterBindings.Count > paramInfos.Count) { validationErrors.Add(new ValidationError(SR.GetString(SR.Warning_AdditionalBindingsFound), ErrorNumbers.Warning_AdditionalBindingsFound, true)); } } } } return(validationErrors); }
/// <summary> /// Initializes a new instance of the <see cref="BraintreeApiException"/> class. /// </summary> /// <param name="validationError"> /// The validation error. /// </param> public BraintreeApiException(ValidationError validationError) : this(new[] { validationError}) { }
public void AddResult(string actionName, ValidationError error, ValidationOutcome?outcome = null) { this[actionName].AddResults(new ValidationError[] { error }, outcome); }
protected override void Simpan() { if (this._supplier == null || txtSupplier.Text.Length == 0) { MsgHelper.MsgWarning("'Supplier' tidak boleh kosong !"); txtSupplier.Focus(); return; } var total = SumGrid(this._listOfItemBeli); if (!(total > 0)) { MsgHelper.MsgWarning("Anda belum melengkapi inputan data produk !"); return; } if (rdoKredit.Checked) { if (!DateTimeHelper.IsValidRangeTanggal(dtpTanggal.Value, dtpTanggalTempo.Value)) { MsgHelper.MsgNotValidRangeTanggal(); return; } } if (!MsgHelper.MsgKonfirmasi("Apakah proses ingin dilanjutkan ?")) { return; } if (_isNewData) { _beli = new BeliProduk(); } _beli.pengguna_id = this._pengguna.pengguna_id; _beli.Pengguna = this._pengguna; _beli.supplier_id = this._supplier.supplier_id; _beli.Supplier = this._supplier; _beli.nota = txtNota.Text; _beli.tanggal = dtpTanggal.Value; _beli.tanggal_tempo = DateTimeHelper.GetNullDateTime(); _beli.is_tunai = rdoTunai.Checked; if (rdoKredit.Checked) // pembelian kredit { _beli.tanggal_tempo = dtpTanggalTempo.Value; } _beli.ppn = NumberHelper.StringToDouble(txtPPN.Text); _beli.diskon = NumberHelper.StringToDouble(txtDiskon.Text); _beli.keterangan = txtKeterangan.Text; _beli.item_beli = this._listOfItemBeli.Where(f => f.Produk != null).ToList(); foreach (var item in _beli.item_beli) { if (!(item.harga > 0)) { item.harga = item.Produk.harga_beli; } } if (!_isNewData) // update { _beli.item_beli_deleted = _listOfItemBeliDeleted; } var result = 0; var validationError = new ValidationError(); using (new StCursor(Cursors.WaitCursor, new TimeSpan(0, 0, 0, 0))) { if (_isNewData) { result = _bll.Save(_beli, ref validationError); } else { result = _bll.Update(_beli, ref validationError); } if (result > 0) { try { if (chkCetakNotaBeli.Checked) { CetakNota(_beli.beli_produk_id); } } catch { } Listener.Ok(this, _isNewData, _beli); _supplier = null; _listOfItemBeli.Clear(); _listOfItemBeliDeleted.Clear(); this.Close(); } else { if (validationError.Message.NullToString().Length > 0) { MsgHelper.MsgWarning(validationError.Message); base.SetFocusObject(validationError.PropertyName, this); } else { MsgHelper.MsgUpdateError(); } } } }
/// <summary> /// Tests whether a value is valid against a single <see cref="ValidationAttribute"/> using the <see cref="ValidationContext"/>. /// </summary> /// <param name="value">The value to be tested for validity.</param> /// <param name="validationContext">Describes the property member to validate.</param> /// <param name="attribute">The validation attribute to test.</param> /// <param name="validationError">The validation error that occurs during validation. Will be <c>null</c> when the return value is <c>true</c>.</param> /// <returns><c>true</c> if the value is valid.</returns> /// <exception cref="ArgumentNullException">When <paramref name="validationContext"/> is null.</exception> private static bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out ValidationError validationError) { if (validationContext == null) { throw new ArgumentNullException("validationContext"); } ValidationResult validationResult = attribute.GetValidationResult(value, validationContext); if (validationResult != ValidationResult.Success) { validationError = new ValidationError(attribute, value, validationResult); return false; } validationError = null; return true; }
public void RaiseError(IFormattable message, ErrorType errorType, JSchema schema, object?value, IList <ValidationError>?childErrors) { ValidationError error = CreateError(message, errorType, schema, value, childErrors); RaiseError(error); }
protected ValidationError CreateError(IFormattable message, ErrorType errorType, JSchema schema, object?value, IList <ValidationError>?childErrors, IJsonLineInfo?lineInfo, string path) { ValidationError error = ValidationError.CreateValidationError(message, errorType, schema, null, value, childErrors, lineInfo, path); return(error); }
public AssemblyError(int lineNumber, LineSection lineSection, int causeStartIndex, int causeLength, ValidationError error) : base(Severity.Error, lineNumber, lineSection, causeStartIndex, causeLength, error) { }
/// <summary> /// Overriden. Compares if a <see cref="ValidationError"/> instance is equal to this /// <see cref="ValidationError"/> instance. /// </summary> /// <param name="obj"></param> /// <returns></returns> public bool Equals(ValidationError obj) { return Equals(obj.Message, Message) && Equals(obj.Property, Property); }
private void DefaultLogMessage(ValidationError msg) { // Empty method }
internal override bool Validate(RuleValidation validation) { bool flag = false; RuleExpressionInfo info = null; if (this.assignStatement.Left == null) { ValidationError item = new ValidationError(Messages.NullAssignLeft, 0x541); item.UserData["ErrorObject"] = this.assignStatement; validation.Errors.Add(item); } else { info = validation.ExpressionInfo(this.assignStatement.Left); if (info == null) { info = RuleExpressionWalker.Validate(validation, this.assignStatement.Left, true); } } RuleExpressionInfo info2 = null; if (this.assignStatement.Right == null) { ValidationError error2 = new ValidationError(Messages.NullAssignRight, 0x543); error2.UserData["ErrorObject"] = this.assignStatement; validation.Errors.Add(error2); } else { info2 = RuleExpressionWalker.Validate(validation, this.assignStatement.Right, false); } if ((info == null) || (info2 == null)) { return(flag); } Type expressionType = info2.ExpressionType; Type lhsType = info.ExpressionType; if (lhsType == typeof(NullLiteral)) { ValidationError error3 = new ValidationError(Messages.NullAssignLeft, 0x542); error3.UserData["ErrorObject"] = this.assignStatement; validation.Errors.Add(error3); return(false); } if (lhsType != expressionType) { ValidationError error = null; if (!RuleValidation.TypesAreAssignable(expressionType, lhsType, this.assignStatement.Right, out error)) { if (error == null) { error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, new object[] { RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(lhsType) }), 0x545); } error.UserData["ErrorObject"] = this.assignStatement; validation.Errors.Add(error); return(flag); } } return(true); }
protected override string FormatErrorMessage(ValidationError error) { return(FormatErrorMessage(Errors.ResourceManager, Errors.Culture, error) ?? base.FormatErrorMessage(error)); }
private static void ProcessActivity(ChildActivity childActivity, ref ChildActivity nextActivity, ref Stack <ChildActivity> activitiesRemaining, ActivityCallStack parentChain, ref IList <ValidationError> validationErrors, ProcessActivityTreeOptions options, ProcessActivityCallback callback) { Activity element = childActivity.Activity; IList <Constraint> runtimeConstraints = element.RuntimeConstraints; IList <ValidationError> list2 = null; if (!element.HasStartedCachingMetadata) { element.MemberOf.AddMember(element); element.InternalCacheMetadata(options.CreateEmptyBindings, ref list2); ActivityValidationServices.ValidateArguments(element, element.Parent == null, ref list2); ActivityLocationReferenceEnvironment environment = null; ActivityLocationReferenceEnvironment environment2 = new ActivityLocationReferenceEnvironment(element.HostEnvironment) { InternalRoot = element }; int nextEnvironmentId = 0; ProcessChildren(element, element.Children, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref list2); ProcessChildren(element, element.ImportedChildren, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref list2); ProcessChildren(element, element.ImplementationChildren, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref list2); ProcessArguments(element, element.RuntimeArguments, true, ref environment2, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2); ProcessVariables(element, element.RuntimeVariables, ActivityCollectionType.Public, true, ref environment, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2); ProcessVariables(element, element.ImplementationVariables, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref environment2, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref list2); if (element.HandlerOf != null) { for (int i = 0; i < element.HandlerOf.RuntimeDelegateArguments.Count; i++) { RuntimeDelegateArgument argument = element.HandlerOf.RuntimeDelegateArguments[i]; DelegateArgument boundArgument = argument.BoundArgument; if ((boundArgument != null) && boundArgument.InitializeRelationship(element, ref list2)) { boundArgument.Id = nextEnvironmentId; nextEnvironmentId++; } } } if (environment == null) { element.PublicEnvironment = new ActivityLocationReferenceEnvironment(element.GetParentEnvironment()); } else { if (environment.Parent == null) { environment.InternalRoot = element; } element.PublicEnvironment = environment; } element.ImplementationEnvironment = environment2; ProcessDelegates(element, element.Delegates, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref list2); ProcessDelegates(element, element.ImportedDelegates, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref list2); ProcessDelegates(element, element.ImplementationDelegates, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref list2); if (callback != null) { callback(childActivity, parentChain); } if (list2 != null) { Activity activity2; if (validationErrors == null) { validationErrors = new List <ValidationError>(); } string str = ActivityValidationServices.GenerateValidationErrorPrefix(childActivity.Activity, parentChain, out activity2); for (int j = 0; j < list2.Count; j++) { ValidationError item = list2[j]; item.Source = activity2; item.Id = activity2.Id; if (!string.IsNullOrEmpty(str)) { item.Message = str + item.Message; } validationErrors.Add(item); } list2 = null; } if (options.StoreTempViolations && (validationErrors != null)) { childActivity.Activity.SetTempValidationErrorCollection(validationErrors); validationErrors = null; } } else { SetupForProcessing(element.Children, true, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.ImportedChildren, false, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.RuntimeArguments, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.RuntimeVariables, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.Delegates, true, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.ImportedDelegates, false, ref nextActivity, ref activitiesRemaining); if (!options.SkipPrivateChildren) { SetupForProcessing(element.ImplementationChildren, true, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.ImplementationDelegates, true, ref nextActivity, ref activitiesRemaining); SetupForProcessing(element.ImplementationVariables, ref nextActivity, ref activitiesRemaining); } if ((callback != null) && !options.OnlyCallCallbackForDeclarations) { callback(childActivity, parentChain); } if (childActivity.Activity.HasTempViolations && !options.StoreTempViolations) { childActivity.Activity.TransferTempValidationErrors(ref validationErrors); } } if ((!options.SkipConstraints && parentChain.WillExecute) && (childActivity.CanBeExecuted && (runtimeConstraints.Count > 0))) { ActivityValidationServices.RunConstraints(childActivity, parentChain, runtimeConstraints, options, false, ref validationErrors); } }
public ValidationResult(ValidationError error, bool isValid) { this.Error = error; this.IsValid = isValid; }
public void AddError(ValidationError validationError) { _errors.Add(validationError); }
private void DiscoverInternal(JSchema schema, string latestPath) { if (schema.Reference != null) { return; } if (_knownSchemas.Any(s => s.Schema == schema)) { return; } Uri newScopeId; string scopePath = latestPath; Uri schemaKnownId = GetSchemaIdAndNewScopeId(schema, ref scopePath, out newScopeId); // check whether a schema with the resolved id is already known // this will be hit when a schema contains duplicate ids or references a schema with a duplicate id bool existingSchema = _knownSchemas.Any(s => UriComparer.Instance.Equals(s.Id, schemaKnownId)); #if DEBUG if (_knownSchemas.Any(s => s.Schema == schema)) { throw new InvalidOperationException("Schema with id '{0}' already a known schema.".FormatWith(CultureInfo.InvariantCulture, schemaKnownId)); } #endif // add schema to known schemas whether duplicate or not to avoid multiple errors // the first schema with a duplicate id will be used _knownSchemas.Add(new KnownSchema(schemaKnownId, schema, _state)); if (existingSchema) { if (ValidationErrors != null) { ValidationError error = ValidationError.CreateValidationError("Duplicate schema id '{0}' encountered.".FormatWith(CultureInfo.InvariantCulture, schemaKnownId.OriginalString), ErrorType.Id, schema, null, schemaKnownId, null, schema, schema.Path); ValidationErrors.Add(error); } return; } _pathStack.Push(new SchemaPath(newScopeId, scopePath)); // discover should happen in the same order as writer except extension data (e.g. definitions) if (schema._extensionData != null) { foreach (KeyValuePair <string, JToken> valuePair in schema._extensionData) { DiscoverTokenSchemas(EscapePath(valuePair.Key), valuePair.Value); } } DiscoverSchema(Constants.PropertyNames.AdditionalProperties, schema.AdditionalProperties); DiscoverSchema(Constants.PropertyNames.AdditionalItems, schema.AdditionalItems); DiscoverDictionarySchemas(Constants.PropertyNames.Properties, schema._properties); DiscoverDictionarySchemas(Constants.PropertyNames.PatternProperties, schema._patternProperties); DiscoverDictionarySchemas(Constants.PropertyNames.Dependencies, schema._dependencies); DiscoverArraySchemas(Constants.PropertyNames.Items, schema._items); DiscoverArraySchemas(Constants.PropertyNames.AllOf, schema._allOf); DiscoverArraySchemas(Constants.PropertyNames.AnyOf, schema._anyOf); DiscoverArraySchemas(Constants.PropertyNames.OneOf, schema._oneOf); DiscoverSchema(Constants.PropertyNames.Not, schema.Not); _pathStack.Pop(); }
public virtual IHttpActionResult CreateContent(string path, [FromBody] Dictionary <string, object> contentProperties, EPiServer.DataAccess.SaveAction action = EPiServer.DataAccess.SaveAction.Save) { path = path ?? ""; var parentContentRef = FindContentReference(path); if (parentContentRef == ContentReference.EmptyReference) { return(NotFound()); } if (!ReferenceExists(parentContentRef)) { return(NotFound()); } // Instantiate content of named type. if (contentProperties == null) { return(BadRequestErrorCode("BODY_EMPTY")); } foreach (String property in NonCreatingProperties) { if (contentProperties.ContainsKey(property)) { contentProperties.Remove(property); } } object contentTypeString; if (!(contentProperties.TryGetValue("ContentType", out contentTypeString) || contentProperties.TryGetValue("__EpiserverContentType", out contentTypeString))) { return(BadRequestValidationErrors(ValidationError.Required("ContentType"))); } if (contentProperties.ContainsKey("ContentType")) { contentProperties.Remove("ContentType"); } if (contentProperties.ContainsKey("__EpiserverContentType")) { contentProperties.Remove("__EpiserverContentType"); } if (!(contentTypeString is string)) { return(BadRequestValidationErrors(ValidationError.InvalidType("ContentType", typeof(string)))); } // Check ContentType. ContentType contentType = FindEpiserverContentType(contentTypeString); if (contentType == null) { return(BadRequestValidationErrors(ValidationError.CustomError("ContentType", "CONTENT_TYPE_INVALID", $"Could not find contentType {contentTypeString}"))); } if (!contentProperties.TryGetValue("Name", out object nameValue)) { return(BadRequestValidationErrors(ValidationError.Required("Name"))); } contentProperties.Remove("Name"); if (!(nameValue is string)) { return(BadRequestValidationErrors(ValidationError.InvalidType("Name", typeof(string)))); } EPiServer.DataAccess.SaveAction saveaction = action; if (contentProperties.ContainsKey("SaveAction") && (string)contentProperties["SaveAction"] == "Publish") { saveaction = EPiServer.DataAccess.SaveAction.Publish; contentProperties.Remove("SaveAction"); } if (contentProperties.ContainsKey("SaveAction") && (string)contentProperties["SaveAction"] == "RequestApproval") { saveaction = EPiServer.DataAccess.SaveAction.RequestApproval; contentProperties.Remove("SaveAction"); } if (contentProperties.ContainsKey("SaveAction") && ((string)contentProperties["SaveAction"]) == "CheckIn") { saveaction = EPiServer.DataAccess.SaveAction.CheckIn; contentProperties.Remove("SaveAction"); } // Create content. IContent content; CultureInfo cultureInfo = null; // Check if a Language tag is set. if (contentProperties.TryGetValue("__EpiserverCurrentLanguage", out object languageValue)) { if (!(languageValue is string)) { return(BadRequestValidationErrors(ValidationError.InvalidType("__EpiserverCurrentLanguage", typeof(string)))); } if (!TryGetCultureInfo((string)languageValue, out cultureInfo)) { if (cultureInfo == null || !GetLanguages().Any(ci => ci.TwoLetterISOLanguageName == cultureInfo.TwoLetterISOLanguageName)) { return(BadRequestInvalidLanguage(languageValue.ToString())); } cultureInfo = new CultureInfo(cultureInfo.TwoLetterISOLanguageName); } if (!GetLanguages().Any(ci => ci.TwoLetterISOLanguageName == cultureInfo.TwoLetterISOLanguageName)) { return(BadRequestInvalidLanguage(languageValue.ToString())); } cultureInfo = new CultureInfo(cultureInfo.TwoLetterISOLanguageName); if (_repo.TryGet <IContent>(parentContentRef, cultureInfo, out IContent parent)) { return(BadRequestLanguageBranchExists(parent, cultureInfo.TwoLetterISOLanguageName)); } content = _repo.CreateLanguageBranch <IContent>(parentContentRef, cultureInfo); } else { content = _repo.GetDefault <IContent>(parentContentRef, contentType.ID); } if (contentProperties.ContainsKey("__EpiserverCurrentLanguage")) { contentProperties.Remove("__EpiserverCurrentLanguage"); } content.Name = (string)nameValue; // Set all the other values. var errors = UpdateContentProperties(contentProperties, content); if (errors.Any()) { return(BadRequestValidationErrors(errors.ToArray())); } var validationErrors = _validationService.Validate(content); if (validationErrors.Any()) { return(BadRequestValidationErrors(validationErrors.Select(ValidationError.FromEpiserver).ToArray())); } // Save the reference with the requested save action. try { var createdReference = _repo.Save(content, saveaction); if (TryGetProject(out int projectId, out Project project)) { ProjectItem projectItem = new ProjectItem(projectId, content); _projectrepo.SaveItems(new ProjectItem[] { projectItem }); } return(Created(path, new { reference = createdReference.ID, __EpiserverCurrentLanguage = cultureInfo })); } catch (AccessDeniedException) { return(StatusCode(HttpStatusCode.Forbidden)); } catch (EPiServerException) { return(BadRequestValidationErrors(ValidationError.TypeCannotBeUsed("ContentType", contentType.Name, _repo.Get <IContent>(parentContentRef).GetOriginalType().Name))); } }
/// <summary> /// Tests whether a value is valid against a single <see cref="ValidationAttribute"/> using the <see cref="ValidationContext"/>. /// </summary> /// <param name="value">The value to be tested for validity.</param> /// <param name="validationContext">Describes the property member to validate.</param> /// <param name="attribute">The validation attribute to test.</param> /// <param name="validationError">The validation error that occurs during validation. Will be <c>null</c> when the return value is <c>true</c>.</param> /// <returns><c>true</c> if the value is valid.</returns> /// <exception cref="ArgumentNullException">When <paramref name="validationContext"/> is null.</exception> private static bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out ValidationError validationError) { if (validationContext == null) { throw new ArgumentNullException("validationContext"); } ValidationResult validationResult = attribute.GetValidationResult(value, validationContext); if (validationResult != ValidationResult.Success) { validationError = new ValidationError(attribute, value, validationResult); return(false); } validationError = null; return(true); }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { if (manager == null) { throw new ArgumentNullException("manager"); } if (manager.Context == null) { throw new InvalidOperationException(Messages.ContextStackMissing); } ValidationErrorCollection validationErrors = base.Validate(manager, obj); RuleConditionReference declarativeCondition = obj as RuleConditionReference; if (declarativeCondition == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, typeof(RuleConditionReference).FullName, "obj"); throw new ArgumentException(message, "obj"); } Activity activity = manager.Context[typeof(Activity)] as Activity; if (activity == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(Activity).Name); throw new InvalidOperationException(message); } PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext; if (validationContext == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(PropertyValidationContext).Name); throw new InvalidOperationException(message); } if (!string.IsNullOrEmpty(declarativeCondition.ConditionName)) { RuleDefinitions rules = null; RuleConditionCollection conditionDefinitions = null; CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity); if (declaringActivity == null) { declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity; } if (activity.Site != null) { rules = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity); } else { rules = ConditionHelper.Load_Rules_RT(declaringActivity); } if (rules != null) { conditionDefinitions = rules.Conditions; } if (conditionDefinitions == null || !conditionDefinitions.Contains(declarativeCondition.ConditionName)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, declarativeCondition.ConditionName); ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_ConditionNotFound); validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName"; validationErrors.Add(validationError); } else { RuleCondition actualCondition = conditionDefinitions[declarativeCondition.ConditionName]; ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider)); IDisposable localContextScope = (WorkflowCompilationContext.Current == null ? WorkflowCompilationContext.CreateScope(manager) : null); try { RuleValidation ruleValidator = new RuleValidation(activity, typeProvider, WorkflowCompilationContext.Current.CheckTypes); actualCondition.Validate(ruleValidator); ValidationErrorCollection actualConditionErrors = ruleValidator.Errors; if (actualConditionErrors.Count > 0) { string expressionPropertyName = GetFullPropertyName(manager); string genericErrorMsg = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionExpression, expressionPropertyName); int errorNumber = ErrorNumbers.Error_InvalidConditionExpression; if (activity.Site != null) { ValidationError validationError = new ValidationError(genericErrorMsg, errorNumber); validationError.PropertyName = expressionPropertyName + "." + "Expression"; validationErrors.Add(validationError); } else { foreach (ValidationError actualError in actualConditionErrors) { ValidationError validationError = new ValidationError(genericErrorMsg + " " + actualError.ErrorText, errorNumber); validationError.PropertyName = expressionPropertyName + "." + "Expression"; validationErrors.Add(validationError); } } } // Test duplicates foreach (RuleCondition definition in conditionDefinitions) { if (definition.Name == declarativeCondition.ConditionName && definition != actualCondition) { string message = string.Format(CultureInfo.CurrentCulture, Messages.DuplicateConditions, declarativeCondition.ConditionName); ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_DuplicateConditions); validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName"; validationErrors.Add(validationError); } } } finally { if (localContextScope != null) { localContextScope.Dispose(); } } } } else { string message = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionName, "ConditionName"); ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_InvalidConditionName); validationError.PropertyName = GetFullPropertyName(manager) + "." + "ConditionName"; validationErrors.Add(validationError); } return(validationErrors); }
public static Failure ValidationError(ValidationError validationError) { return(new ValidationFailure(validationError)); }
public void ProcessRawSegment(string name, string[] content, int rowPos, string compositeSeparator) { List <AllowedEntitity> allowedEntities = GetNextAllowedEntities(_currentLoopDef); if (allowedEntities.All(e => e.Entity.EdiName != name)) { string expected = string.Join(", ", allowedEntities.Select(e => e.Entity.Name).ToList()); string msgPart = allowedEntities.Count > 1 ? "Expected one of" : "Expected"; ValidationError err = new ValidationError() { SegmentPos = rowPos, SegmentName = name, Message = $"Unexpected Segment. {msgPart} {expected}. Found {name}." }; _trans.ValidationErrors.Add(err); return; } AllowedEntitity ae = allowedEntities.FirstOrDefault(e => e.Entity.EdiName == name); if (ae?.Entity is MapSegment) { ae.Entity.OccuredTimes++; _currentLoopDef = ae.LoopContext; _currentLoopDef.CurrentPos = _currentLoopDef.Content.IndexOf(ae.Entity); while (((MapLoop)_currentLoopInstance.Definition) != ae.LoopContext && _currentLoopInstance.Parent != null) { _currentLoopInstance = _currentLoopInstance.Parent; } _currentLoopInstance.Content.Add(ProcessSegment(ae.Entity, content, rowPos, compositeSeparator, _trans)); } else if (ae?.Entity is MapLoop) { //find loop definition in map and reset counters ae.LoopContext.CurrentPos = ae.LoopContext.Content.IndexOf(ae.Entity); _currentLoopDef = (MapLoop)ae.Entity; _currentLoopDef.CurrentPos = 0; _currentLoopDef.OccuredTimes++; _currentLoopDef.Content.ForEach(c => c.OccuredTimes = 0); EdiLoop newLoop; if (name == "HL") { int hl01; int hl02; int.TryParse(content[1], out hl01); bool res02 = int.TryParse(content[2], out hl02); if (hl01 > 1 && res02) { FindParentHlLoopContext(hl02); } else { FindParentLoopContext(ae.LoopContext); } newLoop = new EdiHlLoop(ae.Entity, _currentLoopInstance, hl01, (res02 ? hl02 : (int?)null)); } else { FindParentLoopContext(ae.LoopContext); newLoop = new EdiLoop(ae.Entity, _currentLoopInstance); } _currentLoopInstance.Content.Add(newLoop); _currentLoopInstance = newLoop; ProcessRawSegment(name, content, rowPos, compositeSeparator); } }
protected override void Simpan() { if (this._customer == null || txtCustomer.Text.Length == 0) { MsgHelper.MsgWarning("'Customer' tidak boleh kosong !"); txtCustomer.Focus(); return; } var total = SumGrid(this._listOfItemPembayaranPiutang); if (!(total > 0)) { MsgHelper.MsgWarning("Anda belum melengkapi inputan data pembayaran !"); return; } if (!MsgHelper.MsgKonfirmasi("Apakah proses ingin dilanjutkan ?")) { return; } if (_isNewData) { _pembayaranPiutang = new PembayaranPiutangProduk(); } _pembayaranPiutang.pengguna_id = this._pengguna.pengguna_id; _pembayaranPiutang.Pengguna = this._pengguna; _pembayaranPiutang.customer_id = this._customer.customer_id; _pembayaranPiutang.Customer = this._customer; _pembayaranPiutang.nota = txtNota.Text; _pembayaranPiutang.tanggal = dtpTanggal.Value; _pembayaranPiutang.keterangan = txtKeterangan.Text; _pembayaranPiutang.item_pembayaran_piutang = this._listOfItemPembayaranPiutang.Where(f => f.JualProduk != null).ToList(); if (!_isNewData) // update { _pembayaranPiutang.item_pembayaran_piutang_deleted = _listOfItemPembayaranPiutangDeleted.ToList(); } var result = 0; var validationError = new ValidationError(); using (new StCursor(Cursors.WaitCursor, new TimeSpan(0, 0, 0, 0))) { if (_isNewData) { result = _bll.Save(_pembayaranPiutang, false, ref validationError); } else { result = _bll.Update(_pembayaranPiutang, false, ref validationError); } if (result > 0) { Listener.Ok(this, _isNewData, _pembayaranPiutang); _customer = null; _listOfItemPembayaranPiutang.Clear(); _listOfItemPembayaranPiutangDeleted.Clear(); this.Close(); } else { if (validationError.Message.NullToString().Length > 0) { MsgHelper.MsgWarning(validationError.Message); base.SetFocusObject(validationError.PropertyName, this); } else { MsgHelper.MsgUpdateError(); } } } }
public void AddError(ValidationError error) { this.ValidationErrors.AddIfNotExists(error.Title, () => new List <ValidationError>()); this.ValidationErrors[error.Title].Add(error); }
public static bool TryGenerateLinqDelegate <TOperand, TResult>(ExpressionType operatorType, out Func <TOperand, TResult> operation, out ValidationError validationError) { operation = null; validationError = null; ParameterExpression operandParameter = Expression.Parameter(typeof(TOperand), "operand"); try { UnaryExpression unaryExpression = Expression.MakeUnary(operatorType, operandParameter, typeof(TResult)); Expression expressionToCompile = OperatorPermissionHelper.InjectReflectionPermissionIfNecessary(unaryExpression.Method, unaryExpression); Expression <Func <TOperand, TResult> > lambdaExpression = Expression.Lambda <Func <TOperand, TResult> >(expressionToCompile, operandParameter); operation = lambdaExpression.Compile(); return(true); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } validationError = new ValidationError(e.Message); return(false); } }
public ErrorDescriptor(IViewModelDependencies dependencies, IZetboxContext dataCtx, WorkspaceViewModel parent, ValidationError error) : base(dependencies, dataCtx, parent) { this._error = error; this._workspace = parent; }
public static ResponseStatus ToResponseStatus(this ValidationError validationException) { return(ResponseStatusUtils.CreateResponseStatus(validationException.ErrorCode, validationException.Message, validationException.Violations)); }
public BadRequestException(ValidationError error) { this.Error = error; }
private void LoginBTN_Clicked(object sender, RoutedEventArgs e) { Button btn = sender as Button; MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndeterminate(btn, true); MaterialDesignThemes.Wpf.ButtonProgressAssist.SetValue(btn, -1); MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndicatorVisible(btn, true); btn.IsEnabled = false; SignupBTN.IsEnabled = false; bool EverythingFine = true; if (String.IsNullOrEmpty(UsernameBox.Text)) { UsernameBox.GetBindingExpression(TextBox.TextProperty); ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), UsernameBox.GetBindingExpression(TextBox.TextProperty)); validationError.ErrorContent = "Field is required."; Validation.MarkInvalid( UsernameBox.GetBindingExpression(TextBox.TextProperty), validationError); EverythingFine = false; } else { Validation.ClearInvalid(UsernameBox.GetBindingExpression(TextBox.TextProperty)); } if (String.IsNullOrEmpty(PasswordBox.Password)) { PasswordBox.GetBindingExpression(TextBox.TextProperty); ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty)); validationError.ErrorContent = "Field is required."; Validation.MarkInvalid( PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty), validationError); EverythingFine = false; } else if (PasswordBox.Password.Length < 1) { PasswordBox.GetBindingExpression(TextBox.TextProperty); ValidationError validationError = new ValidationError(new NotEmptyValidationRule(), PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty)); validationError.ErrorContent = "At least 8 characters."; Validation.MarkInvalid( PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty), validationError); EverythingFine = false; } else { Validation.ClearInvalid(PasswordBox.GetBindingExpression(PasswordBox.DataContextProperty)); } if (EverythingFine) { LoginRequest loginRequest = new LoginRequest(); loginRequest.username = UsernameBox.Text; loginRequest.password = PasswordBox.Password; app.communicator.SocketSendReceive(JsonSerializer.serializeRequest(loginRequest, Constants.LOGIN_REQUEST_CODE)).ContinueWith(task => { ResponseInfo response = task.Result; LoginResponse loginResponse = JsonDeserializer.deserializeResponse <LoginResponse>(response.buffer); switch (loginResponse.status) { case Constants.LOGIN_SUCCESS: MyMessageQueue.Enqueue("Sign in Successfully!"); this.Dispatcher.Invoke(() => { app.username = UsernameBox.Text; NavigationService ns = NavigationService.GetNavigationService(this); ns.Navigate(new Uri("Menu.xaml", UriKind.Relative)); }); break; case Constants.LOGIN_INCORRECT_PASSWORD: MyMessageQueue.Enqueue("Incorrect password."); break; case Constants.LOGIN_USERNAME_NOT_EXIST: MyMessageQueue.Enqueue("Username not exist."); break; case Constants.LOGIN_UNEXPECTED_ERR: MyMessageQueue.Enqueue("There was an unexpected error."); break; case Constants.LOGIN_ALREADY_ONLINE: MyMessageQueue.Enqueue("This Username is already online."); break; } this.Dispatcher.Invoke(() => { ButtonProgressAssist.SetIsIndeterminate(btn, false); ButtonProgressAssist.SetIsIndicatorVisible(btn, false); btn.IsEnabled = true; SignupBTN.IsEnabled = true; }); }); } else { MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndeterminate(btn, false); MaterialDesignThemes.Wpf.ButtonProgressAssist.SetIsIndicatorVisible(btn, false); btn.IsEnabled = true; SignupBTN.IsEnabled = true; } }
private ModelValidationResult Convert(ValidationError validationError, Type modelType) { return new ModelValidationResult {MemberName = validationError.TargetMemberMetadata.GetRootRelativePath(modelType), Message = validationError.Message}; }
private static string GetPropertyName(ValidationError error) { return(error.Path.Split('.').LastOrDefault()); }
public LeafElement(string id, string value, ValidationError error) { _id = id; _error = error; _value = value; }
public ValidationInfo(ValidationError error) { ErrorContent = error.ErrorContent; Exception = error.Exception; IsException = error.Exception != null; }