fix 查询人员权限

Src/Dlhis.Basic/Device/Controllers/DevicePermissionsController.cs

@@ -39,7 +39,7 @@ public class DevicePermissionsController : ControllerBase
     }
 
     /// <summary>
-    /// 分配权限到设备/设备组/营业点
+    /// 分配权限到设备
     /// </summary>
     /// <param name="request"></param>
     [HttpPost("assign-unique")]

Src/Dlhis.Basic/Device/Dtos/DevicePermissionSourceDto.cs

@@ -0,0 +1,27 @@
+using Dlhis.Entity.Sys.Enums;
+
+namespace Dlhis.Basic.Device.Dtos;
+
+public class DevicePermissionSourceDto
+{
+    public string Factory { get; set; }
+
+    public IEnumerable<DevicePermissionSourceTypeDto> Types { get; set; }
+}
+
+public class DevicePermissionSourceTypeDto
+{
+    /// <summary>
+    /// 分配类型
+    /// </summary>
+    public AssignTypeEnumType AssignType { get; init; }
+
+    /// <summary>
+    /// 分配值
+    /// </summary>
+    public string AssignValue { get; init; }
+
+    public DeviceAssignmentTypeEnumType UniqueType { get; set; }
+
+    public IEnumerable<Guid> Codes { get; set; }
+}

Src/Dlhis.Basic/Device/Dtos/TenantAssignTypeDeviceCode.cs

@@ -37,7 +37,6 @@ public class AssignTypeDeviceCode
     /// </summary>
     public List<Guid> Codes { get; set; }
 
-
     public List<Guid> OriginalCodes { get; set; }
 }
 

Src/Dlhis.Basic/Device/Request/DevicePermissionsAssignToDeviceRequest.cs

@@ -1,45 +1,14 @@
-using System.ComponentModel.DataAnnotations;
+namespace Dlhis.Basic.Device.Request;
-using Dlhis.Entity.Device.Enums;
-using Dlhis.Entity.Sys.Enums;
 
-namespace Dlhis.Basic.Device.Request;
+public class DevicePermissionsAssignToDeviceRequest
-
-public class DevicePermissionsAssignToDeviceRequest : IValidatableObject
 {
-    /// <summary>
-    /// 分配类型
-    /// </summary>
-    public DeviceAssignmentTypeEnumType UniqueType { get; set; }
-
     /// <summary>
     /// 分配值
     /// </summary>
     public Guid UniqueValue { get; set; }
 
-    /// <summary>
-    /// 来源
-    /// </summary>
-    public AssignTypeEnumType AssignType { get; set; }
-
     /// <summary>
     /// 来源值
     /// </summary>
     public List<string> Values { get; set; }
-
-
-    [EnumDataType(typeof(DeviceTypeEnumType))]
-    public DeviceTypeEnumType Type { get; set; }
-
-    /// <summary>
-    /// 只删除权限
-    /// </summary>
-    public bool IsDelete { get; set; }
-
-    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
-    {
-        if (AssignType != AssignTypeEnumType.User)
-        {
-            yield return new ValidationResult("仅支持导入档案人员", new[] { nameof(AssignType) });
-        }
-    }
 }

Src/Dlhis.Basic/Device/Services/IDevicePermissionAnalyzeService.cs

@@ -12,19 +12,25 @@ namespace Dlhis.Basic.Device.Services;
 /// </summary>
 public interface IDevicePermissionAnalyzeService : IScopeDependency
 {
-    Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request);
+    Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request);
 
     Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos);
 
-    Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
-        List<string> userNos,
-        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
-        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null
-    );
-
     Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request);
 
     Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request);
 
     Task<List<Guid>> GetAssignDeviceCodesAsync(string userCode);
+    
+    
+    Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(
+        List<string> userNos,
+        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
+        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null);
+
+    Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
+        List<string> userNos,
+        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
+        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null
+    );
 }

Src/Dlhis.Basic/Device/Services/IDevicePermissionService.cs

@@ -21,7 +21,7 @@ public interface IDevicePermissionService : IScopeDependency
     /// </summary>
     /// <param name="request"></param>
     /// <returns></returns>
-    Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
+    Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
 
 
     Task AssignToUniqueImportAsync(IFormFile file);

Src/Dlhis.Basic/Device/Services/Implements/BasePermissionAnalyzeService.cs

