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/test/Unity.Flex.Application.Tests/Worksheets/WorksheetInstanceRepositoryTests.cs

@@ -0,0 +1,117 @@
+using Shouldly;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Unity.Flex.Domain.WorksheetInstances;
+using Volo.Abp.MultiTenancy;
+using Volo.Abp.Uow;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Unity.Flex.Worksheets
+{
+    public class WorksheetInstanceRepositoryTests : FlexApplicationTestBase
+    {
+        private readonly IWorksheetInstanceRepository _worksheetInstanceRepository;
+        private readonly ICurrentTenant _currentTenant;
+        private readonly IUnitOfWorkManager _unitOfWorkManager;
+
+        public WorksheetInstanceRepositoryTests(ITestOutputHelper outputHelper) : base(outputHelper)
+        {
+            _worksheetInstanceRepository = GetRequiredService<IWorksheetInstanceRepository>();
+            _currentTenant = GetRequiredService<ICurrentTenant>();
+            _unitOfWorkManager = GetRequiredService<IUnitOfWorkManager>();
+        }
+
+        [Fact]
+        [Trait("Category", "Integration")]
+        public async Task GetByCorrelationIdsAsync_OnlyReturnsRowsForTheExactCorrelationProviderRequested()
+        {
+            var correlationId = Guid.NewGuid();
+
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), Guid.NewGuid(), correlationId, "Application",
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), Guid.NewGuid(), correlationId, "OtherProvider",
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+
+            var result = await _worksheetInstanceRepository.GetByCorrelationIdsAsync([correlationId], "Application");
+
+            result.ShouldHaveSingleItem();
+            result[0].CorrelationProvider.ShouldBe("Application");
+        }
+
+        [Fact]
+        [Trait("Category", "Integration")]
+        public async Task GetByCorrelationIdsAsync_RespectsMultiTenantFilter()
+        {
+            var tenantA = Guid.NewGuid();
+            var tenantB = Guid.NewGuid();
+            var correlationId = Guid.NewGuid();
+
+            using (_currentTenant.Change(tenantA))
+            {
+                using var uow = _unitOfWorkManager.Begin();
+                await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                    Guid.NewGuid(), Guid.NewGuid(), correlationId, "Application",
+                    Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+                await uow.CompleteAsync();
+            }
+
+            using (_currentTenant.Change(tenantA))
+            {
+                using var uow = _unitOfWorkManager.Begin();
+                var visibleToOwnTenant = await _worksheetInstanceRepository.GetByCorrelationIdsAsync([correlationId], "Application");
+                visibleToOwnTenant.ShouldHaveSingleItem();
+            }
+
+            using (_currentTenant.Change(tenantB))
+            {
+                using var uow = _unitOfWorkManager.Begin();
+                var visibleToOtherTenant = await _worksheetInstanceRepository.GetByCorrelationIdsAsync([correlationId], "Application");
+                visibleToOtherTenant.ShouldBeEmpty();
+            }
+        }
+
+        [Fact]
+        [Trait("Category", "Integration")]
+        public async Task GetDistinctWorksheetIdsByCorrelationIdsAsync_OnlyReturnsIdsForTheExactCorrelationProviderRequested()
+        {
+            var correlationId = Guid.NewGuid();
+            var worksheetIdForRequestedProvider = Guid.NewGuid();
+            var worksheetIdForOtherProvider = Guid.NewGuid();
+
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), worksheetIdForRequestedProvider, correlationId, "Application",
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), worksheetIdForOtherProvider, correlationId, "OtherProvider",
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+
+            var result = await _worksheetInstanceRepository.GetDistinctWorksheetIdsByCorrelationIdsAsync([correlationId], "Application");
+
+            result.ShouldBe([worksheetIdForRequestedProvider]);
+        }
+
+        [Fact]
+        [Trait("Category", "Integration")]
+        public async Task GetPagedListByCorrelationProviderAsync_OnlyReturnsRowsForTheExactCorrelationProviderRequested()
+        {
+            var marker = Guid.NewGuid().ToString("N");
+            var correlationProvider = $"Provider-{marker}";
+
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), correlationProvider,
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+            await _worksheetInstanceRepository.InsertAsync(new WorksheetInstance(
+                Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), "OtherProvider",
+                Guid.NewGuid(), "FormVersion", "anchor"), autoSave: true);
+
+            var result = await _worksheetInstanceRepository.GetPagedListByCorrelationProviderAsync(correlationProvider, 0, 10);
+
+            result.ShouldHaveSingleItem();
+            result[0].CorrelationProvider.ShouldBe(correlationProvider);
+        }
+    }
+}

applications/Unity.GrantManager/modules/Unity.Identity.Web/src/Pages/Identity/Roles/index.js

@@ -61,7 +61,7 @@ $(function () {
                             _identityRoleAppService
                                 .delete(data.record.id)
                                 .then(function () {
-                                    _dataTable.ajax.reloadEx();
+                                    _dataTable.ajax.reload();
                                     abp.notify.success(l('SuccessfullyDeleted'));
                                 });
                         },
@@ -174,10 +174,10 @@ $(function () {
     });
 
     _createModal.onResult(function () {
-        _dataTable.ajax.reloadEx();
+        _dataTable.ajax.reload();
     });
 
     _editModal.onResult(function () {
-        _dataTable.ajax.reloadEx();
+        _dataTable.ajax.reload();
     });
 });

applications/Unity.GrantManager/modules/Unity.Identity.Web/src/Pages/Identity/Users/index.js

@@ -65,7 +65,7 @@ $(function () {
 
         $('#ImportUserSearchButton').click(function (e) {
             e.preventDefault();
-            _filterDataTable.ajax.reloadEx();
+            _filterDataTable.ajax.reload();
             $('#import-user-btn').attr('disabled', true);
         });
 
@@ -87,7 +87,7 @@ $(function () {
         });
 
         _importModal.onResult(function () {
-            dataTable.ajax.reloadEx();
+            dataTable.ajax.reload();
         });
     }
 

applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Domain.Shared/Localization/Notifications/en.json

@@ -24,14 +24,18 @@
     "Filter": "Filter",
     "Export": "Export",
     "NotificationList:NotificationId": "Notification Id",
-    "NotificationList:SubmissionId": "Submission Id",
+    "NotificationList:SubmissionId": "Submission #",
     "NotificationList:ApplicantName": "Applicant Name",
     "NotificationList:SentDate": "Sent Date",
     "NotificationList:Status": "Status",
     "NotificationList:From": "From",
     "NotificationList:To": "To",
     "NotificationList:Subject": "Subject",
     "NotificationList:Recipient": "Recipient",
-    "NotificationList:EmailType": "Email Type"
+    "NotificationList:EmailType": "Email Type",
+    "NotificationList:EmailType:Manual": "Manual",
+    "NotificationList:EmailType:Scheduled": "Scheduled",
+    "NotificationList:EmailType:EventBased": "Event Based",
+    "NotificationList:EmailType:Delayed": "Delayed"
   }
 }