Activities of "maliming"

hi

Can you try to run the dotnet xxxx.HttpApi.Host.dllcommand in your website folder and check the output?

hi

Sorry for that. Please add the code below.

context.Services.RemoveAll(x => x.ServiceType == typeof(IDistributedCache));
context.Services.AddEnyimMemcached(asDistributedCache: true);

hi

I tried to reproduce this problem in https://demo.abp.io/index.html, but I can't reproduce it.

Can you test this in a new template project. if you can reproduce please share the test project with me. I will check it. Thanks.

hi balazs.koczab

You can use openiddict as authserver. The default template is already built.

Then add AddOpenIdConnect(oidc) in your backend and public MVC website.

Once you sign at the public MVC website. The backend website will sign automatically.

If you want to share the oidc cookies between backend and public you can see: https://abp.io/community/articles/how-to-share-the-cookies-between-subdomains-jfrzggc2

hi

Please check and share the stderr logs .

https://abp.io/docs/latest/solution-templates/layered-web-application/deployment/deployment-iis?UI=NG&DB=EF&Tiered=Yes#how-to-get-stdout-log

ok

hi

https://abp.io/docs/latest/framework/fundamentals/authorization#claims-principal-factory

hi

I have shared the source code.

But the new permission definition only exists in memory. You better add it to the database as well.

You can test it and give feedback here.

Thanks.

The new app service. You are add permission definition to static permission. you don't need to clear the cache of dynamic permission store.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading.Tasks;
using AbpSolution1.Localization;
using AbpSolution1.Permissions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Authorization.Permissions;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Localization;
using Volo.Abp.PermissionManagement;

namespace AbpSolution1.Books;

public class BookAppService :
    CrudAppService<
        Book, //The Book entity
        BookDto, //Used to show books
        Guid, //Primary key of the book entity
        PagedAndSortedResultRequestDto, //Used for paging/sorting
        CreateUpdateBookDto>, //Used to create/update a book
    IBookAppService //implement the IBookAppService
{
    private readonly IPermissionDefinitionManager _permissionDefinitionManager;
    private readonly IExtendedStaticPermissionDefinitionStore _staticPermissionDefinitionStore;

    public BookAppService(IRepository<Book, Guid> repository, IExtendedStaticPermissionDefinitionStore staticPermissionDefinitionStore, IPermissionDefinitionManager permissionDefinitionManager)
        : base(repository)
    {
        GetPolicyName = AbpSolution1Permissions.Books.Default;
        GetListPolicyName = AbpSolution1Permissions.Books.Default;
        CreatePolicyName = AbpSolution1Permissions.Books.Create;
        UpdatePolicyName = AbpSolution1Permissions.Books.Edit;
        DeletePolicyName = AbpSolution1Permissions.Books.Delete;

        _staticPermissionDefinitionStore = staticPermissionDefinitionStore;
        _permissionDefinitionManager = permissionDefinitionManager;
    }

    private static LocalizableString L(string name)
    {
        return LocalizableString.Create<AbpSolution1Resource>(name);
    }

    public override async Task<BookDto> CreateAsync(CreateUpdateBookDto input)
    {
        var publishedPermission = await _permissionDefinitionManager.GetAsync(AbpSolution1Permissions.Books.Published);
        string published_permission_name = AbpSolution1Permissions.Books.Published + "." + input.Name.Replace(" ", "");

        var published_permission_nameDefinition = publishedPermission?.AddChild(published_permission_name, L(input.Name));

        await _staticPermissionDefinitionStore.AddPermissionDefinitionAsync(published_permission_nameDefinition);


        var book = ObjectMapper.Map<CreateUpdateBookDto, Book>(input);


        var thisIsNotNull = await _permissionDefinitionManager.GetOrNullAsync(published_permission_name);

        var content = await Repository.InsertAsync(
            book, autoSave: true
            );

        return ObjectMapper.Map<Book, BookDto>(content);
    }
}


[Dependency(ReplaceServices = true)]
[ExposeServices(typeof(IStaticPermissionDefinitionStore), typeof(IExtendedStaticPermissionDefinitionStore))]
public class MyStaticPermissionDefinitionStore : IStaticPermissionDefinitionStore, IExtendedStaticPermissionDefinitionStore, ISingletonDependency
{
    protected readonly IDictionary<string, PermissionGroupDefinition> PermissionGroupDefinitions;

    protected readonly IDictionary<string, PermissionDefinition> PermissionDefinitions;

    protected AbpPermissionOptions Options { get; }

    private readonly IServiceProvider _serviceProvider;

    public MyStaticPermissionDefinitionStore(
        IServiceProvider serviceProvider,
        IOptions<AbpPermissionOptions> options)
    {
        _serviceProvider = serviceProvider;
        Options = options.Value;

        PermissionGroupDefinitions = CreatePermissionGroupDefinitions();
        PermissionDefinitions = CreatePermissionDefinitions();
    }

    public Task AddPermissionDefinitionAsync(PermissionDefinition permissionDefinition)
    {
        if (!PermissionDefinitions.ContainsKey(permissionDefinition.Name))
        {
            PermissionDefinitions.Add(permissionDefinition.Name, permissionDefinition);
        }

        return Task.CompletedTask;
    }

    protected virtual Dictionary<string, PermissionDefinition> CreatePermissionDefinitions()
    {
        var permissions = new Dictionary<string, PermissionDefinition>();

        foreach (var groupDefinition in PermissionGroupDefinitions.Values)
        {
            foreach (var permission in groupDefinition.Permissions)
            {
                AddPermissionToDictionaryRecursively(permissions, permission);
            }
        }

        return permissions;
    }

    protected virtual void AddPermissionToDictionaryRecursively(
        Dictionary<string, PermissionDefinition> permissions,
        PermissionDefinition permission)
    {
        if (permissions.ContainsKey(permission.Name))
        {
            throw new AbpException("Duplicate permission name: " + permission.Name);
        }

        permissions[permission.Name] = permission;

        foreach (var child in permission.Children)
        {
            AddPermissionToDictionaryRecursively(permissions, child);
        }
    }

    protected virtual Dictionary<string, PermissionGroupDefinition> CreatePermissionGroupDefinitions()
    {
        using (var scope = _serviceProvider.CreateScope())
        {
            var context = new PermissionDefinitionContext(scope.ServiceProvider);

            var providers = Options
                .DefinitionProviders
                .Select(p => (scope.ServiceProvider.GetRequiredService(p) as IPermissionDefinitionProvider)!)
                .ToList();

            foreach (var provider in providers)
            {
                provider.PreDefine(context);
            }

            foreach (var provider in providers)
            {
                provider.Define(context);
            }

            foreach (var provider in providers)
            {
                provider.PostDefine(context);
            }

            return context.Groups;
        }
    }

    public Task<PermissionDefinition?> GetOrNullAsync(string name)
    {
        return Task.FromResult(PermissionDefinitions.GetOrDefault(name));
    }

    public virtual Task<IReadOnlyList<PermissionDefinition>> GetPermissionsAsync()
    {
        return Task.FromResult<IReadOnlyList<PermissionDefinition>>(
            PermissionDefinitions.Values.ToImmutableList()
        );
    }

    public Task<IReadOnlyList<PermissionGroupDefinition>> GetGroupsAsync()
    {
        return Task.FromResult<IReadOnlyList<PermissionGroupDefinition>>(
            PermissionGroupDefinitions.Values.ToImmutableList()
        );
    }
}


public interface IExtendedStaticPermissionDefinitionStore : IStaticPermissionDefinitionStore
{
    Task AddPermissionDefinitionAsync(PermissionDefinition permissionDefinition);
}