add color and alias name with UserFavoriteMenu

apps/vue/package.json

@@ -75,6 +75,7 @@
     "vue-json-pretty": "^2.0.6",
     "vue-router": "^4.0.14",
     "vue-types": "^4.1.1",
+    "vue3-colorpicker": "^2.0.4",
     "xlsx": "^0.18.5"
   },
   "devDependencies": {

apps/vue/src/locales/lang/en/routes/dashboard.ts

@@ -18,7 +18,8 @@ export default {
       more: 'More',
       addMenu: 'Add new menu',
       manager: 'Manage menu',
-      selectMenu: '选择菜单'
+      selectMenu: 'Select menu',
+      selectColor: 'Select color'
     }
   },
   analysis: 'Analysis',

apps/vue/src/locales/lang/zh-CN/routes/dashboard.ts

@@ -18,7 +18,8 @@ export default {
       more: '更多',
       addMenu: '添加菜单',
       manager: '管理菜单',
-      selectMenu: '选择菜单'
+      selectMenu: '选择菜单',
+      selectColor: '选择颜色'
     }
   },
   analysis: '分析页',

apps/vue/src/main.ts

@@ -6,7 +6,7 @@ import 'virtual:windi-utilities.css';
 import 'virtual:svg-icons-register';
 import App from './App.vue';
 import Antd from 'ant-design-vue';
-import VueCookies from 'vue-cookies'
+import VueCookies from 'vue-cookies';
 import { createApp } from 'vue';
 import { initAppConfigStore, initAbpConfigStore } from '/@/logics/initAppConfig';
 import { setupErrorHandle } from '/@/logics/error-handle';

apps/vue/src/views/dashboard/workbench/components/MenuReference.vue

@@ -7,10 +7,15 @@
     @ok="handleSubmit"
   >
     <Form :model="formModel" ref="formElRef">
+      <Form.Item :label-col="{ span: 3 }" :wrapper-col="{ span: 20 }" :label="t('routes.dashboard.workbench.menus.selectColor')" name="color">
+        <VColorPicker v-model:pureColor="formModel.color" format="hex" />
+        <span>({{ formModel.color }})</span>
+      </Form.Item>
       <Form.Item :label-col="{ span: 3 }" :wrapper-col="{ span: 20 }" :label="t('routes.dashboard.workbench.menus.selectMenu')" name="menus">
-        <ATree
+        <VTree
           checkable
           checkStrictly
+          showIcon
           :tree-data="menuTreeData"
           :fieldNames="{
             title: 'displayName',
@@ -18,7 +23,12 @@
           }"
           v-model:checkedKeys="formModel.menus"
           :selectedKeys="defaultCheckedKeys"
-          @check="handleMenuCheck" />
+          @check="handleMenuCheck"
+        >
+          <template #icon="{ dataRef }">
+            <VIcon v-if="dataRef.meta?.icon" :icon="dataRef.meta.icon" />
+          </template>
+        </VTree>
       </Form.Item>
     </Form>
   </BasicModal>
@@ -28,15 +38,20 @@
   import { reactive, ref, unref } from 'vue';
   import { useI18n } from '/@/hooks/web/useI18n';
   import { Form, Tree } from 'ant-design-vue';
+  import { ColorPicker } from "vue3-colorpicker";
+  import { Icon } from '/@/components/Icon';
   import { BasicModal, useModalInner } from '/@/components/Modal';
   import { getMenuList } from '/@/api/sys/menu';
   import { listToTree } from '/@/utils/helper/treeHelper';
 
-  const ATree = Tree;
+  const VTree = Tree;
+  const VColorPicker = ColorPicker;
+  const VIcon = Icon;
 
   const emits = defineEmits(['change', 'change:keys', 'register']);
   const { t } = useI18n();
   const formModel = reactive({
+    color: '#000000',
     menus: [] as string[],
   });
   const formElRef = ref<any>(null);
@@ -50,6 +65,7 @@
   });
 
   function init(props) {
+    formModel.color = '#000000';
     formModel.menus = [];
     checkedMenus.value = [];
     radio.value = props.radio ?? false;
@@ -81,6 +97,6 @@
   }
 </script>
 
-<style lang="less" scoped>
+<style lang="less">
-
+  @import 'vue3-colorpicker/style.css';
 </style>

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuCreateDto.cs

@@ -0,0 +1,13 @@
+using LINGYUN.Platform.Routes;
+using System.ComponentModel.DataAnnotations;
+using Volo.Abp.Validation;
+
+namespace LINGYUN.Platform.Menus;
+
+public class UserFavoriteMenuCreateDto : UserFavoriteMenuCreateOrUpdateDto
+{
+    [Required]
+    [DynamicStringLength(typeof(LayoutConsts), nameof(LayoutConsts.MaxFrameworkLength))]
+
+    public string Framework { get; set; }
+}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuCreateOrUpdateDto.cs

@@ -0,0 +1,20 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Volo.Abp.Validation;
+
+namespace LINGYUN.Platform.Menus;
+
+public abstract class UserFavoriteMenuCreateOrUpdateDto
+{
+    [Required]
+    public Guid MenuId { get; set; }
+
+    [DynamicStringLength(typeof(UserFavoriteMenuConsts), nameof(UserFavoriteMenuConsts.MaxColorLength))]
+    public string Color { get; set; }
+
+    [DynamicStringLength(typeof(UserFavoriteMenuConsts), nameof(UserFavoriteMenuConsts.MaxAliasNameLength))]
+    public string AliasName { get; set; }
+
+    [DynamicStringLength(typeof(UserFavoriteMenuConsts), nameof(UserFavoriteMenuConsts.MaxIconLength))]
+    public string Icon { get; set; }
+}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuDto.cs

