feat: Optimize dynamic application service interfaces

apps/vben5/packages/@abp/features/src/components/definitions/features/FeatureDefinitionModal.vue

@@ -67,7 +67,6 @@ interface DefinitionTreeVo {
 type TabKeys = 'basic' | 'props';
 
 const defaultModel: FeatureDefinitionDto = {
-  allowedProviders: [],
   displayName: '',
   extraProperties: {},
   groupName: '',
@@ -438,7 +437,10 @@ function onSelectionChange(items: SelectionStringValueItem[]) {
             :label="$t('AbpFeatureManagement.DisplayName:IsVisibleToClients')"
             :extra="$t('AbpFeatureManagement.Description:IsVisibleToClients')"
           >
-            <Checkbox v-model:checked="formModel.isVisibleToClients">
+            <Checkbox
+              v-model:checked="formModel.isVisibleToClients"
+              :disabled="formModel.isStatic"
+            >
               {{ $t('AbpFeatureManagement.DisplayName:IsVisibleToClients') }}
             </Checkbox>
           </FormItem>
@@ -447,7 +449,10 @@ function onSelectionChange(items: SelectionStringValueItem[]) {
             :label="$t('AbpFeatureManagement.DisplayName:IsAvailableToHost')"
             :extra="$t('AbpFeatureManagement.Description:IsAvailableToHost')"
           >
-            <Checkbox v-model:checked="formModel.isAvailableToHost">
+            <Checkbox
+              v-model:checked="formModel.isAvailableToHost"
+              :disabled="formModel.isStatic"
+            >
               {{ $t('AbpFeatureManagement.DisplayName:IsAvailableToHost') }}
             </Checkbox>
           </FormItem>

apps/vben5/packages/@abp/features/src/types/definitions.ts

@@ -1,7 +1,7 @@
 import type { IHasConcurrencyStamp, IHasExtraProperties } from '@abp/core';
 
 interface FeatureDefinitionDto extends IHasExtraProperties {
-  allowedProviders: string[];
+  allowedProviders?: string[];
   defaultValue?: string;
   description?: string;
   displayName: string;
@@ -20,7 +20,7 @@ interface FeatureDefinitionGetListInput {
 }
 
 interface FeatureDefinitionCreateOrUpdateDto extends IHasExtraProperties {
-  allowedProviders: string[];
+  allowedProviders?: string[];
   defaultValue?: string;
   description?: string;
   displayName: string;

aspnet-core/modules/feature-management/LINGYUN.Abp.FeatureManagement.Application/LINGYUN/Abp/FeatureManagement/Definitions/FeatureDefinitionAppService.cs

@@ -2,10 +2,10 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -13,7 +13,6 @@ using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.FeatureManagement;
 using Volo.Abp.Features;
-using Volo.Abp.Localization;
 using Volo.Abp.Validation;
 
 namespace LINGYUN.Abp.FeatureManagement.Definitions;
@@ -22,32 +21,23 @@ namespace LINGYUN.Abp.FeatureManagement.Definitions;
 public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFeatureDefinitionAppService
 {
     private readonly StringValueTypeSerializer _stringValueTypeSerializer;
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IFeatureDefinitionManager _featureDefinitionManager;
     private readonly IFeatureValueProviderManager _featureValueProviderManager;
-    private readonly IStaticFeatureDefinitionStore _staticFeatureDefinitionStore;
-    private readonly IDynamicFeatureDefinitionStore _dynamicFeatureDefinitionStore;
     private readonly IFeatureDefinitionRecordRepository _definitionRepository;
     private readonly IRepository<FeatureDefinitionRecord, Guid> _definitionBasicRepository;
+    private readonly IRepository<FeatureGroupDefinitionRecord, Guid> _groupDefinitionBasicRepository;
 
     public FeatureDefinitionAppService(
         StringValueTypeSerializer stringValueTypeSerializer,
-        ILocalizableStringSerializer localizableStringSerializer,
-        IFeatureDefinitionManager featureDefinitionManager,
         IFeatureValueProviderManager featureValueProviderManager,
-        IStaticFeatureDefinitionStore featureDefinitionStore,
-        IDynamicFeatureDefinitionStore dynamicFeatureDefinitionStore,
         IFeatureDefinitionRecordRepository definitionRepository, 
-        IRepository<FeatureDefinitionRecord, Guid> definitionBasicRepository)
+        IRepository<FeatureDefinitionRecord, Guid> definitionBasicRepository,
+        IRepository<FeatureGroupDefinitionRecord, Guid> groupDefinitionBasicRepository)
     {
         _stringValueTypeSerializer = stringValueTypeSerializer;
-        _localizableStringSerializer = localizableStringSerializer;
-        _featureDefinitionManager = featureDefinitionManager;
         _featureValueProviderManager = featureValueProviderManager;
-        _staticFeatureDefinitionStore = featureDefinitionStore;
-        _dynamicFeatureDefinitionStore = dynamicFeatureDefinitionStore;
         _definitionRepository = definitionRepository;
         _definitionBasicRepository = definitionBasicRepository;
+        _groupDefinitionBasicRepository = groupDefinitionBasicRepository;
     }
 
     public virtual Task<ListResultDto<NameValue<string>>> GetAssignableProvidersAsync()
@@ -70,32 +60,15 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
     [Authorize(FeatureManagementPermissionNames.Definition.Create)]
     public async virtual Task<FeatureDefinitionDto> CreateAsync(FeatureDefinitionCreateDto input)
     {
-        var staticGroups = await _staticFeatureDefinitionStore.GetGroupsAsync();
-        if (staticGroups.Any(g => g.Name == input.GroupName))
-        {
-            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-                .WithData(nameof(FeatureDefinitionRecord.Name), input.GroupName);
-        }
-
-        if (await _staticFeatureDefinitionStore.GetOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(FeatureManagementErrorCodes.Definition.AlreayNameExists)
-                .WithData(nameof(FeatureDefinitionRecord.Name), input.Name);
-        }
-
         if (await _definitionRepository.FindByNameAsync(input.Name) != null)
         {
             throw new BusinessException(FeatureManagementErrorCodes.Definition.AlreayNameExists)
                 .WithData(nameof(FeatureDefinitionRecord.Name), input.Name);
         }
 
-        var groupDefinition = await _featureDefinitionManager.GetGroupOrNullAsync(input.GroupName);
+        var groupDefinition = await _groupDefinitionBasicRepository.FindAsync(x => x.Name == input.GroupName)
-        if (groupDefinition == null)
+            ?? throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
-        {
-            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(FeatureGroupDefinitionRecord.Name), input.GroupName);
-        }
-
         var definitionRecord = new FeatureDefinitionRecord(
             GuidGenerator.Create(),
             groupDefinition.Name,
@@ -110,6 +83,8 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
 
         UpdateByInput(definitionRecord, input);
 
+        definitionRecord.SetProperty(nameof(FeatureDefinitionDto.IsStatic), false);
+
         await _definitionRepository.InsertAsync(definitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
@@ -120,103 +95,65 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
     [Authorize(FeatureManagementPermissionNames.Definition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var definitionRecord = await FindRecordByNameAsync(name);
+        var definitionRecord = await FindRecordByNameAsync(name)
+            ?? throw new BusinessException(FeatureManagementErrorCodes.Definition.NameNotFount)
+                .WithData(nameof(FeatureDefinitionRecord.Name), name);
 
-        if (definitionRecord != null)
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        {
-            await _definitionRepository.DeleteAsync(definitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await _definitionRepository.DeleteAsync(definitionRecord);
-        }
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<FeatureDefinitionDto> GetAsync(string name)
     {
-        var definition = await _staticFeatureDefinitionStore.GetOrNullAsync(name);
+        var definitionRecord = await FindRecordByNameAsync(name)
-        if (definition != null)
+            ?? throw new BusinessException(FeatureManagementErrorCodes.Definition.NameNotFount)
-        {
+                .WithData(nameof(FeatureDefinitionRecord.Name), name);
-            return DefinitionToDto(await GetGroupDefinition(definition), definition, true);
+        return DefinitionRecordToDto(definitionRecord);
-        }
-        definition = await _dynamicFeatureDefinitionStore.GetOrNullAsync(name);
-        return DefinitionToDto(await GetGroupDefinition(definition), definition);
     }
 
     public async virtual Task<ListResultDto<FeatureDefinitionDto>> GetListAsync(FeatureDefinitionGetListInput input)
     {
         var featureDtoList = new List<FeatureDefinitionDto>();
 
-        var staticFreatures = new List<FeatureDefinition>();
+        Expression<Func<FeatureDefinitionRecord, bool>> predicate = _ => true;
-
+        if (!input.GroupName.IsNullOrWhiteSpace())
-        var staticGroups = await _staticFeatureDefinitionStore.GetGroupsAsync();
-        var staticGroupNames = staticGroups
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        foreach (var group in staticGroups.WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
-        {
-            var features = group.GetFeaturesWithChildren();
-            staticFreatures.AddRange(features);
-            featureDtoList.AddRange(features.Select(f => DefinitionToDto(group, f, true)));
-        }
-        var staticFeatureNames = staticFreatures
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        var dynamicGroups = await _dynamicFeatureDefinitionStore.GetGroupsAsync();
-        foreach (var group in dynamicGroups
-            .Where(d => !staticGroupNames.Contains(d.Name))
-            .WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
         {
-            var features = group.GetFeaturesWithChildren();
+            predicate = predicate.And(x => x.Name == input.GroupName);
-            featureDtoList.AddRange(features
-                .Where(d => !staticFeatureNames.Contains(d.Name))
-                .Select(f => DefinitionToDto(group, f)));
         }
+        var definitionRecords = await _definitionBasicRepository.GetListAsync(predicate);
+        featureDtoList.AddRange(definitionRecords.Select(DefinitionRecordToDto));
 
-        return new ListResultDto<FeatureDefinitionDto>(featureDtoList
+        return new ListResultDto<FeatureDefinitionDto>(featureDtoList);
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
-            .ToList());
     }
 
     [Authorize(FeatureManagementPermissionNames.Definition.Update)]
     public async virtual Task<FeatureDefinitionDto> UpdateAsync(string name, FeatureDefinitionUpdateDto input)
     {
-        if (await _staticFeatureDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindRecordByNameAsync(name)
-        {
+            ?? throw new BusinessException(FeatureManagementErrorCodes.Definition.NameNotFount)
-            throw new BusinessException(FeatureManagementErrorCodes.Definition.StaticFeatureNotAllowedChanged)
+                .WithData(nameof(FeatureDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var definition = await _featureDefinitionManager.GetAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        var definitionRecord = await FindRecordByNameAsync(name);
+        UpdateByInput(definitionRecord, input);
-
+        definitionRecord = await _definitionBasicRepository.UpdateAsync(definitionRecord);
-        if (definitionRecord == null)
-        {
-            var groupDefinition = await GetGroupDefinition(definition);
-            definitionRecord = new FeatureDefinitionRecord(
-                GuidGenerator.Create(),
-                groupDefinition.Name,
-                name,
-                input.ParentName,
-                input.DisplayName,
-                input.Description,
-                input.DefaultValue,
-                input.IsVisibleToClients,
-                input.IsAvailableToHost,
-                valueType: input.ValueType);
-            UpdateByInput(definitionRecord, input);
-
-            definitionRecord = await _definitionBasicRepository.InsertAsync(definitionRecord);
-        }
-        else
-        {
-            UpdateByInput(definitionRecord, input);
-            definitionRecord = await _definitionBasicRepository.UpdateAsync(definitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
         return DefinitionRecordToDto(definitionRecord);
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(FeatureDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(FeatureDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(FeatureManagementErrorCodes.Definition.StaticFeatureNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
+    }
+
     protected virtual void UpdateByInput(FeatureDefinitionRecord record, FeatureDefinitionCreateOrUpdateDto input)
     {
         record.IsVisibleToClients = input.IsVisibleToClients;
@@ -281,22 +218,6 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
         return definitionRecord;
     }
 
-    protected async virtual Task<FeatureGroupDefinition> GetGroupDefinition(FeatureDefinition definition)
-    {
-        var groups = await _featureDefinitionManager.GetGroupsAsync();
-
-        foreach (var group in groups)
-        {
-            if (group.GetFeatureOrNull(definition.Name) != null)
-            {
-                return group;
-            }
-        }
-
-        throw new BusinessException(FeatureManagementErrorCodes.Definition.FailedGetGroup)
-            .WithData(nameof(FeatureDefinitionRecord.Name), definition.Name);
-    }
-
     protected virtual FeatureDefinitionDto DefinitionRecordToDto(FeatureDefinitionRecord definitionRecord)
     {
         var dto = new FeatureDefinitionDto
@@ -308,10 +229,11 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
             IsVisibleToClients = definitionRecord.IsVisibleToClients,
             DefaultValue = definitionRecord.DefaultValue,
             ValueType = definitionRecord.ValueType,
-            AllowedProviders = definitionRecord.AllowedProviders?.Split(',').ToList(),
+            AllowedProviders = definitionRecord.AllowedProviders?.Split(',').ToList() ?? [],
             Description = definitionRecord.Description,
             DisplayName = definitionRecord.DisplayName,
             ExtraProperties = new ExtraPropertyDictionary(),
+            IsStatic = definitionRecord.GetProperty(nameof(FeatureDefinitionDto.IsStatic), true),
         };
 
         foreach (var property in definitionRecord.ExtraProperties)
@@ -321,39 +243,4 @@ public class FeatureDefinitionAppService : FeatureManagementAppServiceBase, IFea
 
         return dto;
     }
-
-    protected virtual FeatureDefinitionDto DefinitionToDto(FeatureGroupDefinition groupDefinition, FeatureDefinition definition, bool isStatic = false)
-    {
-        var dto = new FeatureDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = definition.Name,
-            GroupName = groupDefinition.Name,
-            ParentName = definition.Parent?.Name,
-            DefaultValue = definition.DefaultValue,
-            AllowedProviders = definition.AllowedProviders,
-            IsAvailableToHost = definition.IsAvailableToHost,
-            IsVisibleToClients = definition.IsVisibleToClients,
-            ValueType = definition.ValueType.Name,
-            DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName),
-            ExtraProperties = new ExtraPropertyDictionary(),
-        };
-
-        if (definition.ValueType != null)
-        {
-            dto.ValueType = _stringValueTypeSerializer.Serialize(definition.ValueType);
-        }
-
-        if (definition.Description != null)
-        {
-            dto.Description = _localizableStringSerializer.Serialize(definition.Description);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            dto.SetProperty(property.Key, property.Value);
-        }
-
-        return dto;
-    }
 }

aspnet-core/modules/feature-management/LINGYUN.Abp.FeatureManagement.Application/LINGYUN/Abp/FeatureManagement/Definitions/FeatureGroupDefinitionAppService.cs

@@ -2,42 +2,28 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.FeatureManagement;
-using Volo.Abp.Features;
-using Volo.Abp.Localization;
 
 namespace LINGYUN.Abp.FeatureManagement.Definitions;
 
 [Authorize(FeatureManagementPermissionNames.GroupDefinition.Default)]
 public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase, IFeatureGroupDefinitionAppService
 {
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IFeatureDefinitionManager _featureDefinitionManager;
-    private readonly IStaticFeatureDefinitionStore _staticFeatureDefinitionStore;
-    private readonly IDynamicFeatureDefinitionStore _dynamicFeatureDefinitionStore;
     private readonly IFeatureGroupDefinitionRecordRepository _groupDefinitionRepository;
     private readonly IRepository<FeatureGroupDefinitionRecord, Guid> _groupDefinitionBasicRepository;
 
     public FeatureGroupDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer,
-        IFeatureDefinitionManager featureDefinitionManager, 
-        IStaticFeatureDefinitionStore featureDefinitionStore,
-        IDynamicFeatureDefinitionStore dynamicFeatureDefinitionStore,
         IFeatureGroupDefinitionRecordRepository groupDefinitionRepository, 
         IRepository<FeatureGroupDefinitionRecord, Guid> groupDefinitionBasicRepository)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _featureDefinitionManager = featureDefinitionManager;
-        _staticFeatureDefinitionStore = featureDefinitionStore;
-        _dynamicFeatureDefinitionStore = dynamicFeatureDefinitionStore;
         _groupDefinitionRepository = groupDefinitionRepository;
         _groupDefinitionBasicRepository = groupDefinitionBasicRepository;
     }
@@ -45,11 +31,6 @@ public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase,
     [Authorize(FeatureManagementPermissionNames.GroupDefinition.Create)]
     public async virtual Task<FeatureGroupDefinitionDto> CreateAsync(FeatureGroupDefinitionCreateDto input)
     {
-        if (await _featureDefinitionManager.GetGroupOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.AlreayNameExists)
-                .WithData(nameof(FeatureGroupDefinitionRecord.Name), input.Name);
-        }
         var groupDefinitionRecord = await _groupDefinitionBasicRepository.FindAsync(x => x.Name == input.Name);
         if (groupDefinitionRecord != null)
         {
@@ -64,6 +45,8 @@ public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase,
 
         UpdateByInput(groupDefinitionRecord, input);
 
+        groupDefinitionRecord.SetProperty(nameof(FeatureGroupDefinitionDto.IsStatic), false);
+
         await _groupDefinitionRepository.InsertAsync(groupDefinitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
@@ -74,91 +57,67 @@ public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase,
     [Authorize(FeatureManagementPermissionNames.GroupDefinition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var groupDefinitionRecord = await FindByNameAsync(name);
+        var groupDefinitionRecord = await FindByNameAsync(name)
+            ?? throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
+                .WithData(nameof(FeatureGroupDefinitionRecord.Name), name);
 
-        if (groupDefinitionRecord != null)
+        CheckIsStaticDefinitionRecord(groupDefinitionRecord);
-        {
-            await _groupDefinitionRepository.DeleteAsync(groupDefinitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await _groupDefinitionRepository.DeleteAsync(groupDefinitionRecord);
-        }
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<FeatureGroupDefinitionDto> GetAsync(string name)
     {
-        var staticGroups = await _staticFeatureDefinitionStore.GetGroupsAsync();
+        var groupDefinitionRecord = await FindByNameAsync(name)
-        var groupDefinition = staticGroups.FirstOrDefault(x => x.Name == name);
+            ?? throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
-        if (groupDefinition != null)
-        {
-            return GroupDefinitionToDto(groupDefinition, true);
-        }
-
-        var dynamicGroups = await _dynamicFeatureDefinitionStore.GetGroupsAsync();
-
-        groupDefinition = dynamicGroups.FirstOrDefault(x => x.Name == name);
-        if (groupDefinition == null)
-        {
-            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(FeatureGroupDefinitionRecord.Name), name);
-        }
 
-        return GroupDefinitionToDto(groupDefinition);
+        return GroupDefinitionRecordToDto(groupDefinitionRecord);
     }
 
     public async virtual Task<ListResultDto<FeatureGroupDefinitionDto>> GetListAsync(FeatureGroupDefinitionGetListInput input)
     {
         var groupDtoList = new List<FeatureGroupDefinitionDto>();
 
-        var staticGroups = await _staticFeatureDefinitionStore.GetGroupsAsync();
+        Expression<Func<FeatureGroupDefinitionRecord, bool>> predicate = _ => true;
-        var staticGroupsNames = staticGroups
+        if (!input.Filter.IsNullOrWhiteSpace())
-           .Select(p => p.Name)
+        {
-           .ToImmutableHashSet();
+            predicate = predicate.And(x => x.Name.Contains(input.Filter));
-        groupDtoList.AddRange(staticGroups.Select(d => GroupDefinitionToDto(d, true)));
+        }
-
+        var permissionGroupDefinitions = await _groupDefinitionBasicRepository.GetListAsync(predicate);
-        var dynamicGroups = await _dynamicFeatureDefinitionStore.GetGroupsAsync();
+
-        groupDtoList.AddRange(dynamicGroups
+        groupDtoList.AddRange(permissionGroupDefinitions.Select(GroupDefinitionRecordToDto));
-           .Where(d => !staticGroupsNames.Contains(d.Name))
+
-           .Select(d => GroupDefinitionToDto(d)));
+        return new ListResultDto<FeatureGroupDefinitionDto>(groupDtoList);
-
-        return new ListResultDto<FeatureGroupDefinitionDto>(
-            groupDtoList
-                .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter))
-                .ToList());
     }
 
     [Authorize(FeatureManagementPermissionNames.GroupDefinition.Update)]
     public async virtual Task<FeatureGroupDefinitionDto> UpdateAsync(string name, FeatureGroupDefinitionUpdateDto input)
     {
-        var staticGroups = await _staticFeatureDefinitionStore.GetGroupsAsync();
+        var groupDefinitionRecord = await FindByNameAsync(name)
-        if (staticGroups.FirstOrDefault(x => x.Name == name) != null)
+            ?? throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(FeatureGroupDefinitionRecord.Name), name);
-            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-              .WithData("Name", name);
-        }
-
-        var groupDefinitionRecord = await FindByNameAsync(name);
-
-        if (groupDefinitionRecord == null)
-        {
-            groupDefinitionRecord = new FeatureGroupDefinitionRecord(
-                GuidGenerator.Create(),
-                name,
-                input.DisplayName);
-            UpdateByInput(groupDefinitionRecord, input);
 
-            groupDefinitionRecord = await _groupDefinitionBasicRepository.InsertAsync(groupDefinitionRecord);
+        CheckIsStaticDefinitionRecord(groupDefinitionRecord);
-        }
+        UpdateByInput(groupDefinitionRecord, input);
-        else
+        groupDefinitionRecord = await _groupDefinitionBasicRepository.UpdateAsync(groupDefinitionRecord);
-        {
-            UpdateByInput(groupDefinitionRecord, input);
-            groupDefinitionRecord = await _groupDefinitionBasicRepository.UpdateAsync(groupDefinitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
         return GroupDefinitionRecordToDto(groupDefinitionRecord);
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(FeatureGroupDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(FeatureGroupDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(FeatureManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
+    }
+
     protected virtual void UpdateByInput(FeatureGroupDefinitionRecord record, FeatureGroupDefinitionCreateOrUpdateDto input)
     {
         record.ExtraProperties.Clear();
@@ -183,6 +142,7 @@ public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase,
     {
         var groupDto = new FeatureGroupDefinitionDto
         {
+            IsStatic = groupDefinitionRecord.GetProperty(nameof(FeatureGroupDefinitionDto.IsStatic), true),
             Name = groupDefinitionRecord.Name,
             DisplayName = groupDefinitionRecord.DisplayName,
             ExtraProperties = new ExtraPropertyDictionary(),
@@ -195,22 +155,4 @@ public class FeatureGroupDefinitionAppService : FeatureManagementAppServiceBase,
 
         return groupDto;
     }
-
-    protected virtual FeatureGroupDefinitionDto GroupDefinitionToDto(FeatureGroupDefinition groupDefinition, bool isStatic = false)
-    {
-        var groupDto = new FeatureGroupDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = groupDefinition.Name,
-            DisplayName = _localizableStringSerializer.Serialize(groupDefinition.DisplayName),
-            ExtraProperties = new ExtraPropertyDictionary(),
-        };
-
-        foreach (var property in groupDefinition.Properties)
-        {
-            groupDto.SetProperty(property.Key, property.Value);
-        }
-
-        return groupDto;
-    }
 }

aspnet-core/modules/permissions-management/LINGYUN.Abp.PermissionManagement.Application/LINGYUN/Abp/PermissionManagement/Definitions/PermissionDefinitionAppService.cs

@@ -2,18 +2,16 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
-using System.Xml.Linq;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
-using Volo.Abp.Localization;
 using Volo.Abp.PermissionManagement;
 using Volo.Abp.SimpleStateChecking;
 using Volo.Abp.Validation;
@@ -24,32 +22,26 @@ namespace LINGYUN.Abp.PermissionManagement.Definitions;
 public class PermissionDefinitionAppService : PermissionManagementAppServiceBase, IPermissionDefinitionAppService
 {
     private readonly ISimpleStateCheckerSerializer _simpleStateCheckerSerializer;
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IPermissionDefinitionManager _permissionDefinitionManager;
-    private readonly IPermissionValueProviderManager _permissionValueProviderManager;
     private readonly IStaticPermissionDefinitionStore _staticPermissionDefinitionStore;
-    private readonly IDynamicPermissionDefinitionStore _dynamicPermissionDefinitionStore;
+    private readonly IPermissionValueProviderManager _permissionValueProviderManager;
     private readonly IPermissionDefinitionRecordRepository _definitionRepository;
     private readonly IRepository<PermissionDefinitionRecord, Guid> _definitionBasicRepository;
+    private readonly IRepository<PermissionGroupDefinitionRecord, Guid> _groupDefinitionBasicRepository;
 
     public PermissionDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer, 
-        IPermissionDefinitionManager permissionDefinitionManager,
-        IPermissionValueProviderManager permissionValueProviderManager,
         IStaticPermissionDefinitionStore staticPermissionDefinitionStore,
-        IDynamicPermissionDefinitionStore dynamicPermissionDefinitionStore,
+        IPermissionValueProviderManager permissionValueProviderManager,
         ISimpleStateCheckerSerializer simpleStateCheckerSerializer,
-        IPermissionDefinitionRecordRepository definitionRepository, 
+        IPermissionDefinitionRecordRepository definitionRepository,
-        IRepository<PermissionDefinitionRecord, Guid> definitionBasicRepository)
+        IRepository<PermissionDefinitionRecord, Guid> definitionBasicRepository,
+        IRepository<PermissionGroupDefinitionRecord, Guid> groupDefinitionBasicRepository)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _permissionDefinitionManager = permissionDefinitionManager;
-        _permissionValueProviderManager = permissionValueProviderManager;
         _staticPermissionDefinitionStore = staticPermissionDefinitionStore;
-        _dynamicPermissionDefinitionStore = dynamicPermissionDefinitionStore;
+        _permissionValueProviderManager = permissionValueProviderManager;
         _simpleStateCheckerSerializer = simpleStateCheckerSerializer;
         _definitionRepository = definitionRepository;
         _definitionBasicRepository = definitionBasicRepository;
+        _groupDefinitionBasicRepository = groupDefinitionBasicRepository;
     }
 
     public virtual Task<ListResultDto<NameValue<string>>> GetAssignableProvidersAsync()
@@ -72,25 +64,15 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
     [Authorize(PermissionManagementPermissionNames.Definition.Create)]
     public async virtual Task<PermissionDefinitionDto> CreateAsync(PermissionDefinitionCreateDto input)
     {
-        if (await _permissionDefinitionManager.GetOrNullAsync(input.Name) != null)
+        if (await _definitionRepository.FindByNameAsync(input.Name) != null)
         {
             throw new BusinessException(PermissionManagementErrorCodes.Definition.AlreayNameExists)
                 .WithData(nameof(PermissionDefinitionRecord.Name), input.Name);
         }
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
-        if (staticGroups.Any(g => g.Name == input.GroupName))
-        {
-            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-                .WithData(nameof(PermissionDefinitionRecord.Name), input.GroupName);
-        }
 
-        var groupDefinition = await _permissionDefinitionManager.GetGroupOrNullAsync(input.GroupName);
+        var groupDefinition = await _groupDefinitionBasicRepository.FindAsync(x => x.Name == input.GroupName) ??
-        if (groupDefinition == null)
-        {
             throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(PermissionGroupDefinitionRecord.Name), input.GroupName);
-        }
-
         var definitionRecord = new PermissionDefinitionRecord(
             GuidGenerator.Create(),
             groupDefinition.Name,
@@ -103,6 +85,8 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
 
         await UpdateByInput(definitionRecord, input);
 
+        definitionRecord.SetProperty(nameof(PermissionDefinitionDto.IsStatic), false);
+
         definitionRecord = await _definitionRepository.InsertAsync(definitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
@@ -113,109 +97,67 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
     [Authorize(PermissionManagementPermissionNames.Definition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        if (await _staticPermissionDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindByNameAsync(name) ??
-        {
+            throw new BusinessException(PermissionManagementErrorCodes.Definition.NameNotFount)
-            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
+                .WithData(nameof(PermissionDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var definitionRecord = await FindByNameAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
 
-        if (definitionRecord != null)
+        await _definitionRepository.DeleteAsync(definitionRecord);
-        {
-            await _definitionRepository.DeleteAsync(definitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await CurrentUnitOfWork.SaveChangesAsync();
-        }
     }
 
     public async virtual Task<PermissionDefinitionDto> GetAsync(string name)
     {
-        var definition = await _staticPermissionDefinitionStore.GetOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (definition != null)
+            throw new BusinessException(PermissionManagementErrorCodes.Definition.NameNotFount)
-        {
+                .WithData(nameof(PermissionDefinitionRecord.Name), name);
-            return DefinitionToDto(await GetGroupDefinition(definition), definition, true);
+        return DefinitionRecordToDto(definitionRecord);
-        }
-        definition = await _dynamicPermissionDefinitionStore.GetOrNullAsync(name);
-        return DefinitionToDto(await GetGroupDefinition(definition), definition);
     }
 
     public async virtual Task<ListResultDto<PermissionDefinitionDto>> GetListAsync(PermissionDefinitionGetListInput input)
     {
         var permissionDtoList = new List<PermissionDefinitionDto>();
 
-        var staticPermissions = new List<PermissionDefinition>();
+        Expression<Func<PermissionDefinitionRecord, bool>> predicate = _ => true;
-
+        if (!input.GroupName.IsNullOrWhiteSpace())
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
-        var staticGroupNames = staticGroups
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        foreach (var group in staticGroups.WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
-        {
-            var permissions = group.GetPermissionsWithChildren();
-            staticPermissions.AddRange(permissions);
-            permissionDtoList.AddRange(permissions.Select(f => DefinitionToDto(group, f, true)));
-        }
-        var staticPermissionNames = staticPermissions
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        var dynamicGroups = await _dynamicPermissionDefinitionStore.GetGroupsAsync();
-        foreach (var group in dynamicGroups
-            .Where(d => !staticGroupNames.Contains(d.Name))
-            .WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
         {
-            var permissions = group.GetPermissionsWithChildren();
+            predicate = predicate.And(x => x.Name == input.GroupName);
-            permissionDtoList.AddRange(permissions
-                .Where(d => !staticPermissionNames.Contains(d.Name))
-                .Select(f => DefinitionToDto(group, f)));
         }
+        var permissionDefinitions = await _definitionBasicRepository.GetListAsync(predicate);
+        permissionDtoList.AddRange(permissionDefinitions.Select(DefinitionRecordToDto));
 
-        return new ListResultDto<PermissionDefinitionDto>(permissionDtoList
+        return new ListResultDto<PermissionDefinitionDto>(permissionDtoList);
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
-            .ToList());
     }
 
     [Authorize(PermissionManagementPermissionNames.Definition.Update)]
     public async virtual Task<PermissionDefinitionDto> UpdateAsync(string name, PermissionDefinitionUpdateDto input)
     {
-        if (await _staticPermissionDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindByNameAsync(name) ??
-        {
+            throw new BusinessException(PermissionManagementErrorCodes.Definition.NameNotFount)
-            throw new BusinessException(PermissionManagementErrorCodes.Definition.StaticPermissionNotAllowedChanged)
+                .WithData(nameof(PermissionDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var definition = await _permissionDefinitionManager.GetOrNullAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        var definitionRecord = await FindByNameAsync(name);
 
-        if (definitionRecord == null)
+        await UpdateByInput(definitionRecord, input);
-        {
-            var groupDefinition = await GetGroupDefinition(definition);
-            definitionRecord = new PermissionDefinitionRecord(
-                GuidGenerator.Create(),
-                groupDefinition.Name,
-                name,
-                input.ResourceName,
-                input.ManagementPermissionName,
-                input.ParentName,
-                input.DisplayName,
-                input.IsEnabled);
-
-            await UpdateByInput(definitionRecord, input);
-
-            definitionRecord = await _definitionBasicRepository.InsertAsync(definitionRecord);
-        }
-        else
-        {
-            await UpdateByInput(definitionRecord, input);
 
-            definitionRecord = await _definitionBasicRepository.UpdateAsync(definitionRecord);
+        definitionRecord = await _definitionBasicRepository.UpdateAsync(definitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
         return DefinitionRecordToDto(definitionRecord);
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(PermissionDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(PermissionDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(PermissionManagementErrorCodes.Definition.StaticPermissionNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
+    }
+
     protected async virtual Task UpdateByInput(PermissionDefinitionRecord record, PermissionDefinitionCreateOrUpdateDto input)
     {
         record.IsEnabled = input.IsEnabled;
@@ -285,27 +227,11 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
         return definitionRecord;
     }
 
-    protected async virtual Task<PermissionGroupDefinition> GetGroupDefinition(PermissionDefinition definition)
-    {
-        var groups = await _permissionDefinitionManager.GetGroupsAsync();
-
-        foreach (var group in groups)
-        {
-            if (group.GetPermissionOrNull(definition.Name) != null)
-            {
-                return group;
-            }
-        }
-
-        throw new BusinessException(PermissionManagementErrorCodes.Definition.FailedGetGroup)
-            .WithData(nameof(PermissionDefinitionRecord.Name), definition.Name);
-    }
-
     protected virtual PermissionDefinitionDto DefinitionRecordToDto(PermissionDefinitionRecord definitionRecord)
     {
         var dto = new PermissionDefinitionDto
         {
-            IsStatic = false,
+            IsStatic = definitionRecord.GetProperty(nameof(PermissionDefinitionDto.IsStatic), true),
             Name = definitionRecord.Name,
             GroupName = definitionRecord.GroupName,
             ParentName = definitionRecord.ParentName,
@@ -313,7 +239,7 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
             DisplayName = definitionRecord.DisplayName,
             ResourceName = definitionRecord.ResourceName,
             ManagementPermissionName = definitionRecord.ManagementPermissionName,
-            Providers = definitionRecord.Providers?.Split(',').ToList(),
+            Providers = definitionRecord.Providers?.Split(',').ToList() ?? [],
             StateCheckers = definitionRecord.StateCheckers,
             MultiTenancySide = definitionRecord.MultiTenancySide,
             ExtraProperties = new ExtraPropertyDictionary(),
@@ -326,34 +252,4 @@ public class PermissionDefinitionAppService : PermissionManagementAppServiceBase
 
         return dto;
     }
-
-    protected virtual PermissionDefinitionDto DefinitionToDto(PermissionGroupDefinition groupDefinition, PermissionDefinition definition, bool isStatic = false)
-    {
-        var dto = new PermissionDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = definition.Name,
-            GroupName = groupDefinition.Name,
-            ParentName = definition.Parent?.Name,
-            IsEnabled = definition.IsEnabled,
-            Providers = definition.Providers,
-            ResourceName = definition.ResourceName,
-            ManagementPermissionName = definition.ManagementPermissionName,
-            MultiTenancySide = definition.MultiTenancySide,
-            DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName),
-            ExtraProperties = new ExtraPropertyDictionary(),
-        };
-
-        if (definition.StateCheckers.Any())
-        {
-            dto.StateCheckers = _simpleStateCheckerSerializer.Serialize(definition.StateCheckers);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            dto.SetProperty(property.Key, property.Value);
-        }
-
-        return dto;
-    }
 }

aspnet-core/modules/permissions-management/LINGYUN.Abp.PermissionManagement.Application/LINGYUN/Abp/PermissionManagement/Definitions/PermissionGroupDefinitionAppService.cs

@@ -2,16 +2,14 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
-using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
-using Volo.Abp.Localization;
 using Volo.Abp.PermissionManagement;
 
 namespace LINGYUN.Abp.PermissionManagement.Definitions;
@@ -19,25 +17,13 @@ namespace LINGYUN.Abp.PermissionManagement.Definitions;
 [Authorize(PermissionManagementPermissionNames.GroupDefinition.Default)]
 public class PermissionGroupDefinitionAppService : PermissionManagementAppServiceBase, IPermissionGroupDefinitionAppService
 {
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IPermissionDefinitionManager _permissionDefinitionManager;
-    private readonly IStaticPermissionDefinitionStore _staticPermissionDefinitionStore;
-    private readonly IDynamicPermissionDefinitionStore _dynamicPermissionDefinitionStore;
     private readonly IPermissionGroupDefinitionRecordRepository _groupDefinitionRepository;
     private readonly IRepository<PermissionGroupDefinitionRecord, Guid> _groupDefinitionBasicRepository;
 
     public PermissionGroupDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer, 
-        IPermissionDefinitionManager permissionDefinitionManager, 
-        IStaticPermissionDefinitionStore staticPermissionDefinitionStore,
-        IDynamicPermissionDefinitionStore dynamicPermissionDefinitionStore,
         IPermissionGroupDefinitionRecordRepository groupDefinitionRepository, 
         IRepository<PermissionGroupDefinitionRecord, Guid> groupDefinitionBasicRepository)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _permissionDefinitionManager = permissionDefinitionManager;
-        _staticPermissionDefinitionStore = staticPermissionDefinitionStore;
-        _dynamicPermissionDefinitionStore = dynamicPermissionDefinitionStore;
         _groupDefinitionRepository = groupDefinitionRepository;
         _groupDefinitionBasicRepository = groupDefinitionBasicRepository;
     }
@@ -45,12 +31,6 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
     [Authorize(PermissionManagementPermissionNames.GroupDefinition.Create)]
     public async virtual Task<PermissionGroupDefinitionDto> CreateAsync(PermissionGroupDefinitionCreateDto input)
     {
-        if (await _permissionDefinitionManager.GetGroupOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.AlreayNameExists)
-                .WithData(nameof(PermissionGroupDefinitionRecord.Name), input.Name);
-        }
-
         var groupDefinitionRecord = await _groupDefinitionBasicRepository.FindAsync(x => x.Name == input.Name);
         if (groupDefinitionRecord != null)
         {
@@ -67,6 +47,7 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
         {
             groupDefinitionRecord.SetProperty(property.Key, property.Value);
         }
+        groupDefinitionRecord.SetProperty(nameof(PermissionGroupDefinitionDto.IsStatic), false);
 
         groupDefinitionRecord = await _groupDefinitionRepository.InsertAsync(groupDefinitionRecord);
 
@@ -78,93 +59,53 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
     [Authorize(PermissionManagementPermissionNames.GroupDefinition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
+        var groupDefinitionRecord = await FindByNameAsync(name) ??
-        if (staticGroups.Any(g => g.Name == name))
+            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(PermissionGroupDefinitionRecord.Name), name);
-            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-              .WithData("Name", name);
-        }
 
-        var groupDefinitionRecord = await FindByNameAsync(name);
+        CheckIsStaticDefinitionRecord(groupDefinitionRecord);
 
-        if (groupDefinitionRecord != null)
+        await _groupDefinitionRepository.DeleteAsync(groupDefinitionRecord);
-        {
-            await _groupDefinitionRepository.DeleteAsync(groupDefinitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await CurrentUnitOfWork.SaveChangesAsync();
-        }
     }
 
     public async virtual Task<PermissionGroupDefinitionDto> GetAsync(string name)
     {
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
+        var groupDefinitionRecord = await FindByNameAsync(name) ??
-        var groupDefinition = staticGroups.FirstOrDefault(x => x.Name == name);
-        if (groupDefinition != null)
-        {
-            return DefinitionToDto(groupDefinition, true);
-        }
-
-        var dynamicGroups = await _dynamicPermissionDefinitionStore.GetGroupsAsync();
-
-        groupDefinition = dynamicGroups.FirstOrDefault(x => x.Name == name);
-        if (groupDefinition == null)
-        {
             throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(PermissionGroupDefinitionRecord.Name), name);
-        }
 
-        return DefinitionToDto(groupDefinition);
+        return DefinitionRecordToDto(groupDefinitionRecord);
     }
 
     public async virtual Task<ListResultDto<PermissionGroupDefinitionDto>> GetListAsync(PermissionGroupDefinitionGetListInput input)
     {
         var groupDtoList = new List<PermissionGroupDefinitionDto>();
 
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
+        Expression<Func<PermissionGroupDefinitionRecord, bool>> predicate = _ => true;
-        var staticGroupsNames = staticGroups
+        if (!input.Filter.IsNullOrWhiteSpace())
-           .Select(p => p.Name)
+        {
-           .ToImmutableHashSet();
+            predicate = predicate.And(x => x.Name.Contains(input.Filter));
-        groupDtoList.AddRange(staticGroups.Select(d => DefinitionToDto(d, true)));
+        }
-
+        var permissionGroupDefinitions = await _groupDefinitionBasicRepository.GetListAsync(predicate);
-        var dynamicGroups = await _dynamicPermissionDefinitionStore.GetGroupsAsync();
+
-        groupDtoList.AddRange(dynamicGroups
+        groupDtoList.AddRange(permissionGroupDefinitions.Select(DefinitionRecordToDto));
-           .Where(d => !staticGroupsNames.Contains(d.Name))
+
-           .Select(d => DefinitionToDto(d)));
+        return new ListResultDto<PermissionGroupDefinitionDto>(groupDtoList);
-
-        return new ListResultDto<PermissionGroupDefinitionDto>(
-            groupDtoList
-                .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter))
-                .ToList());
     }
 
     [Authorize(PermissionManagementPermissionNames.GroupDefinition.Update)]
     public async virtual Task<PermissionGroupDefinitionDto> UpdateAsync(string name, PermissionGroupDefinitionUpdateDto input)
     {
-        var staticGroups = await _staticPermissionDefinitionStore.GetGroupsAsync();
+        var groupDefinitionRecord = await FindByNameAsync(name) ??
-        if (staticGroups.Any(g => g.Name == name))
+            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(PermissionGroupDefinitionRecord.Name), name);
-            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-              .WithData("Name", name);
-        }
-
-        var groupDefinitionRecord = await FindByNameAsync(name);
-
-        if (groupDefinitionRecord == null)
-        {
-            groupDefinitionRecord = new PermissionGroupDefinitionRecord(
-                GuidGenerator.Create(),
-                name,
-                input.DisplayName);
-            UpdateByInput(groupDefinitionRecord, input);
 
-            groupDefinitionRecord = await _groupDefinitionBasicRepository.InsertAsync(groupDefinitionRecord);
+        CheckIsStaticDefinitionRecord(groupDefinitionRecord);
-        }
+        UpdateByInput(groupDefinitionRecord, input);
-        else
-        {
-            UpdateByInput(groupDefinitionRecord, input);
 
-            groupDefinitionRecord = await _groupDefinitionBasicRepository.UpdateAsync(groupDefinitionRecord);
+        groupDefinitionRecord = await _groupDefinitionBasicRepository.UpdateAsync(groupDefinitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
@@ -181,6 +122,15 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
         return groupDefinitionRecord;
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(PermissionGroupDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(PermissionGroupDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(PermissionManagementErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
+    }
+
     protected virtual void UpdateByInput(PermissionGroupDefinitionRecord record, PermissionGroupDefinitionCreateOrUpdateDto input)
     {
         record.ExtraProperties.Clear();
@@ -198,7 +148,7 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
     {
         var groupDto = new PermissionGroupDefinitionDto
         {
-            IsStatic = false,
+            IsStatic = groupDefinitionRecord.GetProperty(nameof(PermissionGroupDefinitionDto.IsStatic), true),
             Name = groupDefinitionRecord.Name,
             DisplayName = groupDefinitionRecord.DisplayName,
             ExtraProperties = new ExtraPropertyDictionary(),
@@ -211,22 +161,4 @@ public class PermissionGroupDefinitionAppService : PermissionManagementAppServic
 
         return groupDto;
     }
-
-    protected virtual PermissionGroupDefinitionDto DefinitionToDto(PermissionGroupDefinition groupDefinition, bool isStatic = false)
-    {
-        var groupDto = new PermissionGroupDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = groupDefinition.Name,
-            DisplayName = _localizableStringSerializer.Serialize(groupDefinition.DisplayName),
-            ExtraProperties = new ExtraPropertyDictionary(),
-        };
-
-        foreach (var property in groupDefinition.Properties)
-        {
-            groupDto.SetProperty(property.Key, property.Value);
-        }
-
-        return groupDto;
-    }
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.Application/LINGYUN/Abp/Notifications/Definitions/Groups/NotificationGroupDefinitionAppService.cs

@@ -2,8 +2,8 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -16,33 +16,19 @@ namespace LINGYUN.Abp.Notifications.Definitions.Groups;
 public class NotificationGroupDefinitionAppService : AbpNotificationsApplicationServiceBase, INotificationGroupDefinitionAppService
 {
     private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly INotificationDefinitionManager _definitionManager;
+    private readonly INotificationDefinitionGroupRecordRepository _definitionGroupRecordRepository;
-    private readonly IStaticNotificationDefinitionStore _staticDefinitionStore;
-    private readonly IDynamicNotificationDefinitionStore _dynamicDefinitionStore;
-    private readonly INotificationDefinitionGroupRecordRepository _definitionRecordRepository;
 
     public NotificationGroupDefinitionAppService(
         ILocalizableStringSerializer localizableStringSerializer, 
-        INotificationDefinitionManager definitionManager,
+        INotificationDefinitionGroupRecordRepository definitionGroupRecordRepository)
-        IStaticNotificationDefinitionStore staticDefinitionStore,
-        IDynamicNotificationDefinitionStore dynamicDefinitionStore,
-        INotificationDefinitionGroupRecordRepository definitionRecordRepository)
     {
         _localizableStringSerializer = localizableStringSerializer;
-        _definitionManager = definitionManager;
+        _definitionGroupRecordRepository = definitionGroupRecordRepository;
-        _staticDefinitionStore = staticDefinitionStore;
-        _dynamicDefinitionStore = dynamicDefinitionStore;
-        _definitionRecordRepository = definitionRecordRepository;
     }
 
     [Authorize(NotificationsPermissions.GroupDefinition.Create)]
     public async virtual Task<NotificationGroupDefinitionDto> CreateAsync(NotificationGroupDefinitionCreateDto input)
     {
-        if (await _definitionManager.GetGroupOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.AlreayNameExists)
-                .WithData(nameof(NotificationDefinitionGroupRecord.Name), input.Name);
-        }
         var definitionRecord = await FindByNameAsync(input.Name);
         if (definitionRecord != null)
         {
@@ -57,7 +43,9 @@ public class NotificationGroupDefinitionAppService : AbpNotificationsApplication
 
         UpdateByInput(definitionRecord, input);
 
-        await _definitionRecordRepository.InsertAsync(definitionRecord);
+        definitionRecord.SetProperty(nameof(NotificationGroupDefinitionDto.IsStatic), false);
+
+        await _definitionGroupRecordRepository.InsertAsync(definitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
@@ -67,88 +55,68 @@ public class NotificationGroupDefinitionAppService : AbpNotificationsApplication
     [Authorize(NotificationsPermissions.GroupDefinition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var definitionRecord = await FindByNameAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
+            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.NameNotFount)
+                .WithData(nameof(NotificationDefinitionGroupRecord.Name), name);
 
-        if (definitionRecord != null)
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        {
-            await _definitionRecordRepository.DeleteAsync(definitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await _definitionGroupRecordRepository.DeleteAsync(definitionRecord);
-        }
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<NotificationGroupDefinitionDto> GetAsync(string name)
     {
-        var definition = await _staticDefinitionStore.GetGroupOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (definition != null)
-        {
-            return DefinitionToDto(definition, true);
-        }
-
-        definition = await _dynamicDefinitionStore.GetGroupOrNullAsync(name);
-        if (definition == null)
-        {
             throw new BusinessException(NotificationsErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(NotificationDefinitionGroupRecord.Name), name);
-        }
+        return DefinitionRecordToDto(definitionRecord);
-
-        return DefinitionToDto(definition);
     }
 
     public async virtual Task<ListResultDto<NotificationGroupDefinitionDto>> GetListAsync(NotificationGroupDefinitionGetListInput input)
     {
         var definitionDtoList = new List<NotificationGroupDefinitionDto>();
 
-        var staticGroups = await _staticDefinitionStore.GetGroupsAsync();
+        Expression<Func<NotificationDefinitionGroupRecord, bool>> expression = _ => true;
-        var staticGroupsNames = staticGroups
+        if (!input.Filter.IsNullOrWhiteSpace())
-           .Select(p => p.Name)
+        {
-           .ToImmutableHashSet();
+            expression = expression.And(x => x.Name.Contains(input.Filter));
-        definitionDtoList.AddRange(staticGroups.Select(d => DefinitionToDto(d, true)));
+        }
-
+
-        var dynamicGroups = await _dynamicDefinitionStore.GetGroupsAsync();
+        var definitionRecords = await _definitionGroupRecordRepository.GetListAsync(
-        definitionDtoList.AddRange(dynamicGroups
+            new Volo.Abp.Specifications.ExpressionSpecification<NotificationDefinitionGroupRecord>(expression));
-           .Where(d => !staticGroupsNames.Contains(d.Name))
+
-           .Select(d => DefinitionToDto(d)));
+        definitionDtoList.AddRange(definitionRecords.Select(DefinitionRecordToDto));
-
+
-        return new ListResultDto<NotificationGroupDefinitionDto>(
+        return new ListResultDto<NotificationGroupDefinitionDto>(definitionDtoList);
-            definitionDtoList
-                .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter))
-                .ToList());
     }
 
     [Authorize(NotificationsPermissions.GroupDefinition.Update)]
     public async virtual Task<NotificationGroupDefinitionDto> UpdateAsync(string name, NotificationGroupDefinitionUpdateDto input)
     {
-        var definition = await _staticDefinitionStore.GetGroupOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (definition != null)
+            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(NotificationDefinitionGroupRecord.Name), name);
-            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-              .WithData(nameof(NotificationDefinitionGroupRecord.Name), name);
-        }
-
-        var definitionRecord = await FindByNameAsync(name);
-
-        if (definitionRecord == null)
-        {
-            definitionRecord = new NotificationDefinitionGroupRecord(
-                GuidGenerator.Create(),
-                name,
-                input.DisplayName);
-            UpdateByInput(definitionRecord, input);
 
-            definitionRecord = await _definitionRecordRepository.InsertAsync(definitionRecord);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        }
+        UpdateByInput(definitionRecord, input);
-        else
+        definitionRecord = await _definitionGroupRecordRepository.UpdateAsync(definitionRecord);
-        {
-            UpdateByInput(definitionRecord, input);
-            definitionRecord = await _definitionRecordRepository.UpdateAsync(definitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
         return DefinitionRecordToDto(definitionRecord);
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(NotificationDefinitionGroupRecord record)
+    {
+        if (record.GetProperty(nameof(NotificationGroupDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
+              .WithData(nameof(NotificationDefinitionGroupRecord.Name), record.Name);
+        }
+    }
+
     protected virtual void UpdateByInput(NotificationDefinitionGroupRecord record, NotificationGroupDefinitionCreateOrUpdateDto input)
     {
         record.AllowSubscriptionToClients = input.AllowSubscriptionToClients;
@@ -170,7 +138,7 @@ public class NotificationGroupDefinitionAppService : AbpNotificationsApplication
 
     protected async virtual Task<NotificationDefinitionGroupRecord> FindByNameAsync(string name)
     {
-        var definitionRecord = await _definitionRecordRepository.FindByNameAsync(name);
+        var definitionRecord = await _definitionGroupRecordRepository.FindByNameAsync(name);
 
         return definitionRecord;
     }
@@ -179,7 +147,7 @@ public class NotificationGroupDefinitionAppService : AbpNotificationsApplication
     {
         var dto = new NotificationGroupDefinitionDto
         {
-            IsStatic = false,
+            IsStatic = definitionRecord.GetProperty(nameof(NotificationGroupDefinitionDto.IsStatic), true),
             Name = definitionRecord.Name,
             DisplayName = definitionRecord.DisplayName,
             Description = definitionRecord.Description,
@@ -193,27 +161,4 @@ public class NotificationGroupDefinitionAppService : AbpNotificationsApplication
 
         return dto;
     }
-
-    protected virtual NotificationGroupDefinitionDto DefinitionToDto(NotificationGroupDefinition definition, bool isStatic = false)
-    {
-        var dto = new NotificationGroupDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = definition.Name,
-            AllowSubscriptionToClients = definition.AllowSubscriptionToClients,
-            DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName),
-        };
-
-        if (definition.Description != null)
-        {
-            dto.Description = _localizableStringSerializer.Serialize(definition.Description);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            dto.SetProperty(property.Key, property.Value);
-        }
-
-        return dto;
-    }
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.Application/LINGYUN/Abp/Notifications/Definitions/Notifications/NotificationDefinitionAppService.cs

@@ -2,67 +2,41 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Data;
-using Volo.Abp.Localization;
 
 namespace LINGYUN.Abp.Notifications.Definitions.Notifications;
 
 [Authorize(NotificationsPermissions.Definition.Default)]
 public class NotificationDefinitionAppService : AbpNotificationsApplicationServiceBase, INotificationDefinitionAppService
 {
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly INotificationDefinitionManager _definitionManager;
-    private readonly IStaticNotificationDefinitionStore _staticDefinitionStore;
-    private readonly IDynamicNotificationDefinitionStore _dynamicDefinitionStore;
     private readonly INotificationDefinitionRecordRepository _definitionRecordRepository;
+    private readonly INotificationDefinitionGroupRecordRepository _definitionGroupRecordRepository;
 
     public NotificationDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer,
+        INotificationDefinitionRecordRepository definitionRecordRepository,
-        INotificationDefinitionManager definitionManager,
+        INotificationDefinitionGroupRecordRepository definitionGroupRecordRepository)
-        IStaticNotificationDefinitionStore staticDefinitionStore,
-        IDynamicNotificationDefinitionStore dynamicDefinitionStore, 
-        INotificationDefinitionRecordRepository definitionRecordRepository)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _definitionManager = definitionManager;
-        _staticDefinitionStore = staticDefinitionStore;
-        _dynamicDefinitionStore = dynamicDefinitionStore;
         _definitionRecordRepository = definitionRecordRepository;
+        _definitionGroupRecordRepository = definitionGroupRecordRepository;
     }
 
     [Authorize(NotificationsPermissions.Definition.Create)]
     public async virtual Task<NotificationDefinitionDto> CreateAsync(NotificationDefinitionCreateDto input)
     {
-        if (await _staticDefinitionStore.GetGroupOrNullAsync(input.GroupName) != null)
-        {
-            throw new BusinessException(NotificationsErrorCodes.GroupDefinition.StaticGroupNotAllowedChanged)
-                .WithData(nameof(NotificationDefinitionGroupRecord.Name), input.GroupName);
-        }
-
-        if (await _staticDefinitionStore.GetOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(NotificationsErrorCodes.Definition.AlreayNameExists)
-                .WithData(nameof(NotificationDefinitionRecord.Name), input.Name);
-        }
-
         if (await _definitionRecordRepository.FindByNameAsync(input.Name) != null)
         {
             throw new BusinessException(NotificationsErrorCodes.Definition.AlreayNameExists)
                 .WithData(nameof(NotificationDefinitionRecord.Name), input.Name);
         }
 
-        var groupDefinition = await _definitionManager.GetGroupOrNullAsync(input.GroupName);
+        var groupDefinition = await _definitionGroupRecordRepository.FindByNameAsync(input.GroupName) ??
-        if (groupDefinition == null)
-        {
             throw new BusinessException(NotificationsErrorCodes.GroupDefinition.NameNotFount)
                 .WithData(nameof(NotificationDefinitionGroupRecord.Name), input.GroupName);
-        }
-
         var definitionRecord = new NotificationDefinitionRecord(
             GuidGenerator.Create(),
             input.Name,
@@ -76,6 +50,8 @@ public class NotificationDefinitionAppService : AbpNotificationsApplicationServi
 
         UpdateByInput(definitionRecord, input);
 
+        definitionRecord.SetProperty(nameof(NotificationDefinitionDto.IsStatic), false);
+
         await _definitionRecordRepository.InsertAsync(definitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
@@ -86,107 +62,88 @@ public class NotificationDefinitionAppService : AbpNotificationsApplicationServi
     [Authorize(NotificationsPermissions.Definition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var definitionRecord = await FindRecordByNameAsync(name);
+        var definitionRecord = await FindRecordByNameAsync(name) ??
+            throw new BusinessException(NotificationsErrorCodes.Definition.NameNotFount)
+                .WithData(nameof(NotificationDefinitionRecord.Name), name);
 
-        if (definitionRecord != null)
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        {
-            await _definitionRecordRepository.DeleteAsync(definitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        await _definitionRecordRepository.DeleteAsync(definitionRecord);
-        }
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<NotificationDefinitionDto> GetAsync(string name)
     {
-        var definition = await _staticDefinitionStore.GetOrNullAsync(name);
+        var definitionRecord = await FindRecordByNameAsync(name) ??
-        if (definition != null)
+            throw new BusinessException(NotificationsErrorCodes.Definition.NameNotFount)
-        {
+                .WithData(nameof(NotificationDefinitionRecord.Name), name);
-            return DefinitionToDto(await GetGroupDefinition(definition), definition, true);
+        return DefinitionRecordToDto(definitionRecord);
-        }
-        definition = await _dynamicDefinitionStore.GetOrNullAsync(name);
-        return DefinitionToDto(await GetGroupDefinition(definition), definition);
     }
 
     public async virtual Task<ListResultDto<NotificationDefinitionDto>> GetListAsync(NotificationDefinitionGetListInput input)
     {
         var dtoList = new List<NotificationDefinitionDto>();
 
-        var staticDefinitions = new List<NotificationDefinition>();
+        Expression<Func<NotificationDefinitionRecord, bool>> expression = _ => true;
-
+        if (!input.Filter.IsNullOrWhiteSpace())
-        var staticGroups = await _staticDefinitionStore.GetGroupsAsync();
+        {
-        var staticGroupNames = staticGroups
+            expression = expression.And(x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter));
-            .Select(p => p.Name)
+        }
-            .ToImmutableHashSet();
+        if (!input.Template.IsNullOrWhiteSpace())
-        foreach (var group in staticGroups.WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
+        {
+            expression = expression.And(x => x.Template == input.Template);
+        }
+        if (input.AllowSubscriptionToClients.HasValue)
+        {
+            expression = expression.And(x => x.AllowSubscriptionToClients == input.AllowSubscriptionToClients);
+        }
+        if (input.ContentType.HasValue)
         {
-            var definitions = group.Notifications;
+            expression = expression.And(x => x.ContentType == input.ContentType);
-            staticDefinitions.AddRange(definitions);
-            dtoList.AddRange(definitions.Select(f => DefinitionToDto(group, f, true)));
         }
-        var staticDefinitionNames = staticDefinitions
+        if (input.NotificationLifetime.HasValue)
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        var dynamicGroups = await _dynamicDefinitionStore.GetGroupsAsync();
-        foreach (var group in dynamicGroups
-            .Where(d => !staticGroupNames.Contains(d.Name))
-            .WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.Name == input.GroupName))
         {
-            var definitions = group.Notifications;
+            expression = expression.And(x => x.NotificationLifetime == input.NotificationLifetime);
-            dtoList.AddRange(definitions
-                .Where(d => !staticDefinitionNames.Contains(d.Name))
-                .Select(f => DefinitionToDto(group, f)));
         }
+        if (input.NotificationType.HasValue)
+        {
+            expression = expression.And(x => x.NotificationType == input.NotificationType);
+        }
+
+        var definitionRecords = await _definitionRecordRepository.GetListAsync(
+            new Volo.Abp.Specifications.ExpressionSpecification<NotificationDefinitionRecord>(expression));
 
-        return new ListResultDto<NotificationDefinitionDto>(dtoList
+        dtoList.AddRange(definitionRecords.Select(DefinitionRecordToDto));
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
+
-            .WhereIf(!input.Template.IsNullOrWhiteSpace(), x => x.Template == input.Template)
+        return new ListResultDto<NotificationDefinitionDto>(dtoList);
-            .WhereIf(input.AllowSubscriptionToClients.HasValue, x => x.AllowSubscriptionToClients == input.AllowSubscriptionToClients)
-            .WhereIf(input.ContentType.HasValue, x => x.ContentType == input.ContentType)
-            .WhereIf(input.NotificationLifetime.HasValue, x => x.NotificationLifetime == input.NotificationLifetime)
-            .WhereIf(input.NotificationType.HasValue, x => x.NotificationType == input.NotificationType)
-            .ToList());
     }
 
     [Authorize(NotificationsPermissions.Definition.Update)]
     public async virtual Task<NotificationDefinitionDto> UpdateAsync(string name, NotificationDefinitionUpdateDto input)
     {
-        if (await _staticDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindRecordByNameAsync(name) ??
-        {
+            throw new BusinessException(NotificationsErrorCodes.Definition.NameNotFount)
-            throw new BusinessException(NotificationsErrorCodes.Definition.StaticFeatureNotAllowedChanged)
+                .WithData(nameof(NotificationDefinitionRecord.Name), name);
-              .WithData(nameof(NotificationDefinitionRecord.Name), name);
-        }
 
-        var definition = await _definitionManager.GetAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        var definitionRecord = await FindRecordByNameAsync(name);
+        UpdateByInput(definitionRecord, input);
-
+        definitionRecord = await _definitionRecordRepository.UpdateAsync(definitionRecord);
-        if (definitionRecord == null)
-        {
-            var groupDefinition = await GetGroupDefinition(definition);
-            definitionRecord = new NotificationDefinitionRecord(
-                GuidGenerator.Create(),
-                name,
-                groupDefinition.Name,
-                input.DisplayName,
-                input.Description,
-                input.Template,
-                input.NotificationLifetime,
-                input.NotificationType,
-                input.ContentType);
-            UpdateByInput(definitionRecord, input);
-
-            definitionRecord = await _definitionRecordRepository.InsertAsync(definitionRecord);
-        }
-        else
-        {
-            UpdateByInput(definitionRecord, input);
-            definitionRecord = await _definitionRecordRepository.UpdateAsync(definitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
         return DefinitionRecordToDto(definitionRecord);
     }
 
+    protected virtual void CheckIsStaticDefinitionRecord(NotificationDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(NotificationDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(NotificationsErrorCodes.Definition.StaticFeatureNotAllowedChanged)
+              .WithData(nameof(NotificationDefinitionGroupRecord.Name), record.Name);
+        }
+    }
+
     protected virtual void UpdateByInput(NotificationDefinitionRecord record, NotificationDefinitionCreateOrUpdateDto input)
     {
         record.AllowSubscriptionToClients = input.AllowSubscriptionToClients;
@@ -227,27 +184,11 @@ public class NotificationDefinitionAppService : AbpNotificationsApplicationServi
         return await _definitionRecordRepository.FindByNameAsync(name);
     }
 
-    protected async virtual Task<NotificationGroupDefinition> GetGroupDefinition(NotificationDefinition definition)
-    {
-        var groups = await _definitionManager.GetGroupsAsync();
-
-        foreach (var group in groups)
-        {
-            if (group.GetNotificationOrNull(definition.Name) != null)
-            {
-                return group;
-            }
-        }
-
-        throw new BusinessException(NotificationsErrorCodes.Definition.FailedGetGroup)
-            .WithData(nameof(NotificationDefinitionRecord.Name), definition.Name);
-    }
-
     protected virtual NotificationDefinitionDto DefinitionRecordToDto(NotificationDefinitionRecord definitionRecord)
     {
         var dto = new NotificationDefinitionDto
         {
-            IsStatic = false,
+            IsStatic = definitionRecord.GetProperty(nameof(NotificationDefinitionDto.IsStatic), true),
             Name = definitionRecord.Name,
             GroupName = definitionRecord.GroupName,
             Description = definitionRecord.Description,
@@ -257,11 +198,9 @@ public class NotificationDefinitionAppService : AbpNotificationsApplicationServi
             NotificationLifetime = definitionRecord.NotificationLifetime,
             NotificationType = definitionRecord.NotificationType,
             AllowSubscriptionToClients = definitionRecord.AllowSubscriptionToClients,
-            Providers = definitionRecord.Providers?.Split(",").ToList(),
+            Providers = definitionRecord.Providers?.Split(",").ToList() ?? [],
         };
 
-
-
         foreach (var property in definitionRecord.ExtraProperties)
         {
             dto.SetProperty(property.Key, property.Value);
@@ -269,33 +208,4 @@ public class NotificationDefinitionAppService : AbpNotificationsApplicationServi
 
         return dto;
     }
-
-    protected virtual NotificationDefinitionDto DefinitionToDto(NotificationGroupDefinition groupDefinition, NotificationDefinition definition, bool isStatic = false)
-    {
-        var dto = new NotificationDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = definition.Name,
-            GroupName = groupDefinition.Name,
-            Template = definition.Template?.Name,
-            AllowSubscriptionToClients = definition.AllowSubscriptionToClients,
-            ContentType = definition.ContentType,
-            NotificationLifetime = definition.NotificationLifetime,
-            NotificationType = definition.NotificationType,
-            DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName),
-            Providers = definition.Providers,
-        };
-
-        if (definition.Description != null)
-        {
-            dto.Description = _localizableStringSerializer.Serialize(definition.Description);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            dto.SetProperty(property.Key, property.Value);
-        }
-
-        return dto;
-    }
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.Domain/LINGYUN/Abp/Notifications/INotificationDefinitionGroupRecordRepository.cs

@@ -1,11 +1,19 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.Notifications;
 
 public interface INotificationDefinitionGroupRecordRepository : IBasicRepository<NotificationDefinitionGroupRecord, Guid>
 {
-    Task<NotificationDefinitionGroupRecord> FindByNameAsync(string name, CancellationToken cancellationToken = default);
+    Task<NotificationDefinitionGroupRecord> FindByNameAsync(
+        string name, 
+        CancellationToken cancellationToken = default);
+
+    Task<List<NotificationDefinitionGroupRecord>> GetListAsync(
+        ISpecification<NotificationDefinitionGroupRecord> specification,
+        CancellationToken cancellationToken = default);
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.Domain/LINGYUN/Abp/Notifications/INotificationDefinitionRecordRepository.cs

@@ -1,11 +1,19 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.Notifications;
 
 public interface INotificationDefinitionRecordRepository : IBasicRepository<NotificationDefinitionRecord, Guid>
 {
-    Task<NotificationDefinitionRecord> FindByNameAsync(string name, CancellationToken cancellationToken = default);
+    Task<NotificationDefinitionRecord> FindByNameAsync(
+        string name, 
+        CancellationToken cancellationToken = default);
+
+    Task<List<NotificationDefinitionRecord>> GetListAsync(
+        ISpecification<NotificationDefinitionRecord> specification,
+        CancellationToken cancellationToken = default);
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.EntityFrameworkCore/LINGYUN/Abp/Notifications/EntityFrameworkCore/EfCoreNotificationDefinitionGroupRecordRepository.cs

@@ -1,5 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Dynamic.Core;
 using System.Threading;
@@ -7,6 +8,7 @@ using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.Notifications.EntityFrameworkCore;
 
@@ -21,10 +23,21 @@ public class EfCoreNotificationDefinitionGroupRecordRepository :
     {
     }
 
-    public async virtual Task<NotificationDefinitionGroupRecord> FindByNameAsync(string name, CancellationToken cancellationToken = default)
+    public async virtual Task<NotificationDefinitionGroupRecord> FindByNameAsync(
+        string name,
+        CancellationToken cancellationToken = default)
     {
         return await (await GetDbSetAsync())
             .Where(x => x.Name == name)
             .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
     }
+
+    public async virtual Task<List<NotificationDefinitionGroupRecord>> GetListAsync(
+        ISpecification<NotificationDefinitionGroupRecord> specification,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(specification.ToExpression())
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 }

aspnet-core/modules/realtime-notifications/LINGYUN.Abp.Notifications.EntityFrameworkCore/LINGYUN/Abp/Notifications/EntityFrameworkCore/EfCoreNotificationDefinitionRecordRepository.cs

@@ -1,11 +1,14 @@
 using Microsoft.EntityFrameworkCore;
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Dynamic.Core;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.Notifications.EntityFrameworkCore;
 
@@ -20,10 +23,22 @@ public class EfCoreNotificationDefinitionRecordRepository :
     {
     }
 
-    public async virtual Task<NotificationDefinitionRecord> FindByNameAsync(string name, CancellationToken cancellationToken = default)
+    public async virtual Task<NotificationDefinitionRecord> FindByNameAsync(
+        string name, 
+        CancellationToken cancellationToken = default)
     {
         return await (await GetDbSetAsync())
             .Where(x => x.Name == name)
             .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
     }
+
+
+    public async virtual Task<List<NotificationDefinitionRecord>> GetListAsync(
+        ISpecification<NotificationDefinitionRecord> specification,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(specification.ToExpression())
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 }

aspnet-core/modules/settings/LINGYUN.Abp.SettingManagement.Application/LINGYUN/Abp/SettingManagement/Localization/Resources/en.json

@@ -2,6 +2,7 @@
   "culture": "en",
   "texts": {
     "SettingManagement:001001": "A setting definition called {Name} already exists!",
+    "SettingManagement:001002": "There is no setting definition named {Name}!",
     "SettingManagement:001010": "The {Name} static setting is not allowed to change!",
     "Permission:Definition": "Definition Settings",
     "Permission:Create": "Create",

aspnet-core/modules/settings/LINGYUN.Abp.SettingManagement.Application/LINGYUN/Abp/SettingManagement/Localization/Resources/zh-Hans.json

@@ -2,6 +2,7 @@
   "culture": "zh-Hans",
   "texts": {
     "SettingManagement:001001": "已经存在名为 {Name} 的设置定义!",
+    "SettingManagement:001002": "没有名为 {Name} 的设置定义!",
     "SettingManagement:001010": "静态设置项 {Name} 不允许变更!",
     "Permission:Definition": "定义设置",
     "Permission:Create": "新增",

aspnet-core/modules/settings/LINGYUN.Abp.SettingManagement.Application/LINGYUN/Abp/SettingManagement/SettingDefinitionAppService.cs

@@ -1,8 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -19,26 +19,17 @@ namespace LINGYUN.Abp.SettingManagement;
 public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISettingDefinitionAppService
 {
     private readonly IStringEncryptionService _stringEncryptionService;
-    private readonly ISettingDefinitionManager _settingDefinitionManager;
     private readonly ISettingValueProviderManager _settingValueProviderManager;
-    private readonly IStaticSettingDefinitionStore _staticSettingDefinitionStore;
-    private readonly IDynamicSettingDefinitionStore _dynamicSettingDefinitionStore;
     private readonly ILocalizableStringSerializer _localizableStringSerializer;
     private readonly IRepository<SettingDefinitionRecord, Guid> _settingRepository;
 
     public SettingDefinitionAppService(
         IStringEncryptionService stringEncryptionService, 
-        ISettingDefinitionManager settingDefinitionManager,
-        IStaticSettingDefinitionStore staticSettingDefinitionStore,
-        IDynamicSettingDefinitionStore dynamicSettingDefinitionStore,
         ILocalizableStringSerializer localizableStringSerializer,
         IRepository<SettingDefinitionRecord, Guid> settingRepository,
         ISettingValueProviderManager settingValueProviderManager)
     {
         _stringEncryptionService = stringEncryptionService;
-        _settingDefinitionManager = settingDefinitionManager;
-        _staticSettingDefinitionStore = staticSettingDefinitionStore;
-        _dynamicSettingDefinitionStore = dynamicSettingDefinitionStore;
         _localizableStringSerializer = localizableStringSerializer;
         _settingRepository = settingRepository;
         _settingValueProviderManager = settingValueProviderManager;
@@ -47,12 +38,6 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
     [Authorize(SettingManagementPermissions.Definition.Create)]
     public async virtual Task<SettingDefinitionDto> CreateAsync(SettingDefinitionCreateDto input)
     {
-        if (await _staticSettingDefinitionStore.GetOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(SettingManagementErrorCodes.Definition.DuplicateName)
-                .WithData("Name", input.Name);
-        }
-
         var settingDefinitionRecord = await _settingRepository.FindAsync(x => x.Name == input.Name);
         if (settingDefinitionRecord != null)
         {
@@ -79,6 +64,7 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
         {
             settingDefinitionRecord.ExtraProperties.Add(property.Key, property.Value);
         }
+        settingDefinitionRecord.SetProperty(nameof(SettingDefinitionDto.IsStatic), false);
 
         settingDefinitionRecord = await _settingRepository.InsertAsync(settingDefinitionRecord);
 
@@ -90,24 +76,23 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
     [Authorize(SettingManagementPermissions.Definition.DeleteOrRestore)]
     public async virtual Task DeleteOrRestoreAsync(string name)
     {
-        var settingDefinitionRecord = await _settingRepository.FindAsync(x => x.Name == name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (settingDefinitionRecord != null)
+            throw new BusinessException(SettingManagementErrorCodes.Definition.NameNotFount)
-        {
+                .WithData(nameof(SettingDefinitionRecord.Name), name);
-            await _settingRepository.DeleteAsync(settingDefinitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        }
+
+        await _settingRepository.DeleteAsync(definitionRecord);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<SettingDefinitionDto> GetAsync(string name)
     {
-        var settingDefinition = await _staticSettingDefinitionStore.GetOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (settingDefinition != null)
+            throw new BusinessException(SettingManagementErrorCodes.Definition.NameNotFount)
-        {
+                .WithData(nameof(SettingDefinitionRecord.Name), name);
-            return DefinitionToDto(settingDefinition, true);
+        var dto = DefinitionRecordToDto(definitionRecord);
-        }
-        settingDefinition = await _dynamicSettingDefinitionStore.GetOrNullAsync(name);
-        var dto = DefinitionToDto(settingDefinition);
         if (dto.IsEncrypted && !string.IsNullOrWhiteSpace(dto.DefaultValue))
         {
             dto.DefaultValue = _stringEncryptionService.Decrypt(dto.DefaultValue);
@@ -118,21 +103,20 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
     public async virtual Task<ListResultDto<SettingDefinitionDto>> GetListAsync(SettingDefinitionGetListInput input)
     {
         var settingDtoList = new List<SettingDefinitionDto>();
-        var staticSettings = await _staticSettingDefinitionStore.GetAllAsync();
-        var staticSettingNames = staticSettings
-            .Select(p => p.Name)
-            .ToImmutableHashSet();
-        settingDtoList.AddRange(staticSettings.Select(d => DefinitionToDto(d, true)));
 
-        var dynamicSettings = await _dynamicSettingDefinitionStore.GetAllAsync();
+        Expression<Func<SettingDefinitionRecord, bool>> predicate = _ => true;
-        settingDtoList.AddRange(dynamicSettings
+        if (!input.ProviderName.IsNullOrWhiteSpace())
-            .Where(d => !staticSettingNames.Contains(d.Name))
+        {
-            .Select(d => DefinitionToDto(d)));
+            predicate = predicate.And(x => x.Providers.Contains(input.ProviderName));
+        }
+        if (!input.Filter.IsNullOrWhiteSpace())
+        {
+            predicate = predicate.And(x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter));
+        }
+        var settingDefinitionRecords = await _settingRepository.GetListAsync();
+        settingDtoList.AddRange(settingDefinitionRecords.Select(DefinitionRecordToDto).Where(dto => dto != null));
 
-        return new ListResultDto<SettingDefinitionDto>(settingDtoList
+        return new ListResultDto<SettingDefinitionDto>(settingDtoList);
-            .WhereIf(!input.ProviderName.IsNullOrWhiteSpace(), x => x.Providers.Contains(input.ProviderName))
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
-            .ToList());
     }
 
     public virtual Task<ListResultDto<NameValue<string>>> GetAssignableProvidersAsync()
@@ -155,37 +139,31 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
     [Authorize(SettingManagementPermissions.Definition.Update)]
     public async virtual Task<SettingDefinitionDto> UpdateAsync(string name, SettingDefinitionUpdateDto input)
     {
-        if (await _staticSettingDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindByNameAsync(name) ??
-        {
+            throw new BusinessException(SettingManagementErrorCodes.Definition.NameNotFount)
-            throw new BusinessException(SettingManagementErrorCodes.Definition.StaticSettingNotAllowedChanged)
+                .WithData(nameof(SettingDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var settingDefinitionRecord = await _settingRepository.FindAsync(x => x.Name == name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        if (settingDefinitionRecord == null)
+        UpdateByInput(definitionRecord, input);
-        {
+        definitionRecord = await _settingRepository.UpdateAsync(definitionRecord);
-            settingDefinitionRecord = new SettingDefinitionRecord(
-               GuidGenerator.Create(),
-               name,
-               input.DisplayName,
-               input.Description,
-               input.DefaultValue,
-               input.IsVisibleToClients,
-               input.Providers?.JoinAsString(","),
-               input.IsInherited,
-               input.IsEncrypted);
-            UpdateByInput(settingDefinitionRecord, input);
-            settingDefinitionRecord = await _settingRepository.InsertAsync(settingDefinitionRecord);
-        }
-        else
-        {
-            UpdateByInput(settingDefinitionRecord, input);
-            settingDefinitionRecord = await _settingRepository.UpdateAsync(settingDefinitionRecord);
-        }
 
         await CurrentUnitOfWork.SaveChangesAsync();
 
-        return DefinitionRecordToDto(settingDefinitionRecord);
+        return DefinitionRecordToDto(definitionRecord);
+    }
+
+    protected async virtual Task<SettingDefinitionRecord> FindByNameAsync(string name)
+    {
+        return await _settingRepository.FindAsync(x => x.Name == name);
+    }
+
+    protected virtual void CheckIsStaticDefinitionRecord(SettingDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(SettingDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(SettingManagementErrorCodes.Definition.StaticSettingNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
     }
 
     protected virtual void UpdateByInput(SettingDefinitionRecord record, SettingDefinitionCreateOrUpdateDto input)
@@ -222,6 +200,10 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
 
     protected virtual SettingDefinitionDto DefinitionRecordToDto(SettingDefinitionRecord definitionRecord)
     {
+        if (definitionRecord == null)
+        {
+            return null;
+        }
         var dto = new SettingDefinitionDto
         {
             Name = definitionRecord.Name,
@@ -231,7 +213,8 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
             DisplayName = definitionRecord.DisplayName,
             IsEncrypted = definitionRecord.IsEncrypted,
             IsInherited = definitionRecord.IsInherited,
-            Providers = definitionRecord.Providers?.Split(',').ToList(),
+            Providers = definitionRecord.Providers?.Split(',').ToList() ?? [],
+            IsStatic = definitionRecord.GetProperty(nameof(SettingDefinitionDto.IsStatic), true),
         };
 
         foreach (var property in definitionRecord.ExtraProperties)
@@ -241,35 +224,4 @@ public class SettingDefinitionAppService : SettingManagementAppServiceBase, ISet
 
         return dto;
     }
-
-    protected virtual SettingDefinitionDto DefinitionToDto(SettingDefinition definition, bool isStatic = false)
-    {
-        var dto = new SettingDefinitionDto
-        {
-            IsStatic = isStatic,
-            Name = definition.Name,
-            IsVisibleToClients = definition.IsVisibleToClients,
-            DefaultValue = definition.DefaultValue,
-            IsEncrypted = definition.IsEncrypted,
-            IsInherited = definition.IsInherited,
-            Providers = definition.Providers,
-        };
-
-        if (definition.DisplayName != null)
-        {
-            dto.DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName);
-        }
-
-        if (definition.Description != null)
-        {
-            dto.Description = _localizableStringSerializer.Serialize(definition.Description);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            dto.SetProperty(property.Key, property.Value);
-        }
-
-        return dto;
-    }
 }

aspnet-core/modules/settings/LINGYUN.Abp.SettingManagement.Application/LINGYUN/Abp/SettingManagement/SettingManagementErrorCodes.cs

@@ -9,6 +9,8 @@ public static class SettingManagementErrorCodes
 
         public const string DuplicateName = Prefix + "001";
 
+        public const string NameNotFount = Prefix + "002";
+
         public const string StaticSettingNotAllowedChanged = Prefix + "010";
     }
 }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Application/LINGYUN/Abp/WebhooksManagement/Definitions/WebhookDefinitionAppService.cs

@@ -1,69 +1,54 @@
-using LINGYUN.Abp.Webhooks;
+using LINGYUN.Abp.WebhooksManagement.Authorization;
-using LINGYUN.Abp.WebhooksManagement.Authorization;
 using LINGYUN.Abp.WebhooksManagement.Definitions.Dto;
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Data;
-using Volo.Abp.Localization;
 
 namespace LINGYUN.Abp.WebhooksManagement.Definitions;
 
 [Authorize(WebhooksManagementPermissions.WebhookDefinition.Default)]
 public class WebhookDefinitionAppService : WebhooksManagementAppServiceBase, IWebhookDefinitionAppService
 {
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IWebhookDefinitionManager _webhookDefinitionManager;
-    private readonly IStaticWebhookDefinitionStore _staticWebhookDefinitionStore;
     private readonly IWebhookDefinitionRecordRepository _webhookDefinitionRecordRepository;
+    private readonly IWebhookGroupDefinitionRecordRepository _webhookGroupDefinitionRecordRepository;
 
     public WebhookDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer,
-        IWebhookDefinitionManager webhookDefinitionManager,
         IWebhookDefinitionRecordRepository webhookDefinitionRecordRepository,
-        IStaticWebhookDefinitionStore staticWebhookDefinitionStore)
+        IWebhookGroupDefinitionRecordRepository webhookGroupDefinitionRecordRepository)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _webhookDefinitionManager = webhookDefinitionManager;
         _webhookDefinitionRecordRepository = webhookDefinitionRecordRepository;
-        _staticWebhookDefinitionStore = staticWebhookDefinitionStore;
+        _webhookGroupDefinitionRecordRepository = webhookGroupDefinitionRecordRepository;
     }
 
     [Authorize(WebhooksManagementPermissions.WebhookDefinition.Create)]
     public async virtual Task<WebhookDefinitionDto> CreateAsync(WebhookDefinitionCreateDto input)
     {
-        if (await _staticWebhookDefinitionStore.GetGroupOrNullAsync(input.GroupName) != null)
-        {
-            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.StaticGroupNotAllowedChanged)
-                .WithData(nameof(WebhookDefinitionRecord.Name), input.GroupName);
-        }
-
-        if (await _webhookDefinitionManager.GetOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.AlreayNameExists)
-                .WithData(nameof(WebhookDefinitionRecord.Name), input.Name);
-        }
-
         var webhookDefinitionRecord = await _webhookDefinitionRecordRepository.FindByNameAsync(input.Name);
         if (webhookDefinitionRecord != null)
         {
             throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.AlreayNameExists)
                .WithData("Name", input.Name);
         }
+        var webhookDefinitionGroupRecord = await _webhookGroupDefinitionRecordRepository.FindByNameAsync(input.GroupName)
+            ?? throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.StaticGroupNotAllowedChanged)
+                .WithData(nameof(WebhookDefinitionRecord.Name), input.GroupName);
 
         webhookDefinitionRecord = new WebhookDefinitionRecord(
             GuidGenerator.Create(),
-            input.GroupName,
+            webhookDefinitionGroupRecord.Name,
             input.Name,
             input.DisplayName);
         UpdateByInput(webhookDefinitionRecord, input);
 
+        webhookDefinitionRecord.SetProperty(nameof(WebhookDefinitionDto.IsStatic), false);
+
         await _webhookDefinitionRecordRepository.InsertAsync(webhookDefinitionRecord);
 
         await CurrentUnitOfWork.SaveChangesAsync();
@@ -74,78 +59,75 @@ public class WebhookDefinitionAppService : WebhooksManagementAppServiceBase, IWe
     [Authorize(WebhooksManagementPermissions.WebhookDefinition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var webhookDefinitionRecord = await _webhookDefinitionRecordRepository.FindByNameAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (webhookDefinitionRecord != null)
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.NameNotFount)
-        {
+                .WithData(nameof(WebhookDefinitionRecord.Name), name);
-            await _webhookDefinitionRecordRepository.DeleteAsync(webhookDefinitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        }
+        await _webhookDefinitionRecordRepository.DeleteAsync(definitionRecord);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<WebhookDefinitionDto> GetAsync(string name)
     {
-        var webhookDefinition = await _staticWebhookDefinitionStore.GetOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (webhookDefinition != null)
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.NameNotFount)
-        {
+                .WithData(nameof(WebhookDefinitionRecord.Name), name);
-            return DefinitionToDto(webhookDefinition, true);
+
-        }
+        return DefinitionRecordToDto(definitionRecord);
-        var webhookDefinitionRecord = await _webhookDefinitionRecordRepository.GetByNameAsync(name);
-        return DefinitionRecordToDto(webhookDefinitionRecord);
     }
 
     public async virtual Task<ListResultDto<WebhookDefinitionDto>> GetListAsync(WebhookDefinitionGetListInput input)
     {
         var webhookDtoList = new List<WebhookDefinitionDto>();
-        var staticWebhooks = await _staticWebhookDefinitionStore.GetWebhooksAsync();
+
-        var staticWebhookNames = staticWebhooks
+        Expression<Func<WebhookDefinitionRecord, bool>> expression = _ => true;
-            .Select(p => p.Name)
+        if (!input.Filter.IsNullOrWhiteSpace())
-            .ToImmutableHashSet();
+        {
-        webhookDtoList.AddRange(staticWebhooks.Select(d => DefinitionToDto(d, true, true)));
+            expression = expression.And(x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter));
-
+        }
-        var dynamicWebhooks = await _webhookDefinitionRecordRepository.GetListAsync();
+        if (!input.GroupName.IsNullOrWhiteSpace())
-        webhookDtoList.AddRange(dynamicWebhooks
+        {
-            .Where(d => !staticWebhookNames.Contains(d.Name))
+            expression = expression.And(x => x.GroupName == input.GroupName);
-            .Select(d => DefinitionRecordToDto(d)));
+        }
-
+
-        return new ListResultDto<WebhookDefinitionDto>(webhookDtoList
+        var definitionRecords = await _webhookDefinitionRecordRepository.GetListAsync(
-            .WhereIf(!input.GroupName.IsNullOrWhiteSpace(), x => x.GroupName.Equals(input.GroupName))
+            new Volo.Abp.Specifications.ExpressionSpecification<WebhookDefinitionRecord>(expression));
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
+
-            .ToList());
+        webhookDtoList.AddRange(definitionRecords.Select(DefinitionRecordToDto));
+
+        return new ListResultDto<WebhookDefinitionDto>(webhookDtoList);
     }
 
     [Authorize(WebhooksManagementPermissions.WebhookDefinition.Update)]
     public async virtual Task<WebhookDefinitionDto> UpdateAsync(string name, WebhookDefinitionUpdateDto input)
     {
-        if (await _staticWebhookDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindByNameAsync(name) ??
-        {
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.NameNotFount)
-            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.StaticWebhookNotAllowedChanged)
+                .WithData(nameof(WebhookDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var webhookDefinition = await _webhookDefinitionManager.GetAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        var webhookDefinitionRecord = await _webhookDefinitionRecordRepository.FindByNameAsync(name);
+        UpdateByInput(definitionRecord, input);
+        definitionRecord = await _webhookDefinitionRecordRepository.UpdateAsync(definitionRecord);
 
-        if (webhookDefinitionRecord == null)
-        {
-            webhookDefinitionRecord = new WebhookDefinitionRecord(
-                GuidGenerator.Create(),
-                webhookDefinition.GroupName,
-                name,
-                input.DisplayName);
-            UpdateByInput(webhookDefinitionRecord, input);
-
-            webhookDefinitionRecord = await _webhookDefinitionRecordRepository.InsertAsync(webhookDefinitionRecord);
-        }
-        else
-        {
-            UpdateByInput(webhookDefinitionRecord, input);
-            webhookDefinitionRecord = await _webhookDefinitionRecordRepository.UpdateAsync(webhookDefinitionRecord);
-        }
-        
         await CurrentUnitOfWork.SaveChangesAsync();
 
-        return DefinitionRecordToDto(webhookDefinitionRecord);
+        return DefinitionRecordToDto(definitionRecord);
+    }
+
+    protected async virtual Task<WebhookDefinitionRecord> FindByNameAsync(string name)
+    {
+        return await _webhookDefinitionRecordRepository.FindByNameAsync(name);
+    }
+
+    protected virtual void CheckIsStaticDefinitionRecord(WebhookDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(WebhookDefinitionDto.IsStatic), true))
+        {
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookDefinition.StaticWebhookNotAllowedChanged)
+              .WithData("Name", record.Name);
+        }
     }
 
     protected virtual void UpdateByInput(WebhookDefinitionRecord record, WebhookDefinitionCreateOrUpdateDto input)
@@ -181,12 +163,13 @@ public class WebhookDefinitionAppService : WebhooksManagementAppServiceBase, IWe
     {
         var webhookDto = new WebhookDefinitionDto
         {
-            IsStatic = false,
+            IsStatic = record.GetProperty(nameof(WebhookDefinitionDto.IsStatic), true),
             Description = record.Description,
             DisplayName = record.DisplayName,
             GroupName = record.GroupName,
             IsEnabled = record.IsEnabled,
             Name = record.Name,
+            RequiredFeatures = [],
         };
 
         if (!record.RequiredFeatures.IsNullOrWhiteSpace())
@@ -201,29 +184,4 @@ public class WebhookDefinitionAppService : WebhooksManagementAppServiceBase, IWe
 
         return webhookDto;
     }
-
-    protected virtual WebhookDefinitionDto DefinitionToDto(WebhookDefinition definition, bool isStatic = false, bool isEnabled = true)
-    {
-        var webhookDto = new WebhookDefinitionDto
-        {
-            GroupName = definition.GroupName,
-            Name = definition.Name,
-            IsStatic = isStatic,
-            IsEnabled = isEnabled,
-            RequiredFeatures = definition.RequiredFeatures,
-            DisplayName = _localizableStringSerializer.Serialize(definition.DisplayName),
-        };
-
-        if (definition.Description != null)
-        {
-            webhookDto.Description = _localizableStringSerializer.Serialize(definition.Description);
-        }
-
-        foreach (var property in definition.Properties)
-        {
-            webhookDto.SetProperty(property.Key, property.Value);
-        }
-
-        return webhookDto;
-    }
 }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Application/LINGYUN/Abp/WebhooksManagement/Definitions/WebhookGroupDefinitionAppService.cs

@@ -1,51 +1,31 @@
-using LINGYUN.Abp.Webhooks;
+using LINGYUN.Abp.WebhooksManagement.Authorization;
-using LINGYUN.Abp.WebhooksManagement.Authorization;
 using Microsoft.AspNetCore.Authorization;
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Data;
-using Volo.Abp.Localization;
 
 namespace LINGYUN.Abp.WebhooksManagement.Definitions;
 
 [Authorize(WebhooksManagementPermissions.WebhookGroupDefinition.Default)]
 public class WebhookGroupDefinitionAppService : WebhooksManagementAppServiceBase, IWebhookGroupDefinitionAppService
 {
-    private readonly ILocalizableStringSerializer _localizableStringSerializer;
-    private readonly IWebhookDefinitionManager _webhookDefinitionManager;
-    private readonly IStaticWebhookDefinitionStore _staticWebhookDefinitionStore;
-    private readonly IDynamicWebhookDefinitionStore _dynamicWebhookDefinitionStore;
     private readonly IWebhookGroupDefinitionRecordRepository _webhookGroupDefinitionRecordRepository;
 
     public WebhookGroupDefinitionAppService(
-        ILocalizableStringSerializer localizableStringSerializer,
+        IWebhookGroupDefinitionRecordRepository webhookGroupDefinitionRecordRepository)
-        IWebhookDefinitionManager webhookDefinitionManager,
-        IWebhookGroupDefinitionRecordRepository webhookGroupDefinitionRecordRepository,
-        IStaticWebhookDefinitionStore staticWebhookDefinitionStore,
-        IDynamicWebhookDefinitionStore dynamicWebhookDefinitionStore)
     {
-        _localizableStringSerializer = localizableStringSerializer;
-        _webhookDefinitionManager = webhookDefinitionManager;
         _webhookGroupDefinitionRecordRepository = webhookGroupDefinitionRecordRepository;
-        _staticWebhookDefinitionStore = staticWebhookDefinitionStore;
-        _dynamicWebhookDefinitionStore = dynamicWebhookDefinitionStore;
     }
 
     [Authorize(WebhooksManagementPermissions.WebhookGroupDefinition.Create)]
     public async virtual Task<WebhookGroupDefinitionDto> CreateAsync(WebhookGroupDefinitionCreateDto input)
     {
-        if (await _webhookDefinitionManager.GetGroupOrNullAsync(input.Name) != null)
-        {
-            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.AlreayNameExists)
-                .WithData(nameof(WebhookGroupDefinitionRecord.Name), input.Name);
-        }
-
         var webhookGroupDefinitionRecord = await _webhookGroupDefinitionRecordRepository.FindByNameAsync(input.Name);
         if (webhookGroupDefinitionRecord != null)
         {
@@ -62,6 +42,7 @@ public class WebhookGroupDefinitionAppService : WebhooksManagementAppServiceBase
         {
             webhookGroupDefinitionRecord.SetProperty(property.Key, property.Value);
         }
+        webhookGroupDefinitionRecord.SetProperty(nameof(WebhookGroupDefinitionDto.IsStatic), false);
 
         await _webhookGroupDefinitionRecordRepository.InsertAsync(webhookGroupDefinitionRecord);
 
@@ -73,118 +54,94 @@ public class WebhookGroupDefinitionAppService : WebhooksManagementAppServiceBase
     [Authorize(WebhooksManagementPermissions.WebhookGroupDefinition.Delete)]
     public async virtual Task DeleteAsync(string name)
     {
-        var webhookGroupDefinitionRecord = await _webhookGroupDefinitionRecordRepository.FindByNameAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (webhookGroupDefinitionRecord != null)
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(WebhookGroupDefinitionRecord.Name), name);
-            await _webhookGroupDefinitionRecordRepository.DeleteAsync(webhookGroupDefinitionRecord);
 
-            await CurrentUnitOfWork.SaveChangesAsync();
+        CheckIsStaticDefinitionRecord(definitionRecord);
-        }
+        await _webhookGroupDefinitionRecordRepository.DeleteAsync(definitionRecord);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
     }
 
     public async virtual Task<WebhookGroupDefinitionDto> GetAsync(string name)
     {
-        var webhookGroupDefinition = await _staticWebhookDefinitionStore.GetGroupOrNullAsync(name);
+        var definitionRecord = await FindByNameAsync(name) ??
-        if (webhookGroupDefinition != null)
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.NameNotFount)
-        {
+                .WithData(nameof(WebhookGroupDefinitionRecord.Name), name);
-            return DefinitionToDto(webhookGroupDefinition, true);
+
-        }
+        return DefinitionRecordToDto(definitionRecord);
-        webhookGroupDefinition = await _dynamicWebhookDefinitionStore.GetGroupOrNullAsync(name);
-        return DefinitionToDto(webhookGroupDefinition);
     }
 
     public async virtual Task<ListResultDto<WebhookGroupDefinitionDto>> GetListAsync(WebhookGroupDefinitionGetListInput input)
     {
         var groupDtoList = new List<WebhookGroupDefinitionDto>();
-        var staticGroups = await _staticWebhookDefinitionStore.GetGroupsAsync();
+
-        var staticGroupNames = staticGroups
+        Expression<Func<WebhookGroupDefinitionRecord, bool>> expression = _ => true;
-            .Select(p => p.Name)
+        if (!input.Filter.IsNullOrWhiteSpace())
-            .ToImmutableHashSet();
+        {
-        groupDtoList.AddRange(staticGroups.Select(d => DefinitionToDto(d, true)));
+            expression = expression.And(x => x.Name.Contains(input.Filter));
-
+        }
-        var dynamicGroups = await _dynamicWebhookDefinitionStore.GetGroupsAsync();
+
-        groupDtoList.AddRange(dynamicGroups
+        var definitionRecords = await _webhookGroupDefinitionRecordRepository.GetListAsync(
-            .Where(d => !staticGroupNames.Contains(d.Name))
+            new Volo.Abp.Specifications.ExpressionSpecification<WebhookGroupDefinitionRecord>(expression));
-            .Select(d => DefinitionToDto(d)));
+
-
+        groupDtoList.AddRange(definitionRecords.Select(DefinitionRecordToDto));
-        return new ListResultDto<WebhookGroupDefinitionDto>(groupDtoList
+
-            .WhereIf(!input.Filter.IsNullOrWhiteSpace(), x => x.Name.Contains(input.Filter) || x.DisplayName.Contains(input.Filter))
+        return new ListResultDto<WebhookGroupDefinitionDto>(groupDtoList);
-            .ToList());
     }
 
     [Authorize(WebhooksManagementPermissions.WebhookGroupDefinition.Update)]
     public async virtual Task<WebhookGroupDefinitionDto> UpdateAsync(string name, WebhookGroupDefinitionUpdateDto input)
     {
-        if (await _staticWebhookDefinitionStore.GetOrNullAsync(name) != null)
+        var definitionRecord = await FindByNameAsync(name) ??
-        {
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.NameNotFount)
-            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.StaticGroupNotAllowedChanged)
+                .WithData(nameof(WebhookGroupDefinitionRecord.Name), name);
-              .WithData("Name", name);
-        }
 
-        var webhookGroupDefinitionRecord = await _webhookGroupDefinitionRecordRepository.FindByNameAsync(name);
+        CheckIsStaticDefinitionRecord(definitionRecord);
 
-        if (webhookGroupDefinitionRecord == null)
+        definitionRecord.ExtraProperties.Clear();
+        foreach (var property in input.ExtraProperties)
         {
-            webhookGroupDefinitionRecord = new WebhookGroupDefinitionRecord(
+            definitionRecord.SetProperty(property.Key, property.Value);
-                GuidGenerator.Create(),
-                name,
-                input.DisplayName);
-
-            foreach (var property in input.ExtraProperties)
-            {
-                webhookGroupDefinitionRecord.SetProperty(property.Key, property.Value);
-            }
-
-            webhookGroupDefinitionRecord = await _webhookGroupDefinitionRecordRepository.InsertAsync(webhookGroupDefinitionRecord);
         }
-        else
+
+        if (!string.Equals(definitionRecord.DisplayName, input.DisplayName, StringComparison.InvariantCultureIgnoreCase))
         {
-            webhookGroupDefinitionRecord.ExtraProperties.Clear();
+            definitionRecord.DisplayName = input.DisplayName;
-            foreach (var property in input.ExtraProperties)
-            {
-                webhookGroupDefinitionRecord.SetProperty(property.Key, property.Value);
-            }
-
-            if (!string.Equals(webhookGroupDefinitionRecord.DisplayName, input.DisplayName, StringComparison.InvariantCultureIgnoreCase))
-            {
-                webhookGroupDefinitionRecord.DisplayName = input.DisplayName;
-            }
-
-            webhookGroupDefinitionRecord = await _webhookGroupDefinitionRecordRepository.UpdateAsync(webhookGroupDefinitionRecord);
         }
 
+        definitionRecord = await _webhookGroupDefinitionRecordRepository.UpdateAsync(definitionRecord);
+
         await CurrentUnitOfWork.SaveChangesAsync();
 
-        return DefinitionRecordToDto(webhookGroupDefinitionRecord);
+        return DefinitionRecordToDto(definitionRecord);
     }
 
-    protected virtual WebhookGroupDefinitionDto DefinitionRecordToDto(WebhookGroupDefinitionRecord webhookGroupDefinitionRecord)
+    protected async virtual Task<WebhookGroupDefinitionRecord> FindByNameAsync(string name)
     {
-        var webhookGroupDto = new WebhookGroupDefinitionDto
+        return await _webhookGroupDefinitionRecordRepository.FindByNameAsync(name);
-        {
+    }
-            Name = webhookGroupDefinitionRecord.Name,
-            DisplayName = webhookGroupDefinitionRecord.DisplayName,
-            IsStatic = false,
-        };
 
-        foreach (var property in webhookGroupDefinitionRecord.ExtraProperties)
+    protected virtual void CheckIsStaticDefinitionRecord(WebhookGroupDefinitionRecord record)
+    {
+        if (record.GetProperty(nameof(WebhookGroupDefinitionDto.IsStatic), true))
         {
-            webhookGroupDto.SetProperty(property.Key, property.Value);
+            throw new BusinessException(WebhooksManagementErrorCodes.WebhookGroupDefinition.StaticGroupNotAllowedChanged)
+              .WithData("Name", record.Name);
         }
-
-        return webhookGroupDto;
     }
 
-    protected virtual WebhookGroupDefinitionDto DefinitionToDto(WebhookGroupDefinition webhookGroupDefinition, bool isStatic = false)
+    protected virtual WebhookGroupDefinitionDto DefinitionRecordToDto(WebhookGroupDefinitionRecord webhookGroupDefinitionRecord)
     {
         var webhookGroupDto = new WebhookGroupDefinitionDto
         {
-            Name = webhookGroupDefinition.Name,
+            Name = webhookGroupDefinitionRecord.Name,
-            IsStatic = isStatic,
+            DisplayName = webhookGroupDefinitionRecord.DisplayName,
-            DisplayName = _localizableStringSerializer.Serialize(webhookGroupDefinition.DisplayName),
+            IsStatic = webhookGroupDefinitionRecord.GetProperty(nameof(WebhookGroupDefinitionDto.IsStatic), true),
         };
 
-        foreach (var property in webhookGroupDefinition.Properties)
+        foreach (var property in webhookGroupDefinitionRecord.ExtraProperties)
         {
             webhookGroupDto.SetProperty(property.Key, property.Value);
         }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Domain.Shared/LINGYUN/Abp/WebhooksManagement/Localization/Resources/en.json

@@ -14,8 +14,10 @@
     "Permission:Publish": "Publish",
     "Permission:ManageSettings": "Manage Settings",
     "Webhooks:001001": "A group named {Name} already exists!",
+    "Webhooks:001002": "There is no group definition named {Name}!",
     "Webhooks:001010": "Static Webhooks group {Name} is not allowed to change!",
     "Webhooks:002001": "A record named {Name} already exists!",
+    "Webhooks:002002": "There is no webhook named {Name} defined!",
     "Webhooks:002010": "The {Name} static Webhook item is not allowed to change!",
     "Webhooks:010001": "Payload address {WebhookUri} has been mounted event {Webhooks}!",
     "Webhooks:Tests": "Tests",

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Domain.Shared/LINGYUN/Abp/WebhooksManagement/Localization/Resources/zh-Hans.json

@@ -14,8 +14,10 @@
     "Permission:Publish": "发布事件",
     "Permission:ManageSettings": "管理设置",
     "Webhooks:001001": "已经存在一个名为 {Name} 的分组!",
+    "Webhooks:001002": "没有名为 {Name} 的分组定义!",
     "Webhooks:001010": "静态Webhooks分组 {Name} 不允许变更!",
     "Webhooks:002001": "已经存在一个名为 {Name} 的记录!",
+    "Webhooks:002002": "没有名为 {Name} 的Webhook定义!",
     "Webhooks:002010": "静态Webhook项 {Name} 不允许变更!",
     "Webhooks:010001": "载荷地址 {WebhookUri} 已经挂载事件 {Webhooks}!",
     "Webhooks:Tests": "测试",

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Domain.Shared/LINGYUN/Abp/WebhooksManagement/WebhooksManagementErrorCodes.cs

@@ -11,6 +11,8 @@ public static class WebhooksManagementErrorCodes
 
         public const string AlreayNameExists = Prefix + "001";
 
+        public const string NameNotFount = Prefix + "002";
+
         public const string StaticGroupNotAllowedChanged = Prefix + "010";
     }
 
@@ -20,6 +22,8 @@ public static class WebhooksManagementErrorCodes
 
         public const string AlreayNameExists = Prefix + "001";
 
+        public const string NameNotFount = Prefix + "002";
+
         public const string StaticWebhookNotAllowedChanged = Prefix + "010";
     }
 

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Domain/LINGYUN/Abp/WebhooksManagement/IWebhookDefinitionRecordRepository.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.WebhooksManagement;
 
@@ -12,5 +13,10 @@ public interface IWebhookDefinitionRecordRepository : IBasicRepository<WebhookDe
         string name,
         CancellationToken cancellationToken = default);
 
-    Task<List<WebhookDefinitionRecord>> GetAvailableListAsync(CancellationToken cancellationToken = default);
+    Task<List<WebhookDefinitionRecord>> GetAvailableListAsync(
+        CancellationToken cancellationToken = default);
+
+    Task<List<WebhookDefinitionRecord>> GetListAsync(
+        ISpecification<WebhookDefinitionRecord> specification,
+        CancellationToken cancellationToken = default);
 }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.Domain/LINGYUN/Abp/WebhooksManagement/IWebhookGroupDefinitionRecordRepository.cs

@@ -1,10 +1,18 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.WebhooksManagement;
 public interface IWebhookGroupDefinitionRecordRepository : IBasicRepository<WebhookGroupDefinitionRecord, Guid>
 {
-    Task<WebhookGroupDefinitionRecord> FindByNameAsync(string name, CancellationToken cancellationToken = default);
+    Task<WebhookGroupDefinitionRecord> FindByNameAsync(
+        string name, 
+        CancellationToken cancellationToken = default);
+
+    Task<List<WebhookGroupDefinitionRecord>> GetListAsync(
+        ISpecification<WebhookGroupDefinitionRecord> specification,
+        CancellationToken cancellationToken = default);
 }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.EntityFrameworkCore/LINGYUN/Abp/WebhooksManagement/EntityFrameworkCore/EfCoreWebhookDefinitionRecordRepository.cs

@@ -6,6 +6,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
+using Volo.Abp.Specifications;
 
 namespace LINGYUN.Abp.WebhooksManagement.EntityFrameworkCore;
 
@@ -34,4 +35,14 @@ public class EfCoreWebhookDefinitionRecordRepository :
             .Where(x => x.IsEnabled == true)
             .ToListAsync(GetCancellationToken(cancellationToken));
     }
+
+
+    public async virtual Task<List<WebhookDefinitionRecord>> GetListAsync(
+        ISpecification<WebhookDefinitionRecord> specification,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(specification.ToExpression())
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 }

aspnet-core/modules/webhooks/LINGYUN.Abp.WebhooksManagement.EntityFrameworkCore/LINGYUN/Abp/WebhooksManagement/EntityFrameworkCore/EfCoreWebhookGroupDefinitionRecordRepository.cs

@@ -1,10 +1,12 @@
-using System;
+using Microsoft.EntityFrameworkCore;
-using System.Threading.Tasks;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore;
-using System.Linq;
+using Volo.Abp.Specifications;
-using Microsoft.EntityFrameworkCore;
 
 namespace LINGYUN.Abp.WebhooksManagement.EntityFrameworkCore;
 
@@ -26,4 +28,13 @@ public class EfCoreWebhookGroupDefinitionRecordRepository :
             .OrderBy(x => x.Id)
             .FirstOrDefaultAsync(r => r.Name == name, cancellationToken);
     }
+
+    public async virtual Task<List<WebhookGroupDefinitionRecord>> GetListAsync(
+        ISpecification<WebhookGroupDefinitionRecord> specification,
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(specification.ToExpression())
+            .ToListAsync(GetCancellationToken(cancellationToken));
+    }
 }