Activities of "maliming"

hi

Can you share the RegisterAndSubscribeAsync method code?

hi

You can add OpenIddictToken to IgnoredNavigationEntitySelectors instead of overriding AbpEfCoreNavigationHelper.

Configure<AbpEntityChangeOptions>(options =>
{
    options.IgnoredNavigationEntitySelectors.Add("DisableOpenIddictToken", type => type == typeof(OpenIddictToken));
});

hi

You can reconsider requiring authentication for all pages.

options.Conventions.AuthorizeFolder("/");

Perhaps you can find an alternative solution.

What is your real use case?

Thanks.

hi

I will confirm this with the Theme team.

Thanks.

hi

Can you share the solution?

Thanks.

hi

Please try to override the PublishEventsForChangedEntityOnSaveChangeAsync and PublishEventsForTrackedEntity methods and test again.

Thanks.

[ReplaceDbContext(typeof(IIdentityProDbContext))]
[ConnectionStringName("Default")]
public class AbpShowcaseDbContext :
    AbpDbContext<AbpShowcaseDbContext>,
    IIdentityProDbContext
{

    public AbpShowcaseDbContext(DbContextOptions<AbpShowcaseDbContext> options)
        : base(options)
    {

    }

    protected override Task PublishEventsForChangedEntityOnSaveChangeAsync()
    {
        foreach (var entityEntry in AbpEfCoreNavigationHelper.GetChangedEntityEntries())
        {
            if (EntityChangeOptions.Value.PublishEntityUpdatedEventWhenNavigationChanges)
            {
                var ignoredEntity = EntityChangeOptions.Value.IgnoredNavigationEntitySelectors.Any(selector => selector.Predicate(entityEntry.Entity.GetType()));
                var onlyForeignKeyModifiedEntity = entityEntry.State == EntityState.Modified && entityEntry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey());

                if ((entityEntry.State == EntityState.Unchanged && ignoredEntity) || ignoredEntity)
                {
                    continue;
                }

                if (EntityChangeOptions.Value.UpdateAggregateRootWhenNavigationChanges &&
                    EntityChangeOptions.Value.IgnoredUpdateAggregateRootSelectors.All(selector => !selector.Predicate(entityEntry.Entity.GetType())) &&
                    entityEntry.State == EntityState.Unchanged)
                {
                    ApplyAbpConceptsForModifiedEntity(entityEntry, true);
                }

                if (entityEntry.Entity is ISoftDelete && entityEntry.Entity.As<ISoftDelete>().IsDeleted)
                {
                    EntityChangeEventHelper.PublishEntityDeletedEvent(entityEntry.Entity);
                }
                else
                {
                    EntityChangeEventHelper.PublishEntityUpdatedEvent(entityEntry.Entity);
                }
            }
            else if (entityEntry.Properties.Any(x => x.IsModified && (x.Metadata.ValueGenerated == ValueGenerated.Never || x.Metadata.ValueGenerated == ValueGenerated.OnAdd)))
            {
                if (entityEntry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey()))
                {
                    // Skip `PublishEntityDeletedEvent/PublishEntityUpdatedEvent` if only foreign keys have changed.
                    break;
                }

                if (entityEntry.Entity is ISoftDelete && entityEntry.Entity.As<ISoftDelete>().IsDeleted)
                {
                    EntityChangeEventHelper.PublishEntityDeletedEvent(entityEntry.Entity);
                }
                else
                {
                    EntityChangeEventHelper.PublishEntityUpdatedEvent(entityEntry.Entity);
                }
            }
        }

        return Task.CompletedTask;
    }

    protected override void PublishEventsForTrackedEntity(EntityEntry entry)
    {
        switch (entry.State)
        {
            case EntityState.Added:
                ApplyAbpConceptsForAddedEntity(entry);
                EntityChangeEventHelper.PublishEntityCreatedEvent(entry.Entity);
                break;

            case EntityState.Modified:
                if (entry.Properties.Any(x => x.IsModified && (x.Metadata.ValueGenerated == ValueGenerated.Never || x.Metadata.ValueGenerated == ValueGenerated.OnAdd)))
                {
                    // if (entry.Properties.Where(x => x.IsModified).All(x => x.Metadata.IsForeignKey()))
                    // {
                    //     // Skip `PublishEntityDeletedEvent/PublishEntityUpdatedEvent` if only foreign keys have changed.
                    //     break;
                    // }

                    ApplyAbpConceptsForModifiedEntity(entry);
                    if (entry.Entity is ISoftDelete && entry.Entity.As<ISoftDelete>().IsDeleted)
                    {
                        EntityChangeEventHelper.PublishEntityDeletedEvent(entry.Entity);
                    }
                    else
                    {
                        EntityChangeEventHelper.PublishEntityUpdatedEvent(entry.Entity);
                    }
                }
                else if (EntityChangeOptions.Value.PublishEntityUpdatedEventWhenNavigationChanges &&
                         EntityChangeOptions.Value.IgnoredNavigationEntitySelectors.All(selector => !selector.Predicate(entry.Entity.GetType())) &&
                         AbpEfCoreNavigationHelper.IsNavigationEntryModified(entry))
                {
                    if (EntityChangeOptions.Value.UpdateAggregateRootWhenNavigationChanges &&
                        EntityChangeOptions.Value.IgnoredUpdateAggregateRootSelectors.All(selector => !selector.Predicate(entry.Entity.GetType())))
                    {
                        ApplyAbpConceptsForModifiedEntity(entry, true);
                    }

                    if (entry.Entity is ISoftDelete && entry.Entity.As<ISoftDelete>().IsDeleted)
                    {
                        EntityChangeEventHelper.PublishEntityDeletedEvent(entry.Entity);
                    }
                    else
                    {
                        EntityChangeEventHelper.PublishEntityUpdatedEvent(entry.Entity);
                    }
                }
                break;

            case EntityState.Deleted:
                ApplyAbpConceptsForDeletedEntity(entry);
                EntityChangeEventHelper.PublishEntityDeletedEvent(entry.Entity);
                break;
        }
    }

hi

I will check it again.

Thanks.

hi

The relationship of Genres and Movies is Many-to-Many instead of One-To-Many

https://github.com/abpframework/abp/pull/24094

Great

hi

We will check and fix it.

Thanks.