@@ -9,6 +9,10 @@ public class UserFavoriteMenuDto : AuditedEntityDto<Guid>
 
     public Guid UserId { get; set; }
 
+    public string AliasName { get; set; }
+
+    public string Color { get; set; }
+
     public string Framework { get; set; }
 
     public string Name { get; set; }

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuRemoveInput.cs

@@ -0,0 +1,9 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace LINGYUN.Platform.Menus;
+public class UserFavoriteMenuRemoveInput
+{
+    [Required]
+    public Guid MenuId { get; set; }
+}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuSetInput.cs

@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace LINGYUN.Platform.Menus;
-
-public class UserFavoriteMenuSetInput
-{
-    public string Framework { get; set; }
-
-    public List<Guid> MenuIds { get; set; } = new List<Guid>();
-}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/Dto/UserFavoriteMenuUpdateDto.cs

@@ -0,0 +1,9 @@
+using Volo.Abp.Domain.Entities;
+
+namespace LINGYUN.Platform.Menus;
+
+public class UserFavoriteMenuUpdateDto : UserFavoriteMenuCreateOrUpdateDto, IHasConcurrencyStamp
+{
+
+    public string ConcurrencyStamp { get; set; }
+}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/IMenuAppService.cs

@@ -23,18 +23,10 @@ namespace LINGYUN.Platform.Menus
 
         Task SetUserStartupAsync(Guid id, UserMenuStartupInput input);
 
-        Task SetUserFavoriteMenusAsync(Guid userId, UserFavoriteMenuSetInput input);
-
         Task SetRoleMenusAsync(RoleMenuInput input);
 
         Task SetRoleStartupAsync(Guid id, RoleMenuStartupInput input);
 
         Task<ListResultDto<MenuDto>> GetCurrentUserMenuListAsync(GetMenuInput input);
-
-        Task SetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuSetInput input);
-
-        Task<ListResultDto<UserFavoriteMenuDto>> GetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuGetListInput input);
-
-        Task<ListResultDto<UserFavoriteMenuDto>> GetUserFavoriteMenuListAsync(Guid userId, UserFavoriteMenuGetListInput input);
     }
 }

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Menus/IUserFavoriteMenuAppService.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Threading.Tasks;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Application.Services;
+
+namespace LINGYUN.Platform.Menus;
+
+public interface IUserFavoriteMenuAppService : IApplicationService
+{
+    Task<UserFavoriteMenuDto> CreateAsync(Guid userId, UserFavoriteMenuCreateDto input);
+
+    Task<UserFavoriteMenuDto> CreateMyFavoriteMenuAsync(UserFavoriteMenuCreateDto input);
+
+    Task<UserFavoriteMenuDto> UpdateAsync(Guid userId, UserFavoriteMenuUpdateDto input);
+
+    Task<UserFavoriteMenuDto> UpdateMyFavoriteMenuAsync(UserFavoriteMenuUpdateDto input);
+
+    Task DeleteAsync(Guid userId, UserFavoriteMenuRemoveInput input);
+
+    Task DeleteMyFavoriteMenuAsync(UserFavoriteMenuRemoveInput input);
+
+    Task<ListResultDto<UserFavoriteMenuDto>> GetMyFavoriteMenuListAsync(UserFavoriteMenuGetListInput input);
+
+    Task<ListResultDto<UserFavoriteMenuDto>> GetListAsync(Guid userId, UserFavoriteMenuGetListInput input);
+}

aspnet-core/modules/platform/LINGYUN.Platform.Application.Contracts/LINGYUN/Platform/Permissions/PlatformPermissionDefinitionProvider.cs

@@ -38,24 +38,6 @@ namespace LINGYUN.Platform.Permissions
             menu.AddChild(PlatformPermissions.Menu.ManageRoles, L("Permission:ManageRoleMenus"));
             menu.AddChild(PlatformPermissions.Menu.ManageUsers, L("Permission:ManageUserMenus"));
             menu.AddChild(PlatformPermissions.Menu.ManageUserFavorites, L("Permission:ManageUserFavoriteMenus"));
-
-
-            // TODO: 2020-07-27 目前abp不支持对象存储管理（或者属于企业版?）需要创建一个 LINGYUN.Abp.BlobStoring 项目自行实现
-
-            //var fileSystem = platform.AddPermission(PlatformPermissions.FileSystem.Default, L("Permission:FileSystem"));
-            //fileSystem.AddChild(PlatformPermissions.FileSystem.Create, L("Permission:CreateFolder"));
-            //fileSystem.AddChild(PlatformPermissions.FileSystem.Delete, L("Permission:DeleteFolder"));
-            //fileSystem.AddChild(PlatformPermissions.FileSystem.Rename, L("Permission:RenameFolder"));
-            //fileSystem.AddChild(PlatformPermissions.FileSystem.Copy, L("Permission:CopyFolder"));
-            //fileSystem.AddChild(PlatformPermissions.FileSystem.Move, L("Permission:MoveFolder"));
-
-            //var fileManager = fileSystem.AddChild(PlatformPermissions.FileSystem.FileManager.Default, L("Permission:FileManager"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Create, L("Permission:AppendFile"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Update, L("Permission:UpdateFile"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Delete, L("Permission:DeleteFile"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Copy, L("Permission:CopyFile"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Move, L("Permission:MoveFile"));
-            //fileManager.AddChild(PlatformPermissions.FileSystem.FileManager.Download, L("Permission:DownloadFile"));
         }
 
         private static LocalizableString L(string name)