@@ -41,7 +41,7 @@ public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
         await CheckWhetherAssignToTopDeviceGroupAsync(request);
         await CheckAssignedToTenantAsync(request);
 
-        var dps = await _devicePermissionAnalyzeService.GetDevicePermissions(request);
+        var dps = await _devicePermissionAnalyzeService.GetDevicePermissionsAsync(request);
 
         try
         {

Src/Dlhis.Basic/Device/Services/Implements/DeviceGroupService.cs

@@ -106,6 +106,7 @@ public class DeviceGroupService : IDeviceGroupService
 
         await CheckNoNextGroupAsync(group.Code);
         await CheckGroupTypeMatchAsync(request, group);
+        await CheckAssignToTenantAsync(group.Code, request.DeviceCodes);
 
         var relationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => x.GroupCode == request.GroupCode).ToListAsync();
 
@@ -125,6 +126,23 @@ public class DeviceGroupService : IDeviceGroupService
         return r;
     }
 
+    private async Task CheckAssignToTenantAsync(Guid groupCode, List<Guid> deviceCodes)
+    {
+        if (await _dbContext.Queryable<DevicePermissionEntity>()
+                .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
+                .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
+                .Where(x => x.UniqueValue == groupCode)
+                .AnyAsync())
+        {
+            (await _dbContext.Queryable<DevicePermissionEntity>()
+                .Where(x => x.AssignType != AssignTypeEnumType.Tenant)
+                .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
+                .Where(x => deviceCodes.Contains(x.UniqueValue))
+                .AnyAsync()).ThrowIfTrue("无法分配设备到该设备组:设备组已分配到厂区");
+        }
+    }
+
+
     private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode, List<Guid> beforeDeviceCodes, List<Guid> presentDeviceCodes)
     {
         var codesToAdd = presentDeviceCodes.Except(beforeDeviceCodes).ToList();

Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionAnalyzeService.cs

@@ -33,7 +33,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
     }
 
 
