protected override void OnInitialized() { base.OnInitialized(); _editContext = new EditContext(Model); if (FormProvider != null) { FormProvider.AddForm(this); } if (OnFieldChanged.HasDelegate) { _editContext.OnFieldChanged += OnFieldChangedHandler; } if (OnValidationRequested.HasDelegate) { _editContext.OnValidationRequested += OnValidationRequestedHandler; } if (OnValidationStateChanged.HasDelegate) { _editContext.OnValidationStateChanged += OnValidationStateChangedHandler; } if (ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex)) { _editContext.OnFieldChanged += RulesModeOnFieldChanged; _editContext.OnValidationRequested += RulesModeOnValidationRequested; } }
public bool Validate(ContactModel contactModel, ValidateMode validateMode) { try { //message based on the where condition switch (validateMode) { case ValidateMode.MOBILE: var isMobileAvailable = addressBookEntities.ContactMobiles.ToList().Where(x => x.StatusId == (int)StatusHelper.Active && x.ContactId != contactModel.ContactId && contactModel.contactMobileList.Any(m => m.MobileNumber == x.MobileNumber)).ToList(); if (isMobileAvailable != null && isMobileAvailable.Count > 0) { return(false); } else { return(true); } case ValidateMode.EMAIL: var isEmailAvailable = addressBookEntities.ContactEmails.ToList().Where(x => x.StatusId == (int)StatusHelper.Active && x.ContactId != contactModel.ContactId && contactModel.contactEmailList.Any(m => m.EmailAddress == x.EmailAddress)).ToList(); if (isEmailAvailable != null && isEmailAvailable.Count > 0) { return(false); } else { return(true); } default: return(true); } } catch (Exception e) { return(false); } }
private void RulesModeOnValidationRequested(object sender, ValidationRequestedEventArgs args) { if (!ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex)) { return; } _rulesValidator.ClearErrors(); var errors = new Dictionary <FieldIdentifier, List <string> >(); foreach (var formItem in _formItems) { var result = formItem.ValidateField(); if (result.Length > 0) { errors[formItem.GetFieldIdentifier()] = result.Select(r => r.ErrorMessage).ToList(); } } _rulesValidator.DisplayErrors(errors); }
private void RulesModeOnFieldChanged(object sender, FieldChangedEventArgs args) { if (!ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex)) { return; } _rulesValidator.ClearError(args.FieldIdentifier); var formItem = _formItems .Single(t => t.GetFieldIdentifier().FieldName == args.FieldIdentifier.FieldName); var result = formItem.ValidateField(); if (result.Length > 0) { var errors = new Dictionary <FieldIdentifier, List <string> >(); errors[args.FieldIdentifier] = result.Select(r => r.ErrorMessage).ToList(); _rulesValidator.DisplayErrors(errors); } }
protected override void Dispose(bool disposing) { if (OnFieldChanged.HasDelegate) { _editContext.OnFieldChanged -= OnFieldChangedHandler; } if (OnValidationRequested.HasDelegate) { _editContext.OnValidationRequested -= OnValidationRequestedHandler; } if (OnValidationStateChanged.HasDelegate) { _editContext.OnValidationStateChanged -= OnValidationStateChangedHandler; } if (ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex)) { _editContext.OnFieldChanged -= RulesModeOnFieldChanged; _editContext.OnValidationRequested -= RulesModeOnValidationRequested; } base.Dispose(disposing); }
/// <summary> /// 对象校验 /// </summary> /// <param name="entity">待校验对象</param> /// <param name="mode">校验模式。Create: 用于创建, Update: 用于修改</param> /// <returns></returns> protected virtual ValidateResult Validate(T entity, ValidateMode mode) { return(new ValidateResult(true, string.Empty)); }
private async Task <long> ValidateUnreachableAsync([NotNull] ILogger logger, [NotNull] PathTreeNode tree, ValidateMode mode) { logger.Info(mode == ValidateMode.Delete ? $"[{DateTime.Now:s}] Delete unreachable files{myId}..." : $"[{DateTime.Now:s}] Validating unreachable files{myId}..."); long deleted = 0; var stack = new Stack <PathTreeNode>(); stack.Push(tree); while (stack.Count > 0) { var node = stack.Pop(); if (node.HasChildren) { foreach (var child in node.Children) { stack.Push(child); } } if (!node.HasReferences) { foreach (var file in node.Files) { if (mode == ValidateMode.Delete) { logger.Info($" Deleting {file}"); Interlocked.Increment(ref deleted); await myStorage.DeleteAsync(file); } else { logger.Error($"The file {file} should be deleted as unreferenced"); if (mode == ValidateMode.Fix) { logger.Fix($"The file {file} will be deleted as unreferenced"); await myStorage.DeleteAsync(file); } } } } } return(deleted); }
public async Task <Tuple <Statistics, long> > ValidateAsync( [NotNull] IEnumerable <KeyValuePair <string, Tag> > items, [NotNull] IReadOnlyCollection <string> files, StorageFormat storageFormat, ValidateMode mode, bool verifyAcl = false) { myLogger.Info($"[{DateTime.Now:s}] Validating storage{myId}..."); var fix = mode == ValidateMode.Fix || mode == ValidateMode.Delete; var statistics = new Statistics(); ILogger logger = new LoggerWithStatistics(myLogger, statistics); files = await ValidateDataFilesAsync(logger, files, storageFormat, fix); var tree = await CreateDirectoryTreeAsync(files); foreach (var item in items) { var tagFile = item.Key; var tag = item.Value; logger.Info($" Validating {tagFile}"); var isDirty = false; if (!tag.Product.ValidateProduct()) { logger.Error($"Invalid product {tag.Product} in file {tagFile}"); } if (!tag.Version.ValidateVersion()) { logger.Error($"Invalid version {tag.Version} in file {tagFile}"); } if (tag.CreationUtcTime == DateTime.MinValue) { logger.Error($"The empty creation time in {tagFile}"); if (fix) { var newCreationUtcTime = TryFixCreationTime(tag); if (newCreationUtcTime != null) { logger.Fix($"The creation time will be assigned to tag {tagFile}"); isDirty = true; tag.CreationUtcTime = newCreationUtcTime.Value; } } } if (tag.Directories == null || tag.Directories.Length == 0) { logger.Error($"The empty directory list in {tagFile}"); if (fix) { logger.Fix($"The tag will be deleted {tagFile}"); await myStorage.DeleteAsync(tagFile); continue; } } else { for (var index = 0; index < tag.Directories.Length; index++) { var dir = tag.Directories[index]; switch (dir.ValidateAndFixDataPath(StorageFormat.Normal, out var fixedDir)) { case PathUtil.ValidateAndFixErrors.Ok: break; case PathUtil.ValidateAndFixErrors.Error: logger.Error($"The tag directory {dir} from {tagFile} has invalid format"); break; case PathUtil.ValidateAndFixErrors.CanBeFixed: logger.Error($"The tag directory {dir} from {tagFile} has invalid format"); if (fix) { isDirty = true; tag.Directories[index] = fixedDir; } break; default: throw new ArgumentOutOfRangeException(); } var dstDir = dir.ValidateAndFixDataPath(storageFormat, out fixedDir) == PathUtil.ValidateAndFixErrors.CanBeFixed ? fixedDir : dir; var node = tree; foreach (var part in dstDir.GetPathComponents()) { node = node?.Lookup(part); } if (node == null) { logger.Error($"The directory {dir} from {tagFile} id wasn't found"); } else { node.IncrementReferences(); } } } if (isDirty) { logger.Info($"The tag file {tagFile} will be overwritten"); await using var stream = new MemoryStream(); await TagUtil.WriteTagScriptAsync(tag, stream); await myStorage.CreateForWritingAsync(tagFile, AccessMode.Private, stream); } } var deleted = await ValidateUnreachableAsync(logger, tree, mode); if (verifyAcl) { await ValidateAclAsync(logger, files, fix); } return(Tuple.Create(statistics, deleted)); }