aspnet-core/modules/platform/LINGYUN.Platform.Application/LINGYUN/Platform/Menus/MenuAppService.cs

@@ -17,13 +17,10 @@ namespace LINGYUN.Platform.Menus
     [Authorize]
     public class MenuAppService : PlatformApplicationServiceBase, IMenuAppService
     {
-        protected IStandardMenuConverter StandardMenuConverter => LazyServiceProvider.LazyGetRequiredService<IStandardMenuConverter>();
-
         protected DataItemMappingOptions DataItemMapping { get; }
         protected MenuManager MenuManager { get; }
         protected IMenuRepository MenuRepository { get; }
         protected IUserMenuRepository UserMenuRepository { get; }
-        protected IUserFavoriteMenuRepository UserFavoriteMenuRepository { get; }
         protected IRoleMenuRepository RoleMenuRepository { get; }
         protected IDataRepository DataRepository { get; }
         protected ILayoutRepository LayoutRepository { get; }
@@ -35,7 +32,6 @@ namespace LINGYUN.Platform.Menus
             ILayoutRepository layoutRepository,
             IUserMenuRepository userMenuRepository,
             IRoleMenuRepository roleMenuRepository,
-            IUserFavoriteMenuRepository userFavoriteMenuRepository,
             IOptions<DataItemMappingOptions> options)
         {
             MenuManager = menuManager;
@@ -44,7 +40,6 @@ namespace LINGYUN.Platform.Menus
             LayoutRepository = layoutRepository;
             UserMenuRepository = userMenuRepository;
             RoleMenuRepository = roleMenuRepository;
-            UserFavoriteMenuRepository = userFavoriteMenuRepository;
             DataItemMapping = options.Value;
         }
 
@@ -310,73 +305,5 @@ namespace LINGYUN.Platform.Menus
 
             return new ListResultDto<MenuDto>(menuDtos);
         }
-
-        [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
-        public async virtual Task SetUserFavoriteMenusAsync(Guid userId, UserFavoriteMenuSetInput input)
-        {
-            await SetUserFavoriteMenuListAsync(userId, input);
-        }
-
-        public async virtual Task SetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuSetInput input)
-        {
-            await SetUserFavoriteMenuListAsync(CurrentUser.GetId(), input);
-        }
-
-        [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
-        public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetUserFavoriteMenuListAsync(Guid userId, UserFavoriteMenuGetListInput input)
-        {
-            var userFacoriteMenus = await UserFavoriteMenuRepository.GetFavoriteMenusAsync(
-                userId, input.Framework);
-
-            return new ListResultDto<UserFavoriteMenuDto>(
-                ObjectMapper.Map<List<UserFavoriteMenu>, List<UserFavoriteMenuDto>>(userFacoriteMenus));
-        }
-
-        public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuGetListInput input)
-        {
-            var userFacoriteMenus = await UserFavoriteMenuRepository.GetFavoriteMenusAsync(
-                CurrentUser.GetId(), input.Framework);
-
-            return new ListResultDto<UserFavoriteMenuDto>(
-                ObjectMapper.Map<List<UserFavoriteMenu>, List<UserFavoriteMenuDto>>(userFacoriteMenus));
-        }
-
-        protected async virtual Task SetUserFavoriteMenuListAsync(Guid userId, UserFavoriteMenuSetInput input)
-        {
-            var userFacoriteMenus = await UserFavoriteMenuRepository.GetFavoriteMenusAsync(
-                userId, input.Framework);
-
-            var wellDeleteMenus = userFacoriteMenus.Where(um => !input.MenuIds.Any(id => id == um.MenuId));
-            var wellInsertMenus = input.MenuIds.Where(id => !userFacoriteMenus.Any(um => um.MenuId == id));
-
-            if (wellInsertMenus.Any())
-            {
-                var insertMenus = new List<UserFavoriteMenu>();
-                var menus = await MenuRepository.GetListAsync(wellInsertMenus.Select(id => id));
-
-                foreach (var menu in menus)
-                {
-                    var standardMenu = StandardMenuConverter.Convert(menu);
-
-                    insertMenus.Add(
-                        new UserFavoriteMenu(
-                            GuidGenerator.Create(),
-                            menu.Id,
-                            userId,
-                            menu.Framework,
-                            standardMenu.Name,
-                            standardMenu.DisplayName,
-                            standardMenu.Path,
-                            standardMenu.Icon,
-                            CurrentTenant.Id));
-                }
-
-                await UserFavoriteMenuRepository.InsertManyAsync(insertMenus);
-            }
-
-            await UserFavoriteMenuRepository.DeleteManyAsync(wellDeleteMenus);
-
-            await CurrentUnitOfWork.SaveChangesAsync();
-        }
     }
 }

aspnet-core/modules/platform/LINGYUN.Platform.Application/LINGYUN/Platform/Menus/UserFavoriteMenuAppService.cs

@@ -0,0 +1,172 @@
+using LINGYUN.Platform.Permissions;
+using Microsoft.AspNetCore.Authorization;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Users;
+
+namespace LINGYUN.Platform.Menus;
+
+[Authorize]
+public class UserFavoriteMenuAppService : PlatformApplicationServiceBase, IUserFavoriteMenuAppService
+{
+    protected IStandardMenuConverter StandardMenuConverter => LazyServiceProvider.LazyGetRequiredService<IStandardMenuConverter>();
+    protected IMenuRepository MenuRepository { get; }
+    protected IUserFavoriteMenuRepository UserFavoriteMenuRepository { get; }
+
+    public UserFavoriteMenuAppService(
+        IMenuRepository menuRepository, 
+        IUserFavoriteMenuRepository userFavoriteMenuRepository)
+    {
+        MenuRepository = menuRepository;
+        UserFavoriteMenuRepository = userFavoriteMenuRepository;
+    }
+
+    [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
+    public async virtual Task<UserFavoriteMenuDto> CreateAsync(Guid userId, UserFavoriteMenuCreateDto input)
+    {
+        if (!await UserFavoriteMenuRepository.CheckExistsAsync(input.Framework, userId, input.MenuId))
+        {
+            throw new BusinessException(PlatformErrorCodes.UserDuplicateFavoriteMenu);
+        }
+
+        var menu = await MenuRepository.GetAsync(input.MenuId);
+        var standardMenu = StandardMenuConverter.Convert(menu);
+        var userFavoriteMenu = new UserFavoriteMenu(
+            GuidGenerator.Create(),
+            input.MenuId,
+            userId,
+            input.Framework,
+            standardMenu.Name,
+            standardMenu.DisplayName,
+            standardMenu.Path,
+            standardMenu.Icon,
+            input.Color,
+            input.AliasName,
+            CurrentTenant.Id);
+
+        userFavoriteMenu = await UserFavoriteMenuRepository.InsertAsync(userFavoriteMenu);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
+
+        return ObjectMapper.Map<UserFavoriteMenu, UserFavoriteMenuDto>(userFavoriteMenu);
+    }
+
+    public async virtual Task<UserFavoriteMenuDto> CreateMyFavoriteMenuAsync(UserFavoriteMenuCreateDto input)
+    {
+        var userId = CurrentUser.GetId();
+        if (!await UserFavoriteMenuRepository.CheckExistsAsync(input.Framework, userId, input.MenuId))
+        {
+            throw new BusinessException(PlatformErrorCodes.UserDuplicateFavoriteMenu);
+        }
+
+        var menu = await MenuRepository.GetAsync(input.MenuId);
+        var standardMenu = StandardMenuConverter.Convert(menu);
+        var userFavoriteMenu = new UserFavoriteMenu(
+            GuidGenerator.Create(),
+            input.MenuId,
+            userId,
+            input.Framework,
+            standardMenu.Name,
+            standardMenu.DisplayName,
+            standardMenu.Path,
+            standardMenu.Icon,
+            input.Color,
+            input.AliasName,
+            CurrentTenant.Id);
+
+        userFavoriteMenu = await UserFavoriteMenuRepository.InsertAsync(userFavoriteMenu);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
+
+        return ObjectMapper.Map<UserFavoriteMenu, UserFavoriteMenuDto>(userFavoriteMenu);
+    }
+
+    [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
+    public async virtual Task DeleteAsync(Guid userId, UserFavoriteMenuRemoveInput input)
+    {
+        var userFavoriteMenu = await GetUserMenuAsync(userId, input.MenuId);
+
+        await UserFavoriteMenuRepository.DeleteAsync(userFavoriteMenu);
+    }
+
+    public async virtual Task DeleteMyFavoriteMenuAsync(UserFavoriteMenuRemoveInput input)
+    {
+        var userFavoriteMenu = await GetUserMenuAsync(CurrentUser.GetId(), input.MenuId);
+
+        await UserFavoriteMenuRepository.DeleteAsync(userFavoriteMenu);
+    }
+
+    [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
+    public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetListAsync(Guid userId, UserFavoriteMenuGetListInput input)
+    {
+        var userFacoriteMenus = await UserFavoriteMenuRepository.GetFavoriteMenusAsync(
+                  userId, input.Framework);
+
+        return new ListResultDto<UserFavoriteMenuDto>(
+            ObjectMapper.Map<List<UserFavoriteMenu>, List<UserFavoriteMenuDto>>(userFacoriteMenus));
+    }
+
+    public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetMyFavoriteMenuListAsync(UserFavoriteMenuGetListInput input)
+    {
+        var userFacoriteMenus = await UserFavoriteMenuRepository.GetFavoriteMenusAsync(
+                  CurrentUser.GetId(), input.Framework);
+
+        return new ListResultDto<UserFavoriteMenuDto>(
+            ObjectMapper.Map<List<UserFavoriteMenu>, List<UserFavoriteMenuDto>>(userFacoriteMenus));
+    }
+
+    [Authorize(PlatformPermissions.Menu.ManageUserFavorites)]
+    public async virtual Task<UserFavoriteMenuDto> UpdateAsync(Guid userId, UserFavoriteMenuUpdateDto input)
+    {
+        var userFavoriteMenu = await GetUserMenuAsync(userId, input.MenuId);
+
+        UpdateByInput(userFavoriteMenu, input);
+
+        userFavoriteMenu = await UserFavoriteMenuRepository.UpdateAsync(userFavoriteMenu);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
+
+        return ObjectMapper.Map<UserFavoriteMenu, UserFavoriteMenuDto>(userFavoriteMenu);
+    }
+
+    public async virtual Task<UserFavoriteMenuDto> UpdateMyFavoriteMenuAsync(UserFavoriteMenuUpdateDto input)
+    {
+        var userFavoriteMenu = await GetUserMenuAsync(CurrentUser.GetId(), input.MenuId);
+
+        UpdateByInput(userFavoriteMenu, input);
+
+        userFavoriteMenu = await UserFavoriteMenuRepository.UpdateAsync(userFavoriteMenu);
+
+        await CurrentUnitOfWork.SaveChangesAsync();
+
+        return ObjectMapper.Map<UserFavoriteMenu, UserFavoriteMenuDto>(userFavoriteMenu);
+    }
+
+    protected async virtual Task<UserFavoriteMenu> GetUserMenuAsync(Guid userId, Guid menuId)
+    {
+        var userFavoriteMenu = await UserFavoriteMenuRepository.FindByUserMenuAsync(userId, menuId);
+
+        return userFavoriteMenu ?? throw new BusinessException(PlatformErrorCodes.UserFavoriteMenuNotFound);
+    }
+
+    protected virtual void UpdateByInput(UserFavoriteMenu userFavoriteMenu, UserFavoriteMenuCreateOrUpdateDto input)
+    {
+        if (!string.Equals(userFavoriteMenu.Color, input.Color, StringComparison.CurrentCultureIgnoreCase))
+        {
+            userFavoriteMenu.Color = Check.Length(input.Color, nameof(UserFavoriteMenuCreateOrUpdateDto.Color), UserFavoriteMenuConsts.MaxColorLength);
+        }
+
+        if (!string.Equals(userFavoriteMenu.AliasName, input.AliasName, StringComparison.CurrentCultureIgnoreCase))
+        {
+            userFavoriteMenu.AliasName = Check.Length(input.AliasName, nameof(UserFavoriteMenuCreateOrUpdateDto.AliasName), UserFavoriteMenuConsts.MaxAliasNameLength);
+        }
+
+        if (!string.Equals(userFavoriteMenu.Icon, input.Icon, StringComparison.CurrentCultureIgnoreCase))
+        {
+            userFavoriteMenu.Icon = Check.Length(input.Icon, nameof(UserFavoriteMenuCreateOrUpdateDto.Icon), UserFavoriteMenuConsts.MaxIconLength);
+        }
+    }
+}

aspnet-core/modules/platform/LINGYUN.Platform.Domain.Shared/LINGYUN/Platform/Menus/UserFavoriteMenuConsts.cs

@@ -0,0 +1,9 @@
+using LINGYUN.Platform.Routes;
+
+namespace LINGYUN.Platform.Menus;
+public class UserFavoriteMenuConsts
+{
+    public static int MaxIconLength { get; set; } = 512;
+    public static int MaxColorLength { get; set; } = 30;
+    public static int MaxAliasNameLength { get; set; } = RouteConsts.MaxDisplayNameLength;
+}

aspnet-core/modules/platform/LINGYUN.Platform.Domain.Shared/LINGYUN/Platform/PlatformErrorCodes.cs

@@ -25,5 +25,13 @@
         /// 元数据格式不匹配
         /// </summary>
         public const string MetaFormatMissMatch = Namespace + ":03001";
+        /// <summary>
+        /// 用户重复收藏菜单
+        /// </summary>
+        public const string UserDuplicateFavoriteMenu = Namespace + ":04400";
+        /// <summary>
+        /// 用户收藏菜单未找到
+        /// </summary>
+        public const string UserFavoriteMenuNotFound = Namespace + ":04404";
     }
 }

aspnet-core/modules/platform/LINGYUN.Platform.Domain.Shared/LINGYUN/Platform/Routes/UserFavoriteMenuConsts.cs

@@ -1,5 +0,0 @@
-namespace LINGYUN.Platform.Routes;
-public class UserFavoriteMenuConsts
-{
-    public static int MaxIconLength { get; set; } = 512;
-}

aspnet-core/modules/platform/LINGYUN.Platform.Domain/LINGYUN/Platform/Menus/IUserFavoriteMenuRepository.cs

@@ -8,13 +8,24 @@ namespace LINGYUN.Platform.Menus;
 
 public interface IUserFavoriteMenuRepository : IBasicRepository<UserFavoriteMenu, Guid>
 {
+    Task<bool> CheckExistsAsync(
+        string framework,
+        Guid userId,
+        Guid menuId,
+        CancellationToken cancellationToken = default);
+
+    Task<UserFavoriteMenu> FindByUserMenuAsync(
+        Guid userId,
+        Guid menuId,
+        CancellationToken cancellationToken = default);
+
     Task<List<UserFavoriteMenu>> GetListByMenuIdAsync(
         Guid menuId,
         CancellationToken cancellationToken = default);
 
     Task<List<UserFavoriteMenu>> GetFavoriteMenusAsync(
-            Guid userId,
+        Guid userId,
-            string framework = null,
+        string framework = null,
-            Guid? menuId = null,
+        Guid? menuId = null,
             CancellationToken cancellationToken = default);
 }

aspnet-core/modules/platform/LINGYUN.Platform.Domain/LINGYUN/Platform/Menus/UserFavoriteMenu.cs

@@ -1,4 +1,6 @@
-using System;
+using LINGYUN.Platform.Routes;
+using System;
+using Volo.Abp;
 using Volo.Abp.Domain.Entities.Auditing;
 using Volo.Abp.MultiTenancy;
 
@@ -12,6 +14,10 @@ public class UserFavoriteMenu : AuditedEntity<Guid>, IMultiTenant
 
     public virtual Guid UserId { get; protected set; }
 
+    public virtual string AliasName { get; set; }
+
+    public virtual string Color { get; set; }
+
     public virtual string Framework { get; set; }
 
     public virtual string Name { get; set; }
@@ -32,16 +38,20 @@ public class UserFavoriteMenu : AuditedEntity<Guid>, IMultiTenant
         string displayName,
         string path,
         string icon,
+        string color,
+        string aliasName = null,
         Guid? tenantId = null)
         : base(id)
     {
         MenuId = menuId;
         UserId = userId;
-        Framework = framework;
+        Framework = Check.NotNullOrWhiteSpace(framework, nameof(framework), LayoutConsts.MaxFrameworkLength);
-        Name = name;
+        Name = Check.NotNullOrWhiteSpace(name, nameof(name), RouteConsts.MaxNameLength);
-        DisplayName = displayName;
+        DisplayName = Check.NotNullOrWhiteSpace(displayName, nameof(displayName), RouteConsts.MaxDisplayNameLength);
-        Path = path;
+        Path = Check.NotNullOrWhiteSpace(path, nameof(path), RouteConsts.MaxPathLength);
-        Icon = icon;
+        Icon = Check.Length(icon, nameof(icon), UserFavoriteMenuConsts.MaxIconLength);
+        Color = Check.Length(color, nameof(color), UserFavoriteMenuConsts.MaxColorLength);
+        AliasName = Check.Length(aliasName, nameof(aliasName), UserFavoriteMenuConsts.MaxAliasNameLength);
         TenantId = tenantId;
     }
 }

aspnet-core/modules/platform/LINGYUN.Platform.EntityFrameworkCore/LINGYUN/Platform/EntityFrameworkCore/PlatformDbContextModelBuilderExtensions.cs

@@ -100,10 +100,18 @@ namespace LINGYUN.Platform.EntityFrameworkCore
                     .IsRequired();
                 x.Property(p => p.Path)
                     .HasMaxLength(RouteConsts.MaxPathLength)
-                    .HasColumnName(nameof(Route.Path));
+                    .HasColumnName(nameof(Route.Path))
+                    .IsRequired();
+
                 x.Property(p => p.Icon)
                     .HasMaxLength(UserFavoriteMenuConsts.MaxIconLength)
                     .HasColumnName(nameof(UserFavoriteMenu.Icon));
+                x.Property(p => p.Color)
+                    .HasMaxLength(UserFavoriteMenuConsts.MaxColorLength)
+                    .HasColumnName(nameof(UserFavoriteMenu.Color));
+                x.Property(p => p.AliasName)
+                    .HasMaxLength(UserFavoriteMenuConsts.MaxAliasNameLength)
+                    .HasColumnName(nameof(UserFavoriteMenu.AliasName));
 
                 x.ConfigureByConvention();
 

aspnet-core/modules/platform/LINGYUN.Platform.EntityFrameworkCore/LINGYUN/Platform/Menus/EfCoreUserFavoriteMenuRepository.cs

@@ -41,4 +41,26 @@ public class EfCoreUserFavoriteMenuRepository :
             .OrderBy(x => x.CreationTime)
             .ToListAsync(GetCancellationToken(cancellationToken));
     }
+
+    public async virtual Task<bool> CheckExistsAsync(
+        string framework, 
+        Guid userId, 
+        Guid menuId, 
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .AnyAsync(x =>
+                x.Framework == framework && x.UserId == userId && x.MenuId == menuId,
+                GetCancellationToken(cancellationToken));
+    }
+
+    public async virtual Task<UserFavoriteMenu> FindByUserMenuAsync(
+        Guid userId, 
+        Guid menuId, 
+        CancellationToken cancellationToken = default)
+    {
+        return await (await GetDbSetAsync())
+            .Where(x => x.UserId == userId && x.MenuId == menuId)
+            .FirstOrDefaultAsync(GetCancellationToken(cancellationToken));
+    }
 }

aspnet-core/modules/platform/LINGYUN.Platform.HttpApi/LINGYUN/Platform/Menus/MenuController.cs

@@ -138,33 +138,5 @@ namespace LINGYUN.Platform.Menus
                 Framework = framework
             });
         }
-
-        [HttpPut]
-        [Route("favorites/by-user/{userId}")]
-        public async virtual Task SetUserFavoriteMenusAsync(Guid userId, UserFavoriteMenuSetInput input)
-        {
-            await MenuAppService.SetUserFavoriteMenusAsync(userId, input);
-        }
-
-        [HttpGet]
-        [Route("favorites/by-user/{userId}")]
-        public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetUserFavoriteMenuListAsync(Guid userId, UserFavoriteMenuGetListInput input)
-        {
-            return await MenuAppService.GetUserFavoriteMenuListAsync(userId, input);
-        }
-
-        [HttpPut]
-        [Route("favorites/by-current-user")]
-        public async virtual Task SetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuSetInput input)
-        {
-            await MenuAppService.SetCurrentUserFavoriteMenuListAsync(input);
-        }
-
-        [HttpGet]
-        [Route("favorites/by-current-user")]
-        public async virtual Task<ListResultDto<UserFavoriteMenuDto>> GetCurrentUserFavoriteMenuListAsync(UserFavoriteMenuGetListInput input)
-        {
-            return await MenuAppService.GetCurrentUserFavoriteMenuListAsync(input);
-        }
     }
 }

aspnet-core/modules/platform/LINGYUN.Platform.HttpApi/LINGYUN/Platform/Menus/UserFavoriteMenuController.cs

@@ -0,0 +1,78 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+
+namespace LINGYUN.Platform.Menus;
+
+[Authorize]
+[RemoteService(Name = PlatformRemoteServiceConsts.RemoteServiceName)]
+[Area("platform")]
+[Route("api/platform/menus/favorites")]
+public class UserFavoriteMenuController : PlatformControllerBase, IUserFavoriteMenuAppService
+{
+    protected IUserFavoriteMenuAppService Service { get; }
+
+    public UserFavoriteMenuController(IUserFavoriteMenuAppService service)
+    {
+        Service = service;
+    }
+
+    [HttpPost]
+    [Route("{userId}")]
+    public virtual Task<UserFavoriteMenuDto> CreateAsync(Guid userId, UserFavoriteMenuCreateDto input)
+    {
+        return Service.CreateAsync(userId, input);
+    }
+
+    [HttpPost]
+    [Route("my-favorite-menu")]
+    public virtual Task<UserFavoriteMenuDto> CreateMyFavoriteMenuAsync(UserFavoriteMenuCreateDto input)
+    {
+        return Service.CreateMyFavoriteMenuAsync(input);
+    }
+
+    [HttpDelete]
+    [Route("{userId}/{MenuId}")]
+    public virtual Task DeleteAsync(Guid userId, UserFavoriteMenuRemoveInput input)
+    {
+        return Service.DeleteAsync(userId, input);
+    }
+
+    [HttpDelete]
+    [Route("my-favorite-menu/{MenuId}")]
+    public virtual Task DeleteMyFavoriteMenuAsync(UserFavoriteMenuRemoveInput input)
+    {
+        return Service.DeleteMyFavoriteMenuAsync(input);
+    }
+
+    [HttpGet]
+    [Route("{userId}")]
+    public virtual Task<ListResultDto<UserFavoriteMenuDto>> GetListAsync(Guid userId, UserFavoriteMenuGetListInput input)
+    {
+        return Service.GetListAsync(userId, input);
+    }
+
+    [HttpGet]
+    [Route("my-favorite-menus")]
+    public virtual Task<ListResultDto<UserFavoriteMenuDto>> GetMyFavoriteMenuListAsync(UserFavoriteMenuGetListInput input)
+    {
+        return Service.GetMyFavoriteMenuListAsync(input);
+    }
+
+    [HttpPut]
+    [Route("{userId}")]
+    public virtual Task<UserFavoriteMenuDto> UpdateAsync(Guid userId, UserFavoriteMenuUpdateDto input)
+    {
+        return Service.UpdateAsync(userId, input);
+    }
+
+    [HttpPut]
+    [Route("my-favorite-menu")]
+    public virtual Task<UserFavoriteMenuDto> UpdateMyFavoriteMenuAsync(UserFavoriteMenuUpdateDto input)
+    {
+        return Service.UpdateMyFavoriteMenuAsync(input);
+    }
+}

aspnet-core/services/LY.MicroService.PlatformManagement.HttpApi.Host/Migrations/20220926012110_Add-Color-And-AliasName-With-UserFavoriteMenu.Designer.cs

@@ -0,0 +1,751 @@
+// <auto-generated />
+using System;
+using LY.MicroService.PlatformManagement.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Volo.Abp.EntityFrameworkCore;
+
+#nullable disable
+
+namespace LY.MicroService.PlatformManagement.Migrations
+{
+    [DbContext(typeof(PlatformManagementMigrationsDbContext))]
+    [Migration("20220926012110_Add-Color-And-AliasName-With-UserFavoriteMenu")]
+    partial class AddColorAndAliasNameWithUserFavoriteMenu
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.MySql)
+                .HasAnnotation("ProductVersion", "6.0.9")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            modelBuilder.Entity("LINGYUN.Platform.Datas.Data", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)")
+                        .HasColumnName("Code");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("varchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)")
+                        .HasColumnName("Description");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("longtext")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsStatic")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasColumnName("Name");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("AppPlatformDatas", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Datas.DataItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<bool>("AllowBeNull")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("varchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid>("DataId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("DefaultValue")
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DefaultValue");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)")
+                        .HasColumnName("Description");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("longtext")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsStatic")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasColumnName("Name");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("ValueType")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataId");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("AppPlatformDataItems", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Layouts.Layout", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("varchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid>("DataId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("longtext")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("Framework")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Framework");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Name");
+
+                    b.Property<string>("Path")
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Path");
+
+                    b.Property<string>("Redirect")
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Redirect");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppPlatformLayouts", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Menus.Menu", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(23)
+                        .HasColumnType("varchar(23)")
+                        .HasColumnName("Code");
+
+                    b.Property<string>("Component")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Component");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("varchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("longtext")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("Framework")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Framework");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsPublic")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("LayoutId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Name");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Path")
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Path");
+
+                    b.Property<string>("Redirect")
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Redirect");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppPlatformMenus", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Menus.RoleMenu", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("MenuId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("varchar(256)")
+                        .HasColumnName("RoleName");
+
+                    b.Property<bool>("Startup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleName", "MenuId");
+
+                    b.ToTable("AppPlatformRoleMenus", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Menus.UserFavoriteMenu", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("AliasName")
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("AliasName");
+
+                    b.Property<string>("Color")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasColumnName("Color");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<string>("Framework")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Framework");
+
+                    b.Property<string>("Icon")
+                        .HasMaxLength(512)
+                        .HasColumnType("varchar(512)")
+                        .HasColumnName("Icon");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("MenuId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("varchar(64)")
+                        .HasColumnName("Name");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Path");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "MenuId");
+
+                    b.ToTable("AppPlatformUserFavoriteMenus", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Menus.UserMenu", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("MenuId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<bool>("Startup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("char(36)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "MenuId");
+
+                    b.ToTable("AppPlatformUserMenus", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Versions.AppVersion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(40)
+                        .HasColumnType("varchar(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2048)
+                        .HasColumnType("varchar(2048)")
+                        .HasColumnName("Description");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("longtext")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<int>("Level")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlatformType")
+                        .HasColumnType("int");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("varchar(50)")
+                        .HasColumnName("Title");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasColumnName("Version");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Version");
+
+                    b.ToTable("AppPlatformVersion", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Versions.VersionFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("AppVersionId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int>("DownloadCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FileType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Name");
+
+                    b.Property<string>("Path")
+                        .HasMaxLength(255)
+                        .HasColumnType("varchar(255)")
+                        .HasColumnName("Path");
+
+                    b.Property<string>("SHA256")
+                        .IsRequired()
+                        .HasMaxLength(65)
+                        .HasColumnType("varchar(65)")
+                        .HasColumnName("SHA256");
+
+                    b.Property<long>("Size")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("char(36)")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("varchar(20)")
+                        .HasColumnName("Version");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AppVersionId");
+
+                    b.HasIndex("Path", "Name", "Version")
+                        .IsUnique();
+
+                    b.ToTable("AppPlatformVersionFile", (string)null);
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Datas.DataItem", b =>
+                {
+                    b.HasOne("LINGYUN.Platform.Datas.Data", null)
+                        .WithMany("Items")
+                        .HasForeignKey("DataId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Versions.VersionFile", b =>
+                {
+                    b.HasOne("LINGYUN.Platform.Versions.AppVersion", "AppVersion")
+                        .WithMany("Files")
+                        .HasForeignKey("AppVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AppVersion");
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Datas.Data", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("LINGYUN.Platform.Versions.AppVersion", b =>
+                {
+                    b.Navigation("Files");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

aspnet-core/services/LY.MicroService.PlatformManagement.HttpApi.Host/Migrations/20220926012110_Add-Color-And-AliasName-With-UserFavoriteMenu.cs

@@ -0,0 +1,71 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LY.MicroService.PlatformManagement.Migrations
+{
+    public partial class AddColorAndAliasNameWithUserFavoriteMenu : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                table: "AppPlatformUserFavoriteMenus",
+                keyColumn: "Path",
+                keyValue: null,
+                column: "Path",
+                value: "");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Path",
+                table: "AppPlatformUserFavoriteMenus",
+                type: "varchar(255)",
+                maxLength: 255,
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "varchar(255)",
+                oldMaxLength: 255,
+                oldNullable: true)
+                .Annotation("MySql:CharSet", "utf8mb4")
+                .OldAnnotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.AddColumn<string>(
+                name: "AliasName",
+                table: "AppPlatformUserFavoriteMenus",
+                type: "varchar(128)",
+                maxLength: 128,
+                nullable: true)
+                .Annotation("MySql:CharSet", "utf8mb4");
+
+            migrationBuilder.AddColumn<string>(
+                name: "Color",
+                table: "AppPlatformUserFavoriteMenus",
+                type: "varchar(30)",
+                maxLength: 30,
+                nullable: true)
+                .Annotation("MySql:CharSet", "utf8mb4");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "AliasName",
+                table: "AppPlatformUserFavoriteMenus");
+
+            migrationBuilder.DropColumn(
+                name: "Color",
+                table: "AppPlatformUserFavoriteMenus");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "Path",
+                table: "AppPlatformUserFavoriteMenus",
+                type: "varchar(255)",
+                maxLength: 255,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "varchar(255)",
+                oldMaxLength: 255)
+                .Annotation("MySql:CharSet", "utf8mb4")
+                .OldAnnotation("MySql:CharSet", "utf8mb4");
+        }
+    }
+}

aspnet-core/services/LY.MicroService.PlatformManagement.HttpApi.Host/Migrations/PlatformHttpApiHostMigrationsDbContextModelSnapshot.cs

@@ -449,6 +449,16 @@ namespace LY.MicroService.PlatformManagement.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("char(36)");
 
+                    b.Property<string>("AliasName")
+                        .HasMaxLength(128)
+                        .HasColumnType("varchar(128)")
+                        .HasColumnName("AliasName");
+
+                    b.Property<string>("Color")
+                        .HasMaxLength(30)
+                        .HasColumnType("varchar(30)")
+                        .HasColumnName("Color");
+
                     b.Property<DateTime>("CreationTime")
                         .HasColumnType("datetime(6)")
                         .HasColumnName("CreationTime");
@@ -492,6 +502,7 @@ namespace LY.MicroService.PlatformManagement.Migrations
                         .HasColumnName("Name");
 
                     b.Property<string>("Path")
+                        .IsRequired()
                         .HasMaxLength(255)
                         .HasColumnType("varchar(255)")
                         .HasColumnName("Path");

aspnet-core/services/LY.MicroService.PlatformManagement.HttpApi.Host/PlatformManagementHttpApiHostModule.Configure.cs

@@ -326,7 +326,7 @@ public partial class PlatformManagementHttpApiHostModule
 
         if (isDevelopment)
         {
-            // services.AddAlwaysAllowAuthorization();
+            services.AddAlwaysAllowAuthorization();
         }
 
         if (!isDevelopment)