-    public async Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request)
+    public async Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request)
     {
         var currentTenantId = await GetCurrentFactoryAsync(request);
         (bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
@@ -196,7 +196,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
                 IgnoreUniqueType = ignoreUniqueType
             };
 
-            var codes = GetAssignDeviceCodesInternal(analyzePack,
+            var codes = GetAssignDeviceCodesPermissions(analyzePack,
                 gainfoGroups,
                 devicePermissions,
                 deviceGroups,
@@ -210,7 +210,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
     }
 
 
-    private static IEnumerable<TenantAssignTypeDeviceCode> GetAssignDeviceCodesInternal(
+    private static IEnumerable<TenantAssignTypeDeviceCode> GetAssignDeviceCodesPermissions(
         AnalyzePackDto analyzePack,
         List<GainfoGroupEntity> gainfoGroups,
         List<DevicePermissionDto> devicePermissions,
@@ -366,18 +366,17 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
 
     public async Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request)
     {
-        var currentAssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
+        var r = await GetDevicePermissionsAsync(new DevicePermissionSaveRequest
+        {
+            AssignType = request.AssignType,
+            AssignValue = request.AssignValue,
+            UniqueType = request.UniqueType,
+            Codes = null,
+            TenantId = request.TenantId,
+            Type = request.Type
+        });
 
-        (bool enableFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
+        return r.Select(x => x.UniqueValue).ToList();
-
-        return await _dbContext.Queryable<DevicePermissionEntity>()
-            .Where(x => x.AssignType == request.AssignType)
-            .Where(x => x.AssignValue == currentAssignValue)
-            .Where(x => x.UniqueType == request.UniqueType)
-            .WhereIF(enableFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
-            .Where(x => x.Type == request.Type)
-            .Select(x => x.UniqueValue)
-            .ToListAsync();
     }
 
     public async Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request)

Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionService.cs

@@ -46,29 +46,30 @@ public class DevicePermissionService : IDevicePermissionService
             .AnalyzeAsync(request);
     }
 
-    public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
+    public async Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
     {
         var currentTenantId = _currentUser.GetStringTenantId();
-        var today = DateTime.Today;
-        var factories = _currentUser.GetUserClaim("tenants").Split(",").ToList();
 
         var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Code == request.UniqueValue).SingleAsync();
         device.ThrowIfNull("设备不存在");
 
-        //删除当前匹配的基地权限
+        //当前匹配的基地权限
-        var p = await _dbContext.Queryable<DevicePermissionEntity>()
+        var dps = await _dbContext.Queryable<DevicePermissionEntity>()
-            .Where(x => x.UniqueType == request.UniqueType)
+            .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
             .Where(x => x.UniqueValue == request.UniqueValue)
-            .Where(x => x.AssignType == request.AssignType)
+            .Where(x => x.AssignType == AssignTypeEnumType.User)
-            .Where(x => x.Type == request.Type)
+            .Where(x => x.Type == device.Type)
             .Where(x => x.TenantId == currentTenantId)
             .ToListAsync();
 
-        var beforeNos = p.Select(x => x.AssignValue).ToList();
+        var beforeUserNos = dps.Select(x => x.AssignValue).ToList();
-        var presentNos = new List<string>();
+        var presentUserNos = new List<string>();
+
         if (request.Values.IsPresent())
         {
-            presentNos = await _dbContext.Client.Queryable<GainfoEntity>()
+            var today = DateTime.Today;
+            var factories = _currentUser.GetUserClaim("tenants").Split(",").ToList();
+            presentUserNos = await _dbContext.Client.Queryable<GainfoEntity>()
                 .Where(gainfo => factories.Contains(gainfo.Factory) || SqlFunc.Subqueryable<BusinessTripEntity>()
                     .Where(x => factories.Contains(x.Destination) && SqlFunc.DateIsSame(x.BeginDate, today))
                     .Any()
@@ -76,57 +77,83 @@ public class DevicePermissionService : IDevicePermissionService
                 .Where(gainfo => request.Values.Contains(gainfo.Code) || request.Values.Contains(gainfo.No) || request.Values.Contains(gainfo.IdNo))
                 .Select(gainfo => gainfo.No)
                 .ToListAsync();
-
-            //gainfoNos = gainfoNos.Concat(nos).Distinct().ToList();
         }
 
-        var adds = presentNos.Except(beforeNos);
+        var tasksToAdd = new List<DeviceTaskEntity>();
-        var deletes = beforeNos.Except(presentNos);
+        var tasksToDelete = new List<DeviceTaskEntity>();
 
-        await _dbContext.DeleteAsync(p);
+        try
-        var devicePermissions = presentNos.Select(v => new DevicePermissionEntity
         {
-            UniqueType = request.UniqueType,
+            var usersToAdd = presentUserNos.Except(beforeUserNos);
-            UniqueValue = request.UniqueValue,
+            var usersToDelete = beforeUserNos.Except(presentUserNos).ToList();
-            AssignType = request.AssignType,
-            AssignValue = v,
-            TenantId = currentTenantId,
-            Type = request.Type
-        }).ToList();
 
-        await _dbContext.InsertAsync(devicePermissions);
+            var userTenantDeviceCodes = usersToDelete.IsPresent()
+                ? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(beforeUserNos.Union(presentUserNos).ToList())
+                : new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
 
-        await _dbContext.InsertAsync(adds.Select(x => new DeviceTaskEntity
+            tasksToAdd.AddRange(usersToAdd.Select(userNo => new DeviceTaskEntity
+            {
+                Type = DeviceTaskEnumType.Add,
+                DeviceType = device.Type,
+                UserId = null,
+                UserNo = userNo,
+                DeviceUniqueNo = device.UniqueNo,
+                Status = DeviceTaskStatusEnumType.Wait,
+                Version = 0,
+                ResultMessage = null,
+                CancellationId = 20,
+                Source = DeviceTaskSourceEnumType.Manually,
+                Priority = 0,
+                TenantId = currentTenantId,
+            }));
+
+            foreach (var item in usersToDelete)
+            {
+                var permissions = userTenantDeviceCodes[item].ToList();
+                foreach (var permission in permissions)
+                {
+                    permission.AssignTypes = permission.AssignTypes.Where(x => x.UniqueType != DeviceAssignmentTypeEnumType.Device).ToList();
+                }
+
+                var myDeviceCodes = permissions.SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).Distinct().ToList();
+                if (myDeviceCodes.All(x => x != device.Code))
+                {
+                    tasksToDelete.Add(new DeviceTaskEntity
+                    {
+                        Type = DeviceTaskEnumType.Delete,
+                        DeviceType = device.Type,
+                        UserId = null,
+                        UserNo = item,
+                        DeviceUniqueNo = device.UniqueNo,
+                        Status = DeviceTaskStatusEnumType.Wait,
+                        Version = 0,
+                        ResultMessage = null,
+                        CancellationId = 20,
+                        Source = DeviceTaskSourceEnumType.Manually,
+                        Priority = 0,
+                        TenantId = currentTenantId
+                    });
+                }
+            }
+        }
+        finally
         {
-            Type = DeviceTaskEnumType.Add,
+            await _dbContext.InsertAsync(tasksToAdd);
-            DeviceType = device.Type,
+            await _dbContext.InsertAsync(tasksToDelete);
-            UserId = null,
-            UserNo = x,
-            DeviceUniqueNo = device.UniqueNo,
-            Status = DeviceTaskStatusEnumType.Wait,
-            Version = 0,
-            ResultMessage = null,
-            CancellationId = 0,
-            Source = DeviceTaskSourceEnumType.Manually,
-            Priority = 0,
-            TenantId = currentTenantId,
-        }).ToList());
 
-        await _dbContext.InsertAsync(deletes.Select(x => new DeviceTaskEntity
+            await _dbContext.DeleteAsync(dps);
-        {
+            await _dbContext.InsertAsync(presentUserNos.Select(v => new DevicePermissionEntity
-            Type = DeviceTaskEnumType.Delete,
+            {
-            DeviceType = device.Type,
+                UniqueType = DeviceAssignmentTypeEnumType.Device,
-            UserId = null,
+                UniqueValue = request.UniqueValue,
-            UserNo = x,
+                AssignType = AssignTypeEnumType.User,
-            DeviceUniqueNo = device.UniqueNo,
+                AssignValue = v,
-            Status = DeviceTaskStatusEnumType.Wait,
+                TenantId = currentTenantId,
-            Version = 0,
+                Type = device.Type
-            ResultMessage = null,
+            }).ToList());
-            CancellationId = 0,
+        }
-            Source = DeviceTaskSourceEnumType.Manually,
+
-            Priority = 0,
+        return new DevicePermissionAssignResponse(tasksToAdd.Count, tasksToDelete.Count);
-            TenantId = currentTenantId
-        }).ToList());
     }
 
     /// <inheritdoc />

Src/Dlhis.Basic/Organization/Controllers/GainfoPermissionsController.cs

@@ -51,7 +51,7 @@ public class GainfoPermissionsController : ControllerBase
     /// <param name="request"></param>
     /// <returns></returns>
     [HttpGet("assignDeviceCodes")]
-    public async Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync([FromQuery] DeviceAssRequest request)
+    public async Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync([FromQuery] DeviceAssRequest request)
     {
         return await _gainfoPermissions.GetAssignDeviceCodesAsync(request);
     }

Src/Dlhis.Basic/Organization/Response/GainfoDevicePermissionResponse.cs

@@ -0,0 +1,69 @@
+using Dlhis.Basic.Device.Dtos;
+using Dlhis.Entity.Device.Enums;
+using Kurisu.AspNetCore.Utils.Extensions;
+
+namespace Dlhis.Basic.Organization.Response;
+
+public class GainfoDevicePermissionResponse
+{
+    public long Id { get; set; }
+
+    /// <summary>
+    /// 设备code
+    /// </summary>
+    public Guid Code { get; set; }
+
+    /// <summary>
+    /// 设备码,IP/MAC/SNO
+    /// </summary>
+    public string UniqueNo { get; set; }
+
+    /// <summary>
+    /// 心跳间隔
+    /// </summary>
+    public int HeartbeatInterval { get; set; }
+
+    /// <summary>
+    /// 设备机功能类型
+    /// </summary>
+    public DeviceTypeEnumType Type { get; set; }
+
+    public string TypeDescription => Type.GetDescription();
+
+    /// <summary>
+    /// 是否启用
+    /// </summary>
+    public bool Enable { get; set; }
+
+    /// <summary>
+    /// 厂区
+    /// </summary>
+    public string Factory { get; set; }
+
+    /// <summary>
+    /// 最后心跳时间
+    /// </summary>
+    public DateTime? LastHeartbeatTime { get; set; }
+
+    /// <summary>
+    /// 是否在线
+    /// </summary>
+    public bool IsOnline
+    {
+        get
+        {
+            if (!LastHeartbeatTime.HasValue)
+                return false;
+
+            if (HeartbeatInterval <= 0)
+                return true;
+
+            return LastHeartbeatTime.Value.AddSeconds(HeartbeatInterval) >= DateTime.Now;
+        }
+    }
+
+    /// <summary>
+    /// 分配来源
+    /// </summary>
+    public DevicePermissionSourceDto Source { get; set; }
+}

Src/Dlhis.Basic/Organization/Services/IGainfoPermissionService.cs

@@ -13,7 +13,7 @@ public interface IGainfoPermissionService : IScopeDependency
 
     Task<List<GetDevicesUnderGroupByUserNoResponse>> GetDevicesUnderGroupByUserNoAsync(string userNo, Guid deviceGroupCode);
 
-    Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request);
+    Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request);
 
     Task<List<DeviceGroupTreeResponse>> GetAssignGroupAsync(string userNo);
 

Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs

@@ -93,8 +93,7 @@ public class GainfoGroupService : IGainfoGroupService
         var relations = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
             .Where(x => x.GroupCode == request.GroupCode)
             .ToListAsync();
-
+        
-
         var presentUserNos = await _dbContext.Queryable<GainfoEntity>()
             .Where(x => request.UserNos.Contains(x.No) || request.UserNos.Contains(x.Code)) //NO和工号匹配
             .Select(x => x.No)

Src/Dlhis.Basic/Organization/Services/Implements/GainfoPermissionService.cs

@@ -1,4 +1,5 @@
-using Dlhis.Basic.Device.Request;
+using Dlhis.Basic.Device.Dtos;
+using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Response;
 using Dlhis.Basic.Device.Services;
 using Dlhis.Basic.Organization.Request;
@@ -118,27 +119,39 @@ public class GainfoPermissionService : IGainfoPermissionService
         }).ToList();
     }
 
-    public async Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request)
+    public async Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request)
     {
-        var ids = await _devicePermissionAnalyzeService.GetAssignDeviceCodesAsync(request.UserNo);
+        var result = await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(new List<string> { request.UserNo });
+        var permissions = result[request.UserNo].ToList();
+
+        var codes = permissions.SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).Distinct().ToList();
 
         var page = await _dbContext.Queryable<DeviceEntity>()
-            .LeftJoin<DeviceTemplateEntity>((d, dt) => d.TemplateCode == dt.Code)
+            .LeftJoin<DeviceRegistryEntity>((d, dr) => d.UniqueNo == dr.DeviceUniqueNo)
-            .LeftJoin<DeviceRegistryEntity>((d, dt, dr) => d.UniqueNo == dr.DeviceUniqueNo)
-            .LeftJoin<BusinessPlaceEntity>((d, dt, dr, bp) => dr.BusinessPlaceCode == bp.Code)
             .WhereIF(request.DeviceType.HasValue, d => d.Type == request.DeviceType)
-            .Where(d => ids.Contains(d.Code))
+            .Where(d => codes.Contains(d.Code))
-            .Select((d, dt, dr, bp) => new DevicePageResponse
+            .Select((d, dr) => new GainfoDevicePermissionResponse { Factory = d.TenantId }, true)
-            {
-                FuncsStr = d.Funcs.ToString(),
-                Brand = dt.Brand,
-                Type = d.Type,
-                BusinessPlaceCode = bp.Code,
-                BusinessPlaceName = bp.Name,
-                LastHeartbeatTime = dr.LastHeartbeatTime
-            }, true)
             .ToPageListAsync(request);
 
+        page.Data.ForEach(item =>
+        {
+            var permission = permissions.First(x => x.Tenant == item.Factory);
+
+            item.Source = new DevicePermissionSourceDto
+            {
+                Factory = item.Factory,
+                Types = permission.AssignTypes.Where(x => x.Codes.Any(p => p == item.Code)).Select(x => new DevicePermissionSourceTypeDto
+                {
+                    AssignType = x.AssignType,
+                    AssignValue = x.AssignValue,
+                    UniqueType = x.UniqueType,
+                    Codes = x.UniqueType == DeviceAssignmentTypeEnumType.Device
+                        ? x.Codes.Where(p => p == item.Code)
+                        : x.Codes.Take(1)
+                })
+            };
+        });
+
         return page;
     }