Activities of "maliming"

hi

Thanks for reporting this. We will check it.

Sorry for that.

hi

If I would like to extend WorkflowDefinitions, Workflowinstances tables

These two tables are from Elsa instead of the ABP entity.

If you want to add new fields, you can check the Elsa document or the GitHub issues.

https://docs.elsaworkflows.io/getting-started/database-configuration https://github.com/elsa-workflows/elsa-core/issues

Thanks.

hi

It will be fixed in https://github.com/abpframework/abp/pull/24283

You can override the IPermissionChecker now.

Thanks.

[ExposeServices(typeof(IPermissionChecker))]
public class MyPermissionChecker : IPermissionChecker, ITransientDependency
{
    protected IPermissionDefinitionManager PermissionDefinitionManager { get; }
    protected ICurrentPrincipalAccessor PrincipalAccessor { get; }
    protected ICurrentTenant CurrentTenant { get; }
    protected IPermissionValueProviderManager PermissionValueProviderManager { get; }
    protected ISimpleStateCheckerManager<PermissionDefinition> StateCheckerManager { get; }

    public MyPermissionChecker(
        ICurrentPrincipalAccessor principalAccessor,
        IPermissionDefinitionManager permissionDefinitionManager,
        ICurrentTenant currentTenant,
        IPermissionValueProviderManager permissionValueProviderManager,
        ISimpleStateCheckerManager<PermissionDefinition> stateCheckerManager)
    {
        PrincipalAccessor = principalAccessor;
        PermissionDefinitionManager = permissionDefinitionManager;
        CurrentTenant = currentTenant;
        PermissionValueProviderManager = permissionValueProviderManager;
        StateCheckerManager = stateCheckerManager;
    }

    public virtual async Task<bool> IsGrantedAsync(string name)
    {
        return await IsGrantedAsync(PrincipalAccessor.Principal, name);
    }

    public virtual async Task<bool> IsGrantedAsync(
        ClaimsPrincipal? claimsPrincipal,
        string name)
    {
        Check.NotNull(name, nameof(name));

        var permission = await PermissionDefinitionManager.GetOrNullAsync(name);
        if (permission == null)
        {
            return false;
        }

        if (!permission.IsEnabled)
        {
            return false;
        }

        if (!await StateCheckerManager.IsEnabledAsync(permission))
        {
            return false;
        }

        var multiTenancySide = claimsPrincipal?.GetMultiTenancySide()
                               ?? CurrentTenant.GetMultiTenancySide();

        if (!permission.MultiTenancySide.HasFlag(multiTenancySide))
        {
            return false;
        }

        var isGranted = false;
        var context = new PermissionValueCheckContext(permission, claimsPrincipal);
        foreach (var provider in PermissionValueProviderManager.ValueProviders)
        {
            if (context.Permission.Providers.Any() &&
                !context.Permission.Providers.Contains(provider.Name))
            {
                continue;
            }

            var result = await provider.CheckAsync(context);

            if (result == PermissionGrantResult.Granted)
            {
                isGranted = true;
            }
            else if (result == PermissionGrantResult.Prohibited)
            {
                return false;
            }
        }

        return isGranted;
    }

    public async Task<MultiplePermissionGrantResult> IsGrantedAsync(string[] names)
    {
        return await IsGrantedAsync(PrincipalAccessor.Principal, names);
    }

    public async Task<MultiplePermissionGrantResult> IsGrantedAsync(ClaimsPrincipal? claimsPrincipal, string[] names)
    {
        Check.NotNull(names, nameof(names));

        var result = new MultiplePermissionGrantResult();
        if (!names.Any())
        {
            return result;
        }

        var multiTenancySide = claimsPrincipal?.GetMultiTenancySide() ??
                               CurrentTenant.GetMultiTenancySide();

        var permissionDefinitions = new List<PermissionDefinition>();
        foreach (var name in names)
        {
            var permission = await PermissionDefinitionManager.GetOrNullAsync(name);
            if (permission == null)
            {
                result.Result.Add(name, PermissionGrantResult.Prohibited);
                continue;
            }

            result.Result.Add(name, PermissionGrantResult.Undefined);

            if (permission.IsEnabled &&
                await StateCheckerManager.IsEnabledAsync(permission) &&
                permission.MultiTenancySide.HasFlag(multiTenancySide))
            {
                permissionDefinitions.Add(permission);
            }
        }

        foreach (var provider in PermissionValueProviderManager.ValueProviders)
        {
            var permissions = permissionDefinitions
                .Where(x => !x.Providers.Any() || x.Providers.Contains(provider.Name))
                .ToList();

            if (permissions.IsNullOrEmpty())
            {
                continue;
            }

            var context = new PermissionValuesCheckContext(
                permissions,
                claimsPrincipal);

            var multipleResult = await provider.CheckAsync(context);

            foreach (var grantResult in multipleResult.Result.Where(x => result.Result.ContainsKey(x.Key)))
            {
                switch (grantResult.Value)
                {
                    case PermissionGrantResult.Granted:
                    {
                        if (result.Result[grantResult.Key] != PermissionGrantResult.Prohibited)
                        {
                            result.Result[grantResult.Key] = PermissionGrantResult.Granted;
                        }
                        break;
                    }
                    case PermissionGrantResult.Prohibited:
                        result.Result[grantResult.Key] = PermissionGrantResult.Prohibited;
                        permissionDefinitions.RemoveAll(x => x.Name == grantResult.Key);
                        break;
                }
            }

            if (result.AllProhibited)
            {
                break;
            }
        }

        return result;
    }
}

hi

Elsa has its own independent database management system.

ABP only integrates Identity permissions and authentication. All other features are provided by Elsa.

See the module structure image:

Thanks

hi

I have reproduced the problem, and will provide a solution soon.

Thanks.

hi

The Elsa EF Core package will automatically create the workflow tables in your database instead of abp.

.UseWorkflowRuntime(runtime => runtime.UseEntityFrameworkCore(ef => ef.UseSqlServer(connectionString)))

The ABP Elsa module is basically empty now.

Thanks.

hi

Has your project depended on AbpHttpClientIdentityModelWebModule?

Can you share the source code?

Thanks.

hi

Can you check the code of https://abp.io/docs/latest/samples/elsa-workflows-demo

Thanks.

ok, I will check the source code.

Thanks.

hi

Different pages will use different AppService, and abp will know which AppService's URL to use.

{
  "RemoteServices": {
    "Default": {
      "BaseUrl": "http://localhost:53929/"
    },
    "ServiceA": {
      "BaseUrl": "http://localhost:48393/"
    },
    "ServiceB": {
      "BaseUrl": "http://localhost:48394/"
    } 
  } 
}

https://abp.io/docs/latest/framework/api-development/dynamic-csharp-clients#multiple-remote-service-endpoints

Thanks.