Dev

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Menus/AIMenuContributor.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Unity.AI.Localization;
 using Unity.AI.Permissions;
+using Unity.Modules.Shared.Specializations;
 using Unity.Modules.Shared.Permissions;
 using Volo.Abp.Features;
 using Volo.Abp.UI.Navigation;
@@ -23,14 +24,18 @@ private static async Task ConfigureMainMenuAsync(MenuConfigurationContext contex
         var l = context.GetLocalizer<AIResource>();
         var featureChecker = context.ServiceProvider.GetRequiredService<IFeatureChecker>();
 
-        context.Menu.AddItem(new ApplicationMenuItem(
-            name: AIMenus.Prompts,
-            displayName: "AI Prompts",
-            url: "~/Prompts",
-            icon: "fl fl-ai-prompts",
-            order: 900,
-            requiredPermissionName: IdentityConsts.ITOperationsPermissionName
-        ));
+        var specializationChecker = context.ServiceProvider.GetRequiredService<ISpecializationChecker>();
+        if (!await specializationChecker.IsEnabledAsync(SpecializationConsts.Onboarding))
+        {
+            context.Menu.AddItem(new ApplicationMenuItem(
+                name: AIMenus.Prompts,
+                displayName: "AI Prompts",
+                url: "~/Prompts",
+                icon: "fl fl-ai-prompts",
+                order: 900,
+                requiredPermissionName: IdentityConsts.ITOperationsPermissionName
+            ));
+        }
 
         if (await featureChecker.IsEnabledAsync("Unity.AIReporting"))
         {

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application.Contracts/WorksheetInstances/IWorksheetInstanceAppService.cs

@@ -1,5 +1,7 @@
-using System.Threading.Tasks;
-using System;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.Application.Dtos;
 using Volo.Abp.Application.Services;
 
 namespace Unity.Flex.WorksheetInstances
@@ -9,5 +11,10 @@ public interface IWorksheetInstanceAppService : IApplicationService
         Task<WorksheetInstanceDto> GetByCorrelationAnchorAsync(Guid correlationId, string correlationProvider, Guid worksheetId, string uiAnchor);
         Task<WorksheetInstanceDto> CreateAsync(CreateWorksheetInstanceDto dto);
         Task UpdateAsync(PersistWorksheetIntanceValuesDto dto);
+        Task<List<WorksheetInstanceDataDto>> GetListByCorrelationIdsAsync(List<Guid> correlationIds, string correlationProvider);
+        Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationProviderAsync(string correlationProvider);
+        Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationIdsAsync(List<Guid> correlationIds, string correlationProvider);
+        Task<PagedResultDto<WorksheetInstanceDataDto>> GetPagedListByCorrelationProviderAsync(string correlationProvider, int skipCount, int maxResultCount);
+        Task<WorksheetInstanceDataDto?> GetDataByIdAsync(Guid id);
     }
 }

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application.Contracts/WorksheetInstances/WorksheetInstanceDataDto.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Unity.Flex.WorksheetInstances
+{
+    public class WorksheetInstanceDataDto
+    {
+        public Guid Id { get; set; }
+        public Guid CorrelationId { get; set; }
+        public Guid WorksheetId { get; set; }
+        public string CurrentValue { get; set; } = "{}";
+        public DateTime CreationTime { get; set; }
+    }
+}

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application/Domain/WorksheetInstances/IWorksheetInstanceRepository.cs

@@ -12,5 +12,10 @@ public interface IWorksheetInstanceRepository : IBasicRepository<WorksheetInstan
         Task<WorksheetInstance?> GetWithValuesAsync(Guid worksheetInstanceId);
         Task<bool> ExistsAsync(Guid worksheetId, Guid instanceCorrelationId, string instanceCorrelationProvider, Guid sheetCorrelationId, string sheetCorrelationProvider, string? uiAnchor);
         Task<bool> AnyByWorksheetAndFormVersionAsync(Guid worksheetId, Guid formVersionId);
+        Task<List<WorksheetInstance>> GetByCorrelationIdsAsync(IEnumerable<Guid> correlationIds, string correlationProvider);
+        Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationProviderAsync(string correlationProvider);
+        Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationIdsAsync(IEnumerable<Guid> correlationIds, string correlationProvider);
+        Task<List<WorksheetInstance>> GetPagedListByCorrelationProviderAsync(string correlationProvider, int skipCount, int maxResultCount);
+        Task<int> GetCountByCorrelationProviderAsync(string correlationProvider);
     }
 }

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application/EntityFrameworkCore/Repositories/WorksheetInstanceRepository.cs

@@ -76,5 +76,52 @@ public async Task<bool> AnyByWorksheetAndFormVersionAsync(Guid worksheetId, Guid
                 && s.WorksheetCorrelationId == formVersionId
                 && s.WorksheetCorrelationProvider == CorrelationConsts.FormVersion);
         }
+
+        public async Task<List<WorksheetInstance>> GetByCorrelationIdsAsync(IEnumerable<Guid> correlationIds, string correlationProvider)
+        {
+            var dbSet = await GetDbSetAsync();
+            var ids = correlationIds.ToList();
+            return await dbSet
+                .Where(wi => ids.Contains(wi.CorrelationId) && wi.CorrelationProvider == correlationProvider)
+                .ToListAsync();
+        }
+
+        public async Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationProviderAsync(string correlationProvider)
+        {
+            var dbSet = await GetDbSetAsync();
+            return await dbSet
+                .Where(wi => wi.CorrelationProvider == correlationProvider)
+                .Select(wi => wi.WorksheetId)
+                .Distinct()
+                .ToListAsync();
+        }
+
+        public async Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationIdsAsync(IEnumerable<Guid> correlationIds, string correlationProvider)
+        {
+            var dbSet = await GetDbSetAsync();
+            var ids = correlationIds.ToList();
+            return await dbSet
+                .Where(wi => ids.Contains(wi.CorrelationId) && wi.CorrelationProvider == correlationProvider)
+                .Select(wi => wi.WorksheetId)
+                .Distinct()
+                .ToListAsync();
+        }
+
+        public async Task<List<WorksheetInstance>> GetPagedListByCorrelationProviderAsync(string correlationProvider, int skipCount, int maxResultCount)
+        {
+            var dbSet = await GetDbSetAsync();
+            return await dbSet
+                .Where(wi => wi.CorrelationProvider == correlationProvider)
+                .OrderByDescending(wi => wi.CreationTime)
+                .Skip(skipCount)
+                .Take(maxResultCount)
+                .ToListAsync();
+        }
+
+        public async Task<int> GetCountByCorrelationProviderAsync(string correlationProvider)
+        {
+            var dbSet = await GetDbSetAsync();
+            return await dbSet.CountAsync(wi => wi.CorrelationProvider == correlationProvider);
+        }
     }
 }

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application/Worksheets/WorksheetInstanceAppService.cs

@@ -1,8 +1,12 @@
-using System.Threading.Tasks;
-using System;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Unity.Flex.Domain.WorksheetInstances;
 using Unity.Flex.Domain.Services;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
 
 namespace Unity.Flex.WorksheetInstances
 {
@@ -29,5 +33,60 @@ public virtual async Task UpdateAsync(PersistWorksheetIntanceValuesDto dto)
         {
             await worksheetsManager.PersistWorksheetData(ObjectMapper.Map<PersistWorksheetIntanceValuesDto, PersistWorksheetIntanceValuesEto>(dto));
         }
+
+        [RemoteService(false)]
+        public virtual async Task<List<WorksheetInstanceDataDto>> GetListByCorrelationIdsAsync(List<Guid> correlationIds, string correlationProvider)
+        {
+            var instances = await worksheetInstanceRepository.GetByCorrelationIdsAsync(correlationIds, correlationProvider);
+            return instances.Select(wi => new WorksheetInstanceDataDto
+            {
+                CorrelationId = wi.CorrelationId,
+                WorksheetId = wi.WorksheetId,
+                CurrentValue = wi.CurrentValue
+            }).ToList();
+        }
+
+        [RemoteService(false)]
+        public virtual async Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationProviderAsync(string correlationProvider)
+        {
+            return await worksheetInstanceRepository.GetDistinctWorksheetIdsByCorrelationProviderAsync(correlationProvider);
+        }
+
+        [RemoteService(false)]
+        public virtual async Task<List<Guid>> GetDistinctWorksheetIdsByCorrelationIdsAsync(List<Guid> correlationIds, string correlationProvider)
+        {
+            return await worksheetInstanceRepository.GetDistinctWorksheetIdsByCorrelationIdsAsync(correlationIds, correlationProvider);
+        }
+
+        [RemoteService(false)]
+        public virtual async Task<PagedResultDto<WorksheetInstanceDataDto>> GetPagedListByCorrelationProviderAsync(string correlationProvider, int skipCount, int maxResultCount)
+        {
+            var totalCount = await worksheetInstanceRepository.GetCountByCorrelationProviderAsync(correlationProvider);
+            var instances = await worksheetInstanceRepository.GetPagedListByCorrelationProviderAsync(correlationProvider, skipCount, maxResultCount);
+            var items = instances.Select(wi => new WorksheetInstanceDataDto
+            {
+                Id = wi.Id,
+                CorrelationId = wi.CorrelationId,
+                WorksheetId = wi.WorksheetId,
+                CurrentValue = wi.CurrentValue,
+                CreationTime = wi.CreationTime
+            }).ToList();
+            return new PagedResultDto<WorksheetInstanceDataDto>(totalCount, items);
+        }
+
+        [RemoteService(false)]
+        public virtual async Task<WorksheetInstanceDataDto?> GetDataByIdAsync(Guid id)
+        {
+            var wi = await worksheetInstanceRepository.FindAsync(id);
+            if (wi == null) return null;
+            return new WorksheetInstanceDataDto
+            {
+                Id = wi.Id,
+                CorrelationId = wi.CorrelationId,
+                WorksheetId = wi.WorksheetId,
+                CurrentValue = wi.CurrentValue,
+                CreationTime = wi.CreationTime
+            };
+        }
     }
 }

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Web/Pages/Components/DataGrid/DataGridWriteService.cs

@@ -279,6 +279,22 @@ internal async Task<WriteDataRowResponse> UpdateRowAsync(RowInputData rowInputDa
             };
         }
 
+        internal async Task DeleteRowAsync(Guid valueId, uint row, Guid worksheetInstanceId)
+        {
+            var currentValue = await customFieldValueAppService.GetAsync(valueId);
+            var dataGridValue = DataGridServiceUtils.DeserializeDataGridValue(currentValue.CurrentValue);
+            if (dataGridValue == null) return;
+
+            var dataGridRowsValue = DataGridServiceUtils.DeserializeDataGridRowsValue(dataGridValue.Value?.ToString());
+            if (dataGridRowsValue == null || row >= (uint)dataGridRowsValue.Rows.Count) return;
+
+            dataGridRowsValue.Rows.RemoveAt((int)row);
+            dataGridValue.Value = dataGridRowsValue;
+
+            await customFieldValueAppService.ExplicitSetAsync(valueId, JsonSerializer.Serialize(dataGridValue));
+            await customFieldValueAppService.SyncWorksheetInstanceValueAsync(worksheetInstanceId);
+        }
+
         internal async Task<List<Tuple<string, string, CustomFieldType>>> GenerateKeyValueTypesAsync(Guid customFieldId, Dictionary<string, string>? keyValuePairs)
         {
             var result = new List<Tuple<string, string, CustomFieldType>>();

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Web/Unity.Flex.Web.csproj

@@ -43,6 +43,10 @@
 		<ProjectReference Include="..\Unity.Flex.Application.Contracts\Unity.Flex.Application.Contracts.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+		<InternalsVisibleTo Include="Unity.Flex.Application.Tests" />
+	</ItemGroup>
+
 	<ItemGroup>
 		<Content Update="Views\Shared\Components\RadioDefinitionWidget\Default.cshtml">
 			<ExcludeFromSingleFile>true</ExcludeFromSingleFile>

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Web/Views/Shared/Components/DataGridWidget/DataGridWidgetController.cs

@@ -1,14 +1,22 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Threading.Tasks;
+using Unity.Flex.Web.Pages.Flex;
 using Unity.Flex.Web.Views.Shared.Components.WorksheetInstanceWidget.ViewModels;
+using Unity.Flex.Worksheets;
+using Unity.Flex.WorksheetInstances;
 using Volo.Abp.AspNetCore.Mvc;
 
 namespace Unity.Flex.Web.Views.Shared.Components.DataGridWidget
 {
     [ApiExplorerSettings(IgnoreApi = true)]
     [Route("Flex/Widgets/DataGrid")]
-    public class DataGridWidgetController : AbpController
+    public class DataGridWidgetController(
+        ICustomFieldAppService customFieldAppService,
+        ICustomFieldValueAppService customFieldValueAppService,
+        DataGridWriteService dataGridWriteService) : AbpController
     {
         [HttpGet]
         [Route("Refresh")]
@@ -33,5 +41,54 @@ public IActionResult Refresh(WorksheetFieldViewModel? fieldModel,
                 worksheetInstanceId
             });
         }
+
+        [Authorize]
+        [HttpPost]
+        [Route("DeleteRow")]
+        public async Task<IActionResult> DeleteRow(
+            Guid valueId,
+            uint row,
+            Guid worksheetInstanceId)
+        {
+            await dataGridWriteService.DeleteRowAsync(valueId, row, worksheetInstanceId);
+            return new OkObjectResult(new { row, worksheetInstanceId });
+        }
+
+        [Authorize]
+        [HttpGet]
+        [Route("RefreshByField")]
+        public async Task<IActionResult> RefreshByField(
+            Guid valueId,
+            Guid fieldId,
+            string modelName,
+            Guid worksheetId,
+            Guid worksheetInstanceId,
+            string uiAnchor)
+        {
+            var field = await customFieldAppService.GetAsync(fieldId);
+            var value = await customFieldValueAppService.GetAsync(valueId);
+
+            var fieldModel = new WorksheetFieldViewModel
+            {
+                Id = field.Id,
+                Name = field.Name,
+                Label = field.Label,
+                Type = field.Type,
+                Order = field.Order,
+                Enabled = field.Enabled,
+                Definition = field.Definition,
+                CurrentValue = value.CurrentValue,
+                CurrentValueId = valueId,
+                UiAnchor = uiAnchor
+            };
+
+            return ViewComponent(typeof(DataGridWidget), new
+            {
+                fieldModel,
+                modelName,
+                worksheetId,
+                worksheetInstanceId
+            });
+        }
     }
 }

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Web/Views/Shared/Components/DataGridWidget/Default.css

@@ -33,6 +33,17 @@
 .custom-grid-container {
     display: flex;
     flex-direction: column;
+    position: relative;
+}
+
+.grid-loading-overlay {
+    position: absolute;
+    inset: 0;
+    background: rgba(255, 255, 255, 0.75);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 10;
 }
 
 .grid-position {
@@ -61,4 +72,31 @@
     color: #8a8886;
     margin-left: 4px;
     vertical-align: middle;
+}
+
+.custom-dynamic-table .dropdown {
+    display: inline-block;
+}
+
+.custom-dynamic-table .dropdown-content {
+    display: none;
+    position: fixed;
+    right: auto;
+    background-color: #f9f9f9;
+    min-width: 160px;
+    box-shadow: 0px 8px 16px 0px rgba(0,0,0,0.2);
+    z-index: 1039;
+    --bs-btn-active-color: var(--bc-colors-white-primary-500);
+    --bs-btn-active-bg: var(--bc-colors-blue-primary-500);
+}
+
+.custom-dynamic-table .dropdown:hover .dropdown-content {
+    display: block;
+}
+
+.custom-dynamic-table .dropdown-content .btn.fullWidth {
+    width: calc(100% - 16px);
+    display: block;
+    text-align: left;
+    margin: 10px 8px;
 }