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));
}
