public class CustomWebDocumentViewerOperationLogger : WebDocumentViewerOperationLogger
{
    private readonly IReportInterceptorService _reportInterceptorService;
    
    ...

    public override async Task<Action> BuildStartingAsync(string reportId, string reportUrl, XtraReport report, ReportBuildProperties buildProperties)
    {
        await _reportInterceptorService.PreBuildStartAsync(report.Name, buildProperties.Parameters);
        return null;
    }
    ...
}

public class DonationTaxSummaryReportInterceptor : IReportInterceptorService
{
    public override Task PreBuildStartAsync(string reportName, Dictionary<string, object> parameters)
    {
        var dateRange = GetDateRange(parameters);
        if (!dateRange.HasValue)
        {
            throw new ArgumentException("Please select a year range.");
        }

        return Task.CompletedTask;
    }

    private (DateTime, DateTime)? GetDateRange(Dictionary<string, object> parameters)
    {
        var years = parameters["Years"] as string;
        if (string.IsNullOrWhiteSpace(years) || year.Length != 8)
        {
            return null;
        }

        if (int.TryParse(years[..4], out var yearFrom) && int.TryParse(years[^4..], out var yearTo))
        {
            var dateFrom = new DateTime(yearFrom, 4, 1);
            var dateTo = new DateTime(yearTo, 3, 31);

            return (dateFrom, dateTo);
        }

        return null;
    }
}

private void HandleDocumentBuildException(Exception e)
{
    string message;
    if (e is AggregateException aggregateException)
    {
        message = aggregateException.InnerExceptions.First().Message;
    }
    else
    {
        message = e.Message;
    }

    throw new DocumentCreationException(string.IsNullOrEmpty(message) ? "Internal Server Error" : message);
}

public class StateDefinition : IState
{
    public string Name { get; }

    public StateType Type { get; }

    public ILocalizableString DisplayName
    {
        get => _displayName;
        set => _displayName = Check.NotNull(value, nameof(value));
    }
    private ILocalizableString _displayName;

    internal List<StateTransitionDefinition> Transitions { get; } = new List<StateTransitionDefinition>();

    public Dictionary<string, object> Properties { get; } = new Dictionary<string, object>();

    public object this[string name]
    {
        get => Properties.GetOrDefault(name);
        set => Properties[name] = value;
    }

    public StateDefinition(
        string name,
        ILocalizableString displayName = null,
        StateType type = StateType.Intermediate)
    {
        Name = Check.NotNullOrWhiteSpace(name, nameof(name));
        DisplayName = displayName ?? new FixedLocalizableString(name);
        Type = type;
    }

    public virtual StateTransitionDefinition On(params string[] terms)
    {
        Check.NotNullOrEmpty(terms, nameof(terms));
        return new StateTransitionDefinition(this, terms.Select(term => Check.NotNullOrWhiteSpace(term, nameof(terms))));
    }

    public virtual StateDefinition ReverseOn(params string[] terms)
    {
        Check.NotNullOrEmpty(terms, nameof(terms));
        var lastTransition = Transitions.LastOrDefault();
        if (lastTransition == null)
        {
            throw new MyStatesException("No state transition to be reversed.");
        }

        lastTransition.TargetState.On(terms).TransitTo(this);
        return this;
    }

    public virtual StateDefinition WithProperty(string key, object value)
    {
        Properties[key] = value;
        return this;
    }

    public virtual bool HasTargetState(StateDefinition targetState)
    {
        return Transitions.Any(transition => transition.TargetState.Equals(targetState));
    }

    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        if (ReferenceEquals(this, obj)) return true;
        if (!obj.GetType().IsAssignableTo<StateDefinition>()) return false;

        return Name == obj.As<StateDefinition>()?.Name;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

public class StateTransitionDefinition
{
    public StateDefinition SourceState { get; }

    public StateDefinition TargetState { get; protected set; }

    public List<string> Terms { get; } = new List<string>();

    protected internal StateTransitionDefinition(StateDefinition sourceState, IEnumerable<string> terms)
    {
        AssertStateAllowTransitFrom(Check.NotNull(sourceState, nameof(sourceState)));

        SourceState = sourceState;
        Terms = terms.ToList();
    }

    public virtual StateDefinition TransitTo(StateDefinition targetState)
    {
        AssertStateAllowTransitTo(Check.NotNull(targetState, nameof(targetState)));

        TargetState = targetState;
        SourceState.Transitions.Add(this);

        return SourceState;
    }

    protected virtual void AssertStateAllowTransitFrom(StateDefinition sourceState)
    {
        if (sourceState.Type.HasFlag(StateType.Final))
        {
            throw new MyStatesException("Final state cannot be transited from.", sourceState.Name);
        }
    }

    protected virtual void AssertStateAllowTransitTo(StateDefinition targetState)
    {
        if (targetState.Type.HasFlag(StateType.Initial))
        {
            throw new MyStatesException("Initial state cannot be transited to.", targetState.Name);
        }

        if (Terms.IsNullOrEmpty())
        {
            throw new MyStatesException("State transition must have terms.", targetState.Name);
        }

        if (SourceState.HasTargetState(targetState))
        {
            throw new MyStatesException("Source state already has a same target state.", targetState.Name);
        }

        if (SourceState.Transitions
            .SelectMany(transition => transition.Terms)
            .Intersect(Terms)
            .Any())
        {
            throw new MyStatesException("Source state cannot have multiple transitions with same terms", targetState.Name);
        }
    }

    protected virtual void AssertTransitionAllowReverse()
    {
        if (SourceState == null || TargetState == null)
        {
            throw new MyStatesException($"{nameof(SourceState)} and {nameof(TargetState)} should not be null when reversing.");
        }

        AssertStateAllowTransitFrom(TargetState);
        AssertStateAllowTransitTo(SourceState);
    }
}

public class StateGroupDefinition
{
    public string Name { get; }

    public StateGroupDefinition Parent { get; private set; }

    public ILocalizableString DisplayName
    {
        get => _displayName;
        set => _displayName = Check.NotNull(value, nameof(value));
    }
    private ILocalizableString _displayName;

    public IReadOnlyList<StateDefinition> States => _states.ToImmutableList();
    private readonly List<StateDefinition> _states = new();

    public IReadOnlyList<StateGroupDefinition> Groups => _groups.ToImmutableList();
    private readonly List<StateGroupDefinition> _groups = new();

    public Dictionary<string, object> Properties { get; } = new Dictionary<string, object>();

    public object this[string name]
    {
        get => Properties.GetOrDefault(name);
        set => Properties[name] = value;
    }

    protected internal StateGroupDefinition(
        string name,
        ILocalizableString displayName = null,
        StateGroupDefinition parent = null)
    {
        Name = Check.NotNullOrWhiteSpace(name, nameof(name));
        DisplayName = displayName ?? new FixedLocalizableString(Name);
        Parent = parent;
    }

    public virtual StateGroupDefinition AddGroup(
        string name,
        ILocalizableString displayName = null)
    {
        if (Name == name || _groups.Any(group => group.Name == name))
        {
            throw new MyStatesException($"There is already an existing state group definition with given name: {name}", stateGroupName: name);
        }

        var group = new StateGroupDefinition(name, displayName, this);

        _groups.Add(group);
        return group;
    }

    public virtual StateDefinition AddState(
        string name,
        ILocalizableString displayName = null,
        StateType type = StateType.Intermediate)
    {
        var state = new StateDefinition(name, displayName, type);
        return AddState(state);
    }

    public virtual StateDefinition AddState(StateDefinition state)
    {
        if (_states.Any(s => s.Name == Check.NotNull(state, nameof(state)).Name))
        {
            throw new MyStatesException($"There is already an existing state definition with given name: {state.Name}", state.Name, Name);
        }

        _states.Add(state);
        return state;
    }

    public virtual StateGroupDefinition FindGroupRecursively(string name, bool includeSelf = true)
    {
        Check.NotNullOrWhiteSpace(name, nameof(name));

        if (includeSelf && Name == name)
        {
            return this;
        }

        foreach (var childGroup in _groups)
        {
            var group = EnumerateGroupRecursively(childGroup).FirstOrDefault(g => g.Name == name);
            if (group != null)
            {
                return group;
            }
        }

        return null;
    }

    public virtual List<StateGroupDefinition> GetAllGroups(bool includeSelf = false)
    {
        var groups = new List<StateGroupDefinition>();

        foreach (var group in _groups)
        {
            AddGroupToListRecursively(groups, group);
        }

        if (includeSelf)
        {
            groups.Insert(0, this);
        }

        return groups;
    }

    public virtual List<StateDefinition> GetAllStates()
    {
        var allGroups = GetAllGroups(true);
        return allGroups.SelectMany(group => group.States).ToList();
    }

    public virtual StateTransitionDefinitionCollection On(params string[] terms)
    {
        Check.NotNullOrEmpty(terms, nameof(terms));
        var allStates = GetAllStates();
        return new StateTransitionDefinitionCollection(allStates.Select(state => state.On(terms)).ToList());
    }

    private void AddGroupToListRecursively(List<StateGroupDefinition> groups, StateGroupDefinition group)
    {
        groups.Add(group);

        foreach (var child in group.Groups)
        {
            AddGroupToListRecursively(groups, child);
        }
    }

    private IEnumerable<StateGroupDefinition> EnumerateGroupRecursively(StateGroupDefinition group)
    {
        yield return group;

        foreach (var innerGroup in group._groups)
        {
            foreach (var recurseGroup in EnumerateGroupRecursively(innerGroup))
            {
                yield return recurseGroup;
            }
        }
    }
}

public abstract class StateDefinitionProvider : IStateDefinitionProvider, ITransientDependency
{
    public abstract void Define(IStateDefinitionContext context);
}

public class StateDefinitionManager : IStateDefinitionManager, ISingletonDependency
{
    protected Lazy<IDictionary<string, StateGroupDefinition>> StateGroupDefinitions { get; }

    protected MyStateOptions Options { get; }

    protected IServiceProvider ServiceProvider { get; }

    public StateDefinitionManager(
        IOptions<MyStateOptions> options,
        IServiceProvider serviceProvider)
    {
        ServiceProvider = serviceProvider;
        Options = options.Value;

        StateGroupDefinitions = new Lazy<IDictionary<string, StateGroupDefinition>>(CreateStateDefinitions, true);
    }

    ...

    protected virtual IDictionary<string, StateGroupDefinition> CreateStateDefinitions()
    {
        var states = new Dictionary<string, StateGroupDefinition>();

        using (var scope = ServiceProvider.CreateScope())
        {
            var providers = Options
                .DefinitionProviders
                .Select(p => scope.ServiceProvider.GetRequiredService(p) as IStateDefinitionProvider)
                .ToList();

            foreach (var provider in providers)
            {
                provider.Define(new StateDefinitionContext(states, scope.ServiceProvider));
            }
        }

        return states;
    }
}

public interface IStateTransitionHandler
{
    Task HandleAsync(StateTransitionContext context);
}

public interface IStateTransitionNotifier
{
    Task NotifyAsync(
        string groupName,
        string term,
        Action<StateTransitionContext> contextAction = null,
        bool recurse = true);
}

public class DefaultStateTransitionNotifier : IStateTransitionNotifier, ITransientDependency
{
    public ILogger<DefaultStateTransitionNotifier> Logger { get; set; }

    protected IServiceProvider ServiceProvider { get; }

    protected IStateDefinitionManager DefinationManager { get; }

    protected IStateTransitionHandler TransitionHandler { get; }

    protected MyStateOptions Options { get; }

    public DefaultStateTransitionNotifier(
        IServiceProvider serviceProvider,
        IStateDefinitionManager definationManager,
        IStateTransitionHandler transitionHandler,
        IOptions<MyStateOptions> options)
    {
        ServiceProvider = serviceProvider;
        DefinationManager = definationManager;
        TransitionHandler = transitionHandler;
        Options = options.Value;

        Logger = NullLogger<DefaultStateTransitionNotifier>.Instance;
    }

    public virtual async Task NotifyAsync(
        string groupName,
        string term,
        Action<StateTransitionContext> contextAction = null,
        bool recurse = true)
    {
        Check.NotNullOrWhiteSpace(groupName, nameof(groupName));
        Check.NotNullOrWhiteSpace(term, nameof(term));

        var group = DefinationManager.GetGroupRecursively(groupName);
        var transitions = GetTransitionsToHandle(group, term);
        var context = new StateTransitionContext(groupName, term, transitions, recurse);
        contextAction?.Invoke(context);

        using var scope = ServiceProvider.CreateScope();

        var handlers = Options
            .TransitionHandlers
            .Where(handler =>
            {
                var handleGroupName = HandleStateAttribute.GetHandleGroupName(handler);
                return handleGroupName.IsNullOrEmpty() || DefinationManager.IsGroupBelongTo(groupName, handleGroupName);
            })
            .Select(p => scope.ServiceProvider.GetRequiredService(p) as IStateTransitionHandler)
            .ToList();

        foreach (var handler in handlers)
        {
            await handler.HandleAsync(context);

            if (!context.HandlerContext.Any(handlerContext => !handlerContext.Value))
            {
                break;
            }
        }

        if (!context.HandlerContext.Any(handlerContext => handlerContext.Value))
        {
            Logger.LogWarning("State transition notification not handled by any of the registered handlers, context: {Context}", context);
        }
    }

    protected virtual IEnumerable<StateTransitionDefinition> GetTransitionsToHandle(StateGroupDefinition group, string term)
    {
        return group
            .GetAllStates()
            .SelectMany(state => state.Transitions)
            .Where(transition => transition.Terms.Any(t => t == term));
    }
}

public class MyStateOptions
{
    public ITypeList<IStateDefinitionProvider> DefinitionProviders { get; } = new TypeList<IStateDefinitionProvider>();

    public ITypeList<IStateTransitionHandler> TransitionHandlers { get; } = new TypeList<IStateTransitionHandler>();
}

[DependsOn(typeof(AbpLocalizationModule))]
public class MyStatesModule : AbpModule
{
    public override void PreConfigureServices(ServiceConfigurationContext context)
    {
        AutoAddDefinitionProviders(context.Services);
    }

    private static void AutoAddDefinitionProviders(IServiceCollection services)
    {
        var definitionProviders = new List<Type>();
        var transitionHandlers = new List<Type>();

        services.OnRegistred(context =>
        {
            if (typeof(IStateDefinitionProvider).IsAssignableFrom(context.ImplementationType))
            {
                definitionProviders.Add(context.ImplementationType);
            }

            if (typeof(IStateTransitionHandler).IsAssignableFrom(context.ImplementationType))
            {
                transitionHandlers.Add(context.ImplementationType);
            }
        });

        services.Configure<MyStateOptions>(options =>
        {
            options.DefinitionProviders.AddIfNotContains(definitionProviders);
            options.TransitionHandlers.AddIfNotContains(transitionHandlers);
        });
    }
}

public class PartialUpdate_Tests : EntityFrameworkCoreTestBase
{
    // 这里的仓储类是我们在第一篇博文中涉及到的层级用户仓储类
    private readonly IHierarchicalUserRepository _userRepository;

    public PartialUpdate_Tests()
    {
        _userRepository = GetRequiredService<IHierarchicalUserRepository>();
    }
}

[Fact]
public async Task Should_Prevent_Update_If_HierarchyCode_Of_User_Is_Null()
{
    const string fakeHiearchyCode = "1234";
    var userId = Guid.NewGuid();

    var newUser = new HierarchicalUser(userId, fakeHiearchyCode, "A");
    await _userRepository.InsertAsync(newUser, true);

    newUser.Name = "B";
    newUser.HierarchyCode = null; // 通过赋值null，我们期望HierarchyCode不会参与更新
    await _userRepository.UpdateAsync(newUser, true);

    var currentUser = await _userRepository.GetAsync(userId);
    currentUser.Name.ShouldBe("B"); // 由于Name字段不为按需更新，断言值为新值
    currentUser.HierarchyCode.ShouldBe(fakeHiearchyCode); // 由于HierarchyCode字段为按需更新，断言值仍为原值
}

public class PreventUpdateIfDefaultAttribute : Attribute
{

}

public static void ConfigureByMyConvention(this EntityTypeBuilder b)
{
    //...
    b.TryConfigurePreventUpdate();
}

//...

public static void ConfigurePreventUpdate<T>(this EntityTypeBuilder<T> b)
    where T : class
{
    b.As<EntityTypeBuilder>().TryConfigurePreventUpdate();
}

public static void TryConfigurePreventUpdate(this EntityTypeBuilder b)
{
    var properties = b.Metadata.GetProperties();
    foreach (var property in properties)
    {
        if (property.PropertyInfo?.IsDefined(typeof(PreventUpdateIfDefaultAttribute), true) == true)
        {
            b.Property(property.Name).PreventUpdateIfDefault();
        }
    }
}

public static class MyPropertyBuilderExtensions
{
    public const string PreventUpdateConditionAnnotation = "__PreventUpdateCondition";

    public static PropertyBuilder<TProperty> PreventUpdate<TProperty>(
        this PropertyBuilder<TProperty> propertyBuilder,
        Func<object, bool> predicate,
        bool prevent = true)
    {
        return propertyBuilder.HasAnnotation(PreventUpdateConditionAnnotation, prevent ? predicate : null);
    }

    public static PropertyBuilder PreventUpdate(
        this PropertyBuilder propertyBuilder,
        Func<object, bool> predicate,
        bool prevent = true)
    {
        return propertyBuilder.HasAnnotation(PreventUpdateConditionAnnotation, prevent ? predicate : null);
    }

    public static PropertyBuilder<TProperty> PreventUpdateIfDefault<TProperty>(this PropertyBuilder<TProperty> propertyBuilder)
    {
        var defaultValue = TypeHelper.GetDefaultValue<TProperty>();
        return propertyBuilder.PreventUpdate(property => property == null || property.Equals(defaultValue));
    }

    public static PropertyBuilder PreventUpdateIfDefault(this PropertyBuilder propertyBuilder)
    {
        var defaultValue = TypeHelper.GetDefaultValue(propertyBuilder.Metadata.ClrType);
        return propertyBuilder.PreventUpdate(property => property == null || property.Equals(defaultValue));
    }
}

protected override void ApplyAbpConceptsForModifiedEntity(EntityEntry entry, EntityChangeReport changeReport)
{
    base.ApplyAbpConceptsForModifiedEntity(entry, changeReport);

    //...
    ApplyPartiallyUpdateConcept(entry);
}

protected virtual void ApplyPartiallyUpdateConcept(EntityEntry entry)
{
    ApplyPartiallyUpdateConceptForProperties(entry.Properties);
}

private void ApplyPartiallyUpdateConceptForProperties(IEnumerable<PropertyEntry> properties)
{
    if (properties == null)
    {
        return;
    }

    foreach (var property in properties)
    {
        if (property.Metadata[MyPropertyBuilderExtensions.PreventUpdateConditionAnnotation] is Func<object, bool> predicate)
        {
            if (predicate(property.CurrentValue))
            {
                property.IsModified = false;
            }
        }
    }
}

public class MyTestHasHierarchyRepository : IHasHierarchyRepository<MyTestHierarchy>, ITransientDependency
{
    public static readonly List<MyTestHierarchy> Nodes = new();

    public Task DeleteNodeAsync(MyTestHierarchy node, CancellationToken cancellationToken = default)
    {
        Nodes.RemoveAll(node => node.Id == node.Id);
            return Task.CompletedTask;
    }

    public Task<List<MyTestHierarchy>> GetAllChildrenAsync(MyTestHierarchy parent, bool isReadonly = true, CancellationToken cancellationToken = default)
    {
        if (parent == null)
        {
            return Task.FromResult(Nodes);
        }

        var children = Nodes.Where(node => node.HierarchyCode.StartsWith(parent.HierarchyCode) && node.Id != parent.Id);
        return Task.FromResult(children.ToList());
        }

    public Task<string> GetLastChildCodeOrNullAsync(MyTestHierarchy parent, CancellationToken cancellationToken = default)
    {
        var children = Nodes.Where(node => node.Parent?.Id == parent?.Id);
        var lastChild = children.OrderBy(child => child.HierarchyCode).LastOrDefault();
        return Task.FromResult(lastChild?.HierarchyCode);
    }

    public Task SetHierarchyAsync(MyTestHierarchy node, MyTestHierarchy parent, string code, CancellationToken cancellationToken = default)
    {
        var nodeInRepository = Nodes.Where(n => n.Id == node.Id);
        foreach (var n in nodeInRepository)
        {
            n.Parent = parent;
            n.HierarchyCode = code;
        };

        return Task.CompletedTask;
    }
}

public class MyTestHierarchy : IHasHierarchy
{
    public int Id { get; set; }

    public string HierarchyCode { get; set; }

    public MyTestHierarchy Parent { get; set; }
}

private readonly IHierarchyCodeManager<IHasHierarchy> _globalManager;

public GlobalHierarchyCodeManager_Tests()
{
    _globalManager = GetRequiredService<IHierarchyCodeManager<IHasHierarchy>>();
}

[Fact]
public void Should_Register_Global_Code_Manager_As_Default()
{
    ProxyHelper.UnProxy(_globalManager).ShouldBeOfType<GlobalHierarchyCodeManager>();
}

[Fact]
public async Task Should_Create_Hierarchy_Code_For_Nodes_Of_Different_Types()
{
    var node1 = new MyTestHierarchy1();
    var node2 = new MyTestHierarchy2();
    var node3 = new MyTestHierarchy2();
    var node4 = new MyTestHierarchy2();

    node1.HierarchyCode = await _globalManager.CreateCodeAsync(node1, null);
    node2.HierarchyCode = await _globalManager.CreateCodeAsync(node2, node1);
    node3.HierarchyCode = await _globalManager.CreateCodeAsync(node3, node2);
    node4.HierarchyCode = await _globalManager.CreateCodeAsync(node4, node1);

    node2.HierarchyCode.ShouldStartWith(node1.HierarchyCode);
    node3.HierarchyCode.ShouldStartWith(node2.HierarchyCode);
    node4.HierarchyCode.ShouldStartWith(node1.HierarchyCode);
    node4.HierarchyCode.ShouldNotStartWith(node2.HierarchyCode);
}

public class HierarchicalUser : Entity<Guid>, IHasHierarchy
{
    [PreventUpdateIfDefault]
    public string HierarchyCode { get; set; }

    public string Name { get; set; }

    private HierarchicalUser()
    {

    }

    public HierarchicalUser(Guid id, string hierarchyCode, string name) : base(id)
    {
        HierarchyCode = hierarchyCode;
        Name = name;
    }
}

public class Worksheet : Entity<Guid>, IHasHierarchy
{
    public string HierarchyCode { get; set; }

    public string Title { get; set; }

    private Worksheet()
    {

    }

    public Worksheet(Guid id, string hierarchyCode, string title) : base(id)
    {
        HierarchyCode = hierarchyCode;
        Title = title;
    }
}

public class TestAppDataSeedContributor : IDataSeedContributor, ITransientDependency
{
    public static HierarchicalUser HierarchyUser1 { get; } = new(Guid.NewGuid(), string.Empty, "HierarchyUser1");
    public static HierarchicalUser HierarchyUser2 { get; } = new(Guid.NewGuid(), "0001", "HierarchyUser2");
    public static HierarchicalUser HierarchyUser3 { get; } = new(Guid.NewGuid(), "0001.0002.0003", "HierarchyUser3");
    public static Worksheet Worksheet1 { get; } = new(Guid.NewGuid(), "0001.0002", "Worksheet1");
    public static Worksheet Worksheet2 { get; } = new(Guid.NewGuid(), "0003.0004", "Worksheet2");

    private readonly IHierarchicalUserRepository _hierarchicalUserRepository;
    private readonly IWorksheetRepository _worksheetRepository;

    public TestAppDataSeedContributor(
        IHierarchicalUserRepository hierarchicalUserRepository,
        IWorksheetRepository worksheetRepository)
    {
        _hierarchicalUserRepository = hierarchicalUserRepository;
        _worksheetRepository = worksheetRepository;
    }

    public async Task SeedAsync(DataSeedContext context)
    {
        await _hierarchicalUserRepository.InsertAsync(HierarchyUser1);
        await _hierarchicalUserRepository.InsertAsync(HierarchyUser2);
        await _hierarchicalUserRepository.InsertAsync(HierarchyUser3);
        await _worksheetRepository.InsertAsync(Worksheet1);
        await _worksheetRepository.InsertAsync(Worksheet2);
    }
}

context.Services.AddHierarchicalUser<HierarchicalUser, HierarchicalUserRepository>();