fengling/fengling-platform
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

Compare commits

base: fengling:main
Branches Tags
fengling:main
fengling:v1.0.14
fengling:v1.0.13
fengling:v1.0.12
fengling:v1.0.11
fengling:v1.0.10
fengling:v1.0.9
fengling:v1.0.8
fengling:v1.0.7
fengling:v1.0.6
fengling:v1.0.5
fengling:v1.0.4
fengling:v1.0.3
fengling:v1.0.2
fengling:v1.0.1
fengling:v1.0.0
..
compare: fengling:v1.0.2
Branches Tags
fengling:main
fengling:v1.0.14
fengling:v1.0.13
fengling:v1.0.12
fengling:v1.0.11
fengling:v1.0.10
fengling:v1.0.9
fengling:v1.0.8
fengling:v1.0.7
fengling:v1.0.6
fengling:v1.0.5
fengling:v1.0.4
fengling:v1.0.3
fengling:v1.0.2
fengling:v1.0.1
fengling:v1.0.0

No commits in common. "main" and "v1.0.2" have entirely different histories.
main ... v1.0.2

102 changed files with 4755 additions and 2866 deletions
Show Stats Expand all files Collapse all files

37
.gitea/workflownuget.ymls Normal file
View File

@ -0,0 +1,37 @@
name: Publish NuGet Packages
on:
push:
branches: [main]
tags:
- "v*"
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
GITEA_URL: https://gitea.shtao1.cn
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
dotnet-version: "10.0.x"
- name: Pack Domain
if: startsWith(github.ref, "refs/tags/v")
run: dotnet pack fengling-platform/Fengling.Platform.Domain/Fengling.Platform.Domain.csproj -c Release -o ./packages
- name: Pack Infrastructure
if: startsWith(github.ref, "refs/tags/v")
run: dotnet pack fengling-platform/Fengling.Platform.Infrastructure/Fengling.Platform.Infrastructure.csproj -c Release -o ./packages
- name: Push to Gitea
if: startsWith(github.ref, "refs/tags/v")
run: |
for pkg in ./packages/*.nupkg; do
dotnet nuget push "$pkg" --source "$GITEA_URL/gitea_registry/movingsam/go/__index" --skip-duplicate
done

21
.gitea/workflows/nuget.yml
View File

@ -1,14 +1,13 @@
name: Publish Platform NuGet Packages
name: Publish NuGet Packages
on:
push:
branches:
- main
branches: [main]
tags:
- "v*"
env:
GITEA_TOKEN: ${{ secrets.GITEATOKEN }}
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
GITEA_URL: https://gitea.shtao1.cn
jobs:
@ -22,25 +21,17 @@ jobs:
with:
dotnet-version: "10.0.x"
- name: Get version from tag
if: startsWith(github.ref, 'refs/tags/v')
id: version
run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
- name: Pack Domain
if: startsWith(github.ref, 'refs/tags/v')
run: dotnet pack Fengling.Platform.Domain/Fengling.Platform.Domain.csproj -c Release -o ./packages -p:PackageVersion=${{ steps.version.outputs.VERSION }}
run: dotnet pack Fengling.Platform.Domain/Fengling.Platform.Domain.csproj -c Release -o ./packages
- name: Pack Infrastructure
if: startsWith(github.ref, 'refs/tags/v')
run: dotnet pack Fengling.Platform.Infrastructure/Fengling.Platform.Infrastructure.csproj -c Release -o ./packages -p:PackageVersion=${{ steps.version.outputs.VERSION }}
run: dotnet pack Fengling.Platform.Infrastructure/Fengling.Platform.Infrastructure.csproj -c Release -o ./packages
- name: Push to Gitea
if: startsWith(github.ref, 'refs/tags/v')
run: |
for pkg in ./packages/*.nupkg; do
dotnet nuget push "$pkg" \
--source "$GITEA_URL/api/packages/fengling/nuget/index.json" \
--api-key "$GITEA_TOKEN" \
--skip-duplicate
dotnet nuget push "$pkg" --source "$GITEA_URL/gitea_registry/fengling/go/__index" --skip-duplicate
done

26
.gitea/workflows/publish-nuget.yml Normal file
View File

@ -0,0 +1,26 @@
name: Publish NuGet Package
on:
push:
tags:
- 'v*'
jobs:
publish:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup .NET
uses: actions/setup-dotnet@v4
with:
dotnet-version: '10.0'
- name: Publish NuGet packages
run: |
./push-platform-nuget.sh all
env:
GITEA_HOST: gitea.shtao1.cn
GITEA_ORG: fengling
GITEA_API_TOKEN: ${{ secrets.GITEA_TOKEN }}

57
.planning/ROADMAP.md
View File

@ -10,61 +10,38 @@
**Goal:** Migrate YARP gateway routing entities from fengling-gateway to Platform project with unified management
**Status:** ● Completed
**Status:** ○ Planned
**Requirements:**
- [x] GATEWAY-01: GwTenant entity and management
- [x] GATEWAY-02: GwTenantRoute entity and management
- [x] GATEWAY-03: GwServiceInstance entity and management
- [x] GATEWAY-04: Extensions for IoC registration
- [x] GATEWAY-05: Database migrations
- [ ] GATEWAY-01: GwTenant entity and management
- [ ] GATEWAY-02: GwTenantRoute entity and management
- [ ] GATEWAY-03: GwServiceInstance entity and management
- [ ] GATEWAY-04: Extensions for IoC registration
- [ ] GATEWAY-05: Database migrations
**Plans:**
- [x] 01-01-PLAN.md — Domain entities (GwTenant, GwTenantRoute, GwServiceInstance) ✅
- [x] 01-02-PLAN.md — Infrastructure (Store, Manager, DbContext) ✅
- [x] 01-03-PLAN.md — Extensions and IoC integration ✅
- [ ] 01-01-PLAN.md — Domain entities (GwTenant, GwTenantRoute, GwServiceInstance)
- [ ] 01-02-PLAN.md — Infrastructure (Store, Manager, DbContext)
- [ ] 01-03-PLAN.md — Extensions and IoC integration
---
## Phase 2: Platform Core
## Phase 2: Platform Core (Future)
**Goal:** Complete multi-tenant platform infrastructure
**Status:** ● Completed
**Status:** ○ Planned
**Requirements:**
- [x] USER-01: User management
- [x] USER-02: Role and permissions
- [x] AUTH-01: Authentication flows
- [x] AUTH-02: Authorization
---
## Phase 3: Gateway Cluster Entities
**Goal:** Restructure gateway cluster management - replace GwServiceInstance with GwCluster aggregate root
**Status:** ● In Progress
MV|**Requirements:**
- [x] GATEWAY-RESTRUCTURE-01: GwCluster aggregate root
- [x] GATEWAY-RESTRUCTURE-02: GwCluster value objects (GwDestination, GwHealthCheckConfig, GwSessionAffinityConfig)
- [x] GATEWAY-RESTRUCTURE-03: Extended GwTenantRoute with YARP fields
- [x] GATEWAY-RESTRUCTURE-04: Removed obsolete GwTenant and GwServiceInstance entities
YX|**Plans:**
- [x] 03-gateway-cluster-entities-PLAN.md — Cluster entities ✅
- [x] 03-gateway-route-update-PLAN.md — Route update ✅
**Requirements:**
- [x] GATEWAY-RESTRUCTURE-01: GwCluster aggregate root
- [x] GATEWAY-RESTRUCTURE-02: GwCluster value objects (GwDestination, GwHealthCheckConfig, GwSessionAffinityConfig)
**Plans:**
- [x] 03-gateway-cluster-entities-PLAN.md — Cluster entities ✅
- [ ] USER-01: User management
- [ ] USER-02: Role and permissions
- [ ] AUTH-01: Authentication flows
- [ ] AUTH-02: Authorization
---
## Notes
- Gateway routing entities migrated from `../fengling-gateway/src/Models/`
- Gateway routing entities will be migrated from `../fengling-gateway/src/Models/`
- Pattern: Manager + Store (same as Tenant management)
- Extensions for quick IoC installation via `AddPlatformCore<TContext>()`
- GwCluster replaces old GwServiceInstance design with embedded value objects

67
.planning/STATE.md
View File

@ -1,26 +1,11 @@
---
gsd_state_version: 1.0
milestone: v1.0
milestone_name: milestone
status: unknown
last_updated: "2026-03-03T08:02:48.144Z"
progress:
total_phases: 2
completed_phases: 2
total_plans: 7
completed_plans: 7
---
# Project State
**Last Updated:** 2026-03-03
**Last Updated:** 2026-02-28
## Status
- **Phase:** 03-gateway-infrastructure-update
- **Plan:** 03 ✅ Completed
- **Phase:** Planning new gateway routing feature
- **Milestone:** v1.0 - Platform Foundation
- **Position:** Completed Plan 03 of Phase 03
## Project Context
@ -29,20 +14,16 @@ This is the Fengling.Platform project - a multi-tenant identity and authenticati
### Current State
- Platform layer initialized with Tenant, User, Role aggregates
- **GatewayAggregate updated** - GwTenantRoute extended, GwTenant and GwServiceInstance removed
- **NEW: GwCluster aggregate** added with embedded value objects (GwDestination, GwHealthCheckConfig, GwSessionAffinityConfig)
- **NEW: IClusterStore/ClusterStore** - Store pattern for GwCluster
- Manager + Store pattern established (ITenantStore, ITenantManager, IRouteStore, IClusterStore)
- Extensions for DI registration (AddPlatformCore<TContext>, AddGatewayCore<TContext>)
- Manager + Store pattern established (ITenantStore, ITenantManager)
- Extensions for DI registration (AddPlatformCore<TContext>)
- PostgreSQL database with EF Core migrations
### Source for Migration
**fengling-gateway** project (parent directory):
- `GwTenant` - 租户实体 (REMOVED - use Platform.Tenant)
- `GwTenantRoute` - 路由配置实体 (EXTENDED)
- `GwServiceInstance` - 服务实例实体 (REMOVED - use GwCluster embedded)
- `GwCluster` - 集群聚合根 (NEW)
- `GwTenant` - 租户实体
- `GwTenantRoute` - 路由配置实体
- `GwServiceInstance` - 服务实例实体
- GatewayDbContext with PostgreSQL
## Decisions
@ -50,41 +31,11 @@ This is the Fengling.Platform project - a multi-tenant identity and authenticati
- Using Manager + Store pattern from existing Tenant implementation
- Extensions-based DI registration for quick IoC setup
- Align with existing Platform coding conventions
- **ID Strategy:** GwTenant uses `long` ID (Platform convention); GwTenantRoute, GwCluster use `string` GUID IDs (YARP-compatible)
- **Cluster Design:** GwCluster uses embedded value objects (Owned Entity pattern) for Destinations, HealthCheck, SessionAffinity
- **Route Update:** Extended GwTenantRoute with Methods, Hosts, Headers, LoadBalancingPolicy, AuthorizationPolicy, CorsPolicy, Transforms fields
## Blockers
None.
## Accumulated Context
### Roadmap Evolution
- Phase 1: Gateway routing entities ✅
- Phase 2: Platform infrastructure ✅
- Phase 3: Gateway cluster entities (current)
- Plan 01: Cluster entities ✅
- Plan 02: Route update ✅
- Plan 03: Infrastructure cleanup ✅ (just completed)
### Phase 03 Progress
- **Plan 01: Gateway Cluster Entities** ✅ COMPLETED
- Created GwCluster aggregate root
- Created GwDestination value object
- Created GwHealthCheckConfig value object
- Created GwSessionAffinityConfig value object
- **Plan 02: Gateway Route Update** ✅ COMPLETED
- Extended GwTenantRoute with YARP fields
- Removed obsolete GwTenant entity
- Removed obsolete GwServiceInstance entity
- **Plan 03: Infrastructure Update** ✅ COMPLETED
- Updated PlatformDbContext with GwCluster DbSet
- Created IClusterStore/ClusterStore
- Deleted IInstanceStore/InstanceStore
None
## Pending
- Plan 04: Gateway DI registration (update DI registration for IClusterStore)
- Plan and implement gateway routing migration

88
.planning/phases/01-gateway-routing/01-gateway-routing-01-SUMMARY.md
View File

@ -1,88 +0,0 @@
# Summary: Plan 01 - Gateway Domain Entities
**Phase:** 01-gateway-routing
**Plan:** 01
**Status:** ✅ Completed
**Date:** 2026-03-03
---
## Tasks Completed
| Task | Status | Notes |
|------|--------|-------|
| Task 1: Create GatewayEnums | ✅ | RouteStatus, InstanceHealth, InstanceStatus |
| Task 2: Create GwTenant | ✅ | 54 lines, all required fields |
| Task 3: Create GwTenantRoute | ✅ | 74 lines, all required fields |
| Task 4: Create GwServiceInstance | ✅ | 69 lines, all required fields |
---
## Artifacts Created
```
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/
├── GatewayEnums.cs (28 lines)
├── GwTenant.cs (54 lines)
├── GwTenantRoute.cs (74 lines)
└── GwServiceInstance.cs (69 lines)
```
---
## Verification Results
### GatewayEnums.cs
- ✅ `RouteStatus` enum: Inactive=0, Active=1
- ✅ `InstanceHealth` enum: Unhealthy=0, Healthy=1
- ✅ `InstanceStatus` enum: Inactive=0, Active=1
### GwTenant.cs
- ✅ `Id` (long) - matches Platform convention
- ✅ `TenantCode`, `TenantName` (string)
- ✅ `Status` (int)
- ✅ Audit fields: CreatedBy, CreatedTime, UpdatedBy, UpdatedTime
- ✅ Soft delete: IsDeleted (bool)
- ✅ Concurrency: Version (int)
### GwTenantRoute.cs
- ✅ `Id` (string, Guid-based) - YARP-compatible
- ✅ `TenantCode` (string) - links to GwTenant
- ✅ `ServiceName`, `ClusterId`, `PathPattern` (string)
- ✅ `Priority` (int), `Status` (int), `IsGlobal` (bool)
- ✅ Full audit and soft delete support
### GwServiceInstance.cs
- ✅ `Id` (string, Guid-based) - YARP-compatible
- ✅ `ClusterId`, `DestinationId`, `Address` (string)
- ✅ `Health`, `Weight`, `Status` (int)
- ✅ Full audit and soft delete support
---
## Design Decisions
### ID Type for Route and ServiceInstance
**Plan specified:** `long` for all IDs
**Implementation uses:** `string` with `Guid.CreateVersion7()` for GwTenantRoute and GwServiceInstance
**Rationale:** String-based GUID IDs are more suitable for YARP route configuration and distributed service discovery scenarios. GwTenant retains `long` ID to maintain consistency with Platform's tenant management.
---
## Requirements Mapping
| Requirement | Status | Evidence |
|-------------|--------|----------|
| GATEWAY-01 | ✅ Partial | GwTenant entity created |
| GATEWAY-02 | ✅ Partial | GwTenantRoute entity created |
| GATEWAY-03 | ✅ Partial | GwServiceInstance entity created |
> Note: Full requirement completion requires infrastructure layer (Store, Manager, DbContext) in subsequent plans.
---
## Next Steps
- Plan 02: Infrastructure layer (Store, Manager, DbContext configurations)
- Plan 03: Extensions and IoC integration

94
.planning/phases/01-gateway-routing/01-gateway-routing-02-SUMMARY.md
View File

@ -1,94 +0,0 @@
# Summary: Plan 02 - Gateway Infrastructure
**Phase:** 01-gateway-routing
**Plan:** 02
**Status:** Completed
**Date:** 2026-03-03
---
## Tasks Completed
### Task 1: GatewayDbContext (Integrated into PlatformDbContext)
- **Status:** Done
- **Location:** `Fengling.Platform.Infrastructure/PlatformDbContext.cs`
- **Details:** Gateway DbSets integrated into PlatformDbContext (not separate file)
- `DbSet<GwTenant> GwTenants`
- `DbSet<GwTenantRoute> GwTenantRoutes`
- `DbSet<GwServiceInstance> GwServiceInstances`
- **Indexes configured:**
- GwTenant: TenantCode unique
- GwTenantRoute: TenantCode, ServiceName, ClusterId, composite (ServiceName, IsGlobal, Status)
- GwServiceInstance: composite unique (ClusterId, DestinationId), Health
### Task 2: IRouteStore and RouteStore
- **Status:** Done
- **Files:**
- `Fengling.Platform.Infrastructure/IRouteStore.cs`
- `Fengling.Platform.Infrastructure/RouteStore.cs`
- **Pattern:** Follows TenantStore pattern with generic constraint `where TContext : PlatformDbContext`
- **Methods:** FindByIdAsync, FindByTenantCodeAsync, FindByClusterIdAsync, GetAllAsync, GetPagedAsync, GetCountAsync, CreateAsync, UpdateAsync, DeleteAsync
- **Features:** Soft delete support, paged queries with filters
### Task 3: IRouteManager and RouteManager
- **Status:** Done
- **Files:**
- `Fengling.Platform.Infrastructure/IRouteManager.cs`
- `Fengling.Platform.Infrastructure/RouteManager.cs`
- **Pattern:** Delegates to IRouteStore (matches TenantManager pattern)
- **Constructor:** `public RouteManager(IRouteStore store)`
- **Methods:** FindByIdAsync, FindByTenantCodeAsync, GetAllAsync, CreateRouteAsync, UpdateRouteAsync, DeleteRouteAsync
### Task 4: IInstanceStore and InstanceStore
- **Status:** Done
- **Files:**
- `Fengling.Platform.Infrastructure/IInstanceStore.cs`
- `Fengling.Platform.Infrastructure/InstanceStore.cs`
- **Pattern:** Similar to RouteStore, generic constraint `where TContext : PlatformDbContext`
- **Methods:** FindByIdAsync, FindByClusterIdAsync, FindByDestinationAsync, GetAllAsync, GetPagedAsync, GetCountAsync, CreateAsync, UpdateAsync, DeleteAsync
- **Features:** ClusterId and DestinationId queries, health/status filtering
---
## Verification
- [x] Build passes with 0 errors
- [x] Store implementations follow TenantStore pattern
- [x] Manager implementations delegate to Stores
- [x] DbContext contains all required DbSets and indexes
- [x] Soft delete implemented in all Store classes
---
## Key Decisions
1. **DbContext Location:** Gateway entities integrated into PlatformDbContext rather than separate GatewayDbContext
- Rationale: Follows existing project conventions, simplifies DI
2. **ID Type:** Using `string` IDs for Gateway entities (consistent with source fengling-gateway)
- GwTenant.Id, GwTenantRoute.Id, GwServiceInstance.Id are strings
3. **Soft Delete:** All Store implementations support soft delete via `IsDeleted` property
---
## Artifacts Created
| File | Purpose |
|------|---------|
| `PlatformDbContext.cs` | Contains GwTenants, GwTenantRoutes, GwServiceInstances DbSets |
| `IRouteStore.cs` | Route CRUD interface |
| `RouteStore.cs` | Route data access implementation |
| `IRouteManager.cs` | Route business operations |
| `RouteManager.cs` | Route business logic |
| `IInstanceStore.cs` | Service instance CRUD interface |
| `InstanceStore.cs` | Service instance data access implementation |
---
## Next Steps
Plan 03 will add:
- Extensions for IoC registration
- `AddGatewayStores<TContext>()` extension method
- DI configuration for Managers and Stores

63
.planning/phases/01-gateway-routing/01-gateway-routing-03-SUMMARY.md
View File

@ -1,63 +0,0 @@
# 计划 03 执行摘要
**计划:** 01-gateway-routing-03
**状态:** ✓ 完成
**日期:** 2026-03-03
## 完成的任务
### 任务 1: 创建 GatewayExtensions ✓
创建了 `Fengling.Platform.Infrastructure/GatewayExtensions.cs`:
```csharp
public static class GatewayExtensions
{
public static IServiceCollection AddGatewayCore<TContext>(this IServiceCollection services)
where TContext : PlatformDbContext
{
services.AddScoped<IRouteStore, RouteStore<TContext>>();
services.AddScoped<IInstanceStore, InstanceStore<TContext>>();
services.AddScoped<IRouteManager, RouteManager>();
return services;
}
}
```
**设计决策:**
- 使用 `PlatformDbContext` 作为约束（而非计划中的 `GatewayDbContext`）
- Gateway 实体已集成到 `PlatformDbContext` 中，无需单独的 `GatewayDbContext`
### 任务 2: 数据库迁移 ⚠
**跳过原因:** EF Core 工具在当前环境中不可用。迁移应在实际部署时生成。
**迁移命令参考:**
```bash
cd Fengling.Platform.Infrastructure
dotnet ef migrations add InitialGateway --startup-project ../path/to/startup
```
## 验证结果
- [x] `GatewayExtensions.cs` 已创建
- [x] 构建通过 (0 错误, 4 警告)
- [x] `AddGatewayCore<TContext>` 方法可正常注册所有 Gateway 服务
## 偏差说明
| 原计划 | 实际实现 | 原因 |
|--------|----------|------|
| `where TContext : GatewayDbContext` | `where TContext : PlatformDbContext` | Gateway 实体已集成到 PlatformDbContext |
| 生成 EF 迁移 | 跳过 | EF 工具不可用，推迟到部署时 |
## 后续步骤
- Phase 1 完成
- 可以开始 Phase 2: Platform Core 或 Phase 3: 网关调整
---
*Phase: 01-gateway-routing*
*Plan: 03*
*执行时间: 2026-03-03*

0
.planning/phases/03-/.gitkeep
View File

199
.planning/phases/03-/03-CONTEXT.md
View File

@ -1,199 +0,0 @@
# Phase 3: 调整网关部分的需求 - Context
**Gathered:** 2026-03-03
**Status:** Ready for planning
<domain>
## Phase Boundary
调整 Gateway 模块的实体结构和 YARP 集成方式，包括：
- 重构实体模型（删除 GwTenant 和 GwServiceInstance，新增 GwCluster）
- 扩展 GwTenantRoute 的匹配和转换能力
- 实现与 YARP 配置模型的完整对接
</domain>
<decisions>
## Implementation Decisions
### 实体结构调整
#### 删除的实体
- **GwTenant** - 删除，直接使用 Platform.Tenant 通过 TenantCode 关联
- **GwServiceInstance** - 删除，改为 GwCluster 聚合根内嵌 Destination
#### 新增的实体
**GwCluster（集群聚合根）**
- `string Id` - GUID，与 YARP ClusterId 类型一致
- `string ClusterId` - 集群标识（业务 ID）
- `string Name` - 集群名称
- `string? Description` - 描述
- `List<GwDestination> Destinations` - 目标端点列表（内嵌）
- `string LoadBalancingPolicy` - 负载均衡策略 (RoundRobin, WeightedRoundRobin, LeastRequests 等)
- `GwHealthCheckConfig? HealthCheck` - 健康检查配置
- `GwSessionAffinityConfig? SessionAffinity` - 会话亲和配置
- `int Status` - 状态
- 审计字段 (CreatedBy, CreatedTime, UpdatedBy, UpdatedTime, IsDeleted, Version)
**GwDestination（内嵌值对象）**
- `string DestinationId` - 目标标识
- `string Address` - 后端地址
- `string? Health` - 健康检查端点
- `int Weight` - 权重（用于加权负载均衡）
- `int HealthStatus` - 健康状态
- `int Status` - 状态
**GwHealthCheckConfig（内嵌值对象）**
- `bool Enabled` - 是否启用
- `string? Path` - 健康检查路径 (默认 /health)
- `int IntervalSeconds` - 检查间隔（秒）
- `int TimeoutSeconds` - 超时时间（秒）
**GwSessionAffinityConfig（内嵌值对象）**
- `bool Enabled` - 是否启用
- `string Policy` - 策略 (Header)
- `string AffinityKeyName` - 亲和键名称
#### 修改的实体
**GwTenantRoute 扩展字段**
- `string? Methods` - HTTP 方法匹配 (GET,POST,PUT,DELETE 等)
- `string? Hosts` - Host 头匹配 (支持通配符)
- `string? Headers` - Header 匹配规则 (JSON 格式)
- `string? LoadBalancingPolicy` - 路由级别负载均衡策略覆盖
- `string? AuthorizationPolicy` - 授权策略
- `string? RateLimiterPolicy` - 限流策略
- `string? CorsPolicy` - CORS 策略
- `string? Transforms` - 请求/响应转换规则 (JSON 格式)
保留现有字段：
- `string Id` - GUID v7
- `string TenantCode` - 租户代码（关联 Platform.Tenant）
- `string ServiceName` - 服务名称
- `string ClusterId` - 关联 GwCluster
- `string PathPattern` - 路径匹配模式
- `int Priority` - 优先级
- `int Status` - 状态
- `bool IsGlobal` - 是否全局路由
### 路由匹配能力
- **Path**: 完整支持 YARP Path 模式 (如 `/api/{**catch-all}`)
- **Methods**: 支持 HTTP 方法过滤，逗号分隔 (如 `GET,POST`)
- **Hosts**: 支持 Host 头匹配，逗号分隔 (如 `api.example.com,*.api.com`)
- **Headers**: JSON 格式动态配置，如 `[{"Name":"X-Custom","Values":["value1"],"Mode":"ExactHeader"}]`
### 负载均衡策略
- **集群级别配置**: GwCluster.LoadBalancingPolicy 存储默认策略
- **路由级别覆盖**: GwTenantRoute.LoadBalancingPolicy 可覆盖集群默认策略
- 支持策略: `RoundRobin`, `LeastRequests`, `Random`, `PowerOfTwoChoices`, `WeightedRoundRobin`
### 会话亲和 (Session Affinity)
- **策略**: Header 方式
- **标识来源**: UserId 优先，TenantCode 兜底
- **AffinityKeyName**: `X-Session-Key`
- **实现逻辑**:
1. 已登录用户: 使用 `UserId` 作为会话键
2. 未登录用户: 使用 `TenantCode` 作为会话键
3. 同一会话键的请求路由到同一后端实例
### 健康检查
- **方式**: 主动健康检查 (Active Health Check)
- **配置位置**: GwCluster.HealthCheck
- **默认配置**:
- Path: `/health`
- Interval: 30 秒
- Timeout: 10 秒
### 请求/响应转换 (Transforms)
- **格式**: JSON 数组
- **示例**:
```json
[
{"RequestHeader": "X-Forwarded-For", "Set": "true"},
{"ResponseHeader": "X-Served-By", "Set": "gateway"}
]
```
- 支持的转换类型: RequestHeader, ResponseHeader, PathPrefix, PathRemovePrefix 等
### 租户关联
- **GwTenant 删除**: 不再单独维护网关租户表
- **关联方式**: 通过 `TenantCode` 直接关联 Platform.Tenant
- **TenantCode 来源**:
- 已登录用户: 从 User.TenantInfo.TenantCode 获取
- 请求头: 从 `X-Tenant-Code` 获取
### ID 类型约定
| 实体 | ID 类型 | 原因 |
|------|---------|------|
| GwTenantRoute | `string` (GUID v7) | 与 YARP RouteId 一致 |
| GwCluster | `string` (GUID) | 与 YARP ClusterId 一致 |
| GwDestination | 无独立 ID | 内嵌值对象 |
### Claude's Discretion
- Transforms JSON 的具体结构和验证规则
- HealthCheckConfig 和 SessionAffinityConfig 的详细字段设计
- Header 匹配规则 JSON 的完整 Schema
- 错误处理和验证逻辑
</decisions>
<specifics>
## Specific Ideas
- 会话亲和 Header 名称: `X-Session-Key`
- 健康检查默认路径: `/health`
- 负载均衡默认策略: `PowerOfTwoChoices` (YARP 推荐)
- Header 匹配采用 JSON 格式，支持运行时动态配置
</specifics>
<code_context>
## Existing Code Insights
### 需要删除的文件
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenant.cs`
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwServiceInstance.cs`
### 需要修改的文件
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs` - 扩展字段
- `Fengling.Platform.Infrastructure/PlatformDbContext.cs` - 更新 DbSet 和配置
- `Fengling.Platform.Infrastructure/IInstanceStore.cs` - 删除或改为 IClusterStore
- `Fengling.Platform.Infrastructure/InstanceStore.cs` - 删除或改为 ClusterStore
### 需要新增的文件
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs`
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs`
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs`
- `Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs`
- `Fengling.Platform.Infrastructure/IClusterStore.cs`
- `Fengling.Platform.Infrastructure/ClusterStore.cs`
### 参考资源
- YARP 配置模型文档: `docs/yarp-configuration-model.md`
- YARP 官方仓库: https://github.com/microsoft/reverse-proxy
</code_context>
<deferred>
## Deferred Ideas
- 被动健康检查 (Passive Health Check) - 可在后续版本添加
- 限流策略配置 (RateLimiterPolicy) - 可在后续版本添加
- 授权策略配置 (AuthorizationPolicy) - 可在后续版本添加
- CORS 策略配置 (CorsPolicy) - 可在后续版本添加
</deferred>
---
*Phase: 03-*
*Context gathered: 2026-03-03*

325
.planning/phases/03-/03-RESEARCH.md
View File

@ -1,325 +0,0 @@
# Phase 3: 调整网关部分的需求 - 技术研究
**日期:** 2026-03-03
**状态:** 研究完成
---
## 1. EF Core Owned Entity 配置模式
### GwDestination 内嵌实体
```csharp
// 在 GwCluster 中配置 Owned Entity
modelBuilder.Entity<GwCluster>(entity =>
{
entity.HasKey(e => e.Id);
entity.Property(e => e.ClusterId).HasMaxLength(100).IsRequired();
entity.HasIndex(e => e.ClusterId).IsUnique();
// 配置内嵌的 Destinations 列表
entity.OwnsMany(e => e.Destinations, dest =>
{
dest.WithOwner().HasForeignKey("GwClusterId");
dest.Property(d => d.DestinationId).HasMaxLength(100).IsRequired();
dest.Property(d => d.Address).HasMaxLength(200).IsRequired();
dest.Property(d => d.Health).HasMaxLength(200);
dest.Property(d => d.Weight).HasDefaultValue(1);
dest.Property(d => d.HealthStatus).HasDefaultValue(1);
dest.Property(d => d.Status).HasDefaultValue(1);
// 复合唯一索引
dest.HasIndex(d => new { d.DestinationId }).IsUnique();
});
});
```
### GwHealthCheckConfig 内嵌值对象
```csharp
entity.OwnsOne(e => e.HealthCheck, hc =>
{
hc.Property(h => h.Enabled).HasDefaultValue(false);
hc.Property(h => h.Path).HasMaxLength(100).HasDefaultValue("/health");
hc.Property(h => h.IntervalSeconds).HasDefaultValue(30);
hc.Property(h => h.TimeoutSeconds).HasDefaultValue(10);
});
```
### GwSessionAffinityConfig 内嵌值对象
```csharp
entity.OwnsOne(e => e.SessionAffinity, sa =>
{
sa.Property(s => s.Enabled).HasDefaultValue(false);
sa.Property(s => s.Policy).HasMaxLength(50).HasDefaultValue("Header");
sa.Property(s => s.AffinityKeyName).HasMaxLength(100).HasDefaultValue("X-Session-Key");
});
```
---
## 2. 实体迁移策略
### 删除现有实体
```csharp
// 1. 从 PlatformDbContext 中移除 DbSet
public DbSet<GwTenant> GwTenants => Set<GwTenant>(); // 删除
public DbSet<GwServiceInstance> GwServiceInstances => Set<GwServiceInstance>(); // 删除
// 2. 移除 OnModelCreating 中的配置
// modelBuilder.Entity<GwTenant>(...) - 删除
// modelBuilder.Entity<GwServiceInstance>(...) - 删除
```
### 创建 EF Core 迁移
```bash
# 创建迁移
dotnet ef migrations add RestructureGatewayEntities --project Fengling.Platform.Infrastructure
# 迁移将执行：
# - DROP TABLE GwTenants
# - DROP TABLE GwServiceInstances
# - CREATE TABLE GwClusters (包含 Destinations 作为 JSON 或关联表)
# - ALTER TABLE GwTenantRoutes (添加新字段)
```
---
## 3. GwCluster → YARP ClusterConfig 映射
```csharp
public static ClusterConfig ToClusterConfig(this GwCluster cluster)
{
return new ClusterConfig
{
ClusterId = cluster.ClusterId,
LoadBalancingPolicy = cluster.LoadBalancingPolicy ?? "PowerOfTwoChoices",
Destinations = cluster.Destinations
.Where(d => d.Status == 1)
.ToDictionary(
d => d.DestinationId,
d => new DestinationConfig
{
Address = d.Address,
Health = d.Health,
Metadata = new Dictionary<string, string>
{
["Weight"] = d.Weight.ToString()
}
}
),
HealthCheck = cluster.HealthCheck?.Enabled == true
? new HealthCheckConfig
{
Active = new ActiveHealthCheckConfig
{
Enabled = true,
Path = cluster.HealthCheck.Path ?? "/health",
Interval = TimeSpan.FromSeconds(cluster.HealthCheck.IntervalSeconds),
Timeout = TimeSpan.FromSeconds(cluster.HealthCheck.TimeoutSeconds)
}
}
: null,
SessionAffinity = cluster.SessionAffinity?.Enabled == true
? new SessionAffinityConfig
{
Enabled = true,
Policy = cluster.SessionAffinity.Policy,
AffinityKeyName = cluster.SessionAffinity.AffinityKeyName
}
: null
};
}
```
---
## 4. GwTenantRoute → YARP RouteConfig 映射
```csharp
public static RouteConfig ToRouteConfig(this GwTenantRoute route)
{
return new RouteConfig
{
RouteId = route.Id,
Match = new RouteMatch
{
Path = route.PathPattern,
Methods = route.Methods?.Split(',').ToList(),
Hosts = route.Hosts?.Split(',').ToList(),
Headers = ParseHeaderMatch(route.Headers)
},
ClusterId = route.ClusterId,
Order = route.Priority,
Metadata = new Dictionary<string, string>
{
["TenantCode"] = route.TenantCode,
["ServiceName"] = route.ServiceName,
["IsGlobal"] = route.IsGlobal.ToString()
},
Transforms = ParseTransforms(route.Transforms)
};
}
private static IReadOnlyList<RouteHeader>? ParseHeaderMatch(string? headersJson)
{
if (string.IsNullOrEmpty(headersJson)) return null;
// 解析 JSON 格式的 Header 匹配规则
// [{"Name":"X-Custom","Values":["value1"],"Mode":"ExactHeader"}]
return JsonSerializer.Deserialize<List<RouteHeader>>(headersJson);
}
private static IReadOnlyList<IReadOnlyDictionary<string, string>>? ParseTransforms(string? transformsJson)
{
if (string.IsNullOrEmpty(transformsJson)) return null;
// 解析 JSON 格式的转换规则
return JsonSerializer.Deserialize<List<Dictionary<string, string>>>(transformsJson);
}
```
---
## 5. IClusterStore 接口设计
```csharp
public interface IClusterStore
{
// 基础查询
Task<GwCluster?> FindByIdAsync(string id, CancellationToken cancellationToken = default);
Task<GwCluster?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default);
Task<IList<GwCluster>> GetAllAsync(CancellationToken cancellationToken = default);
// 分页查询
Task<IList<GwCluster>> GetPagedAsync(
int page,
int pageSize,
string? name = null,
ClusterStatus? status = null,
CancellationToken cancellationToken = default);
Task<int> GetCountAsync(
string? name = null,
ClusterStatus? status = null,
CancellationToken cancellationToken = default);
// CRUD 操作
Task<IdentityResult> CreateAsync(GwCluster cluster, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateAsync(GwCluster cluster, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteAsync(GwCluster cluster, CancellationToken cancellationToken = default);
// Destination 管理
Task<IdentityResult> AddDestinationAsync(string clusterId, GwDestination destination, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateDestinationAsync(string clusterId, GwDestination destination, CancellationToken cancellationToken = default);
Task<IdentityResult> RemoveDestinationAsync(string clusterId, string destinationId, CancellationToken cancellationToken = default);
}
```
---
## 6. 会话亲和实现
### 中间件：设置会话键
```csharp
public class SessionAffinityMiddleware
{
private readonly RequestDelegate _next;
public SessionAffinityMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
// 优先使用 UserId
var userId = context.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
// 其次使用 TenantCode
var tenantCode = context.User?.FindFirst("TenantCode")?.Value
?? context.Request.Headers["X-Tenant-Code"].FirstOrDefault();
// 设置会话亲和键
var sessionKey = userId ?? tenantCode ?? "anonymous";
context.Items["SessionAffinityKey"] = sessionKey;
// 添加到请求头供 YARP 使用
context.Request.Headers["X-Session-Key"] = sessionKey;
await _next(context);
}
}
```
---
## 7. 依赖关系图
```
┌─────────────────────────────────────────────────────────────┐
│ Wave 1 │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ GwCluster.cs │ │ GwTenantRoute │ │
│ │ GwDestination │ │ (扩展字段) │ │
│ │ 值对象 │ │ │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
└───────────┼────────────────────┼────────────────────────────┘
│ │
▼ ▼
┌─────────────────────────────────────────────────────────────┐
│ Wave 2 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ PlatformDbContext.cs │ │
│ │ - 移除 GwTenant, GwServiceInstance DbSet │ │
│ │ - 添加 GwCluster DbSet │ │
│ │ - 配置 Owned Entities │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Wave 3 │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ IClusterStore │ │ IRouteStore │ │
│ │ ClusterStore │ │ RouteStore │ │
│ │ (替换Instance) │ │ (更新) │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Extensions.cs │ │
│ │ - 移除 IInstanceStore 注册 │ │
│ │ - 添加 IClusterStore 注册 │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
---
## 8. 风险评估
| 风险 | 影响 | 缓解措施 |
|------|------|----------|
| 删除 GwTenant 导致数据丢失 | 高 | 确认无数据后再删除，或提供迁移脚本 |
| 删除 GwServiceInstance 导致数据丢失 | 高 | 同上 |
| EF Core 迁移失败 | 中 | 手动编写 SQL 迁移脚本 |
| Owned Entity 查询性能 | 低 | EF Core 8+ 已优化 |
---
## 9. 参考资源
- [EF Core Owned Entities](https://learn.microsoft.com/ef/core/modeling/owned-entities)
- [YARP Configuration](https://microsoft.github.io/reverse-proxy/)
- [YARP GitHub](https://github.com/microsoft/reverse-proxy)
- 项目文档: `docs/yarp-configuration-model.md`
---
*研究完成日期: 2026-03-03*

103
.planning/phases/03-/03-VERIFICATION.md
View File

@ -1,103 +0,0 @@
---
phase: 03-
verified: 2026-03-03T00:00:00Z
status: passed
score: 7/7 必备项已验证
re_verification: false
gaps: []
---
# 阶段 03: 网关集群实体验证报告
**阶段目标：** 重构网关集群管理 - 用 GwCluster 聚合根替代 GwServiceInstance
**验证时间：** 2026-03-03
**状态：** 通过
**重新验证：** 否 - 初次验证
## 目标达成情况
### 可验证的事实
| # | 事实 | 状态 | 证据 |
|---|------|------|------|
| 1 | GwCluster 使用 string Id (GUID) | ✓ 已验证 | GwCluster.cs 第 8 行: `Id { get; set; } = Guid.CreateVersion7().ToString("N")` |
| 2 | GwDestination 作为 Owned Entity 内嵌 | ✓ 已验证 | GwCluster.cs 第 28 行: `List<GwDestination> Destinations` + PlatformDbContext.cs 第 114-122 行 |
| 3 | 值对象使用 Owned Entity 配置 | ✓ 已验证 | PlatformDbContext.cs 第 125-136 行: HealthCheck 和 SessionAffinity 的 OwnsOne 配置 |
| 4 | GwTenantRoute 扩展了 Methods、Hosts、Headers、Transforms | ✓ 已验证 | GwTenantRoute.cs 第 75-114 行: 新字段已添加 |
| 5 | 旧实体 GwTenant 和 GwServiceInstance 已移除 | ✓ 已验证 | grep 显示这些文件无匹配 |
| 6 | PlatformDbContext 包含 GwCluster DbSet | ✓ 已验证 | PlatformDbContext.cs 第 22 行: `public DbSet<GwCluster> GwClusters` |
| 7 | IClusterStore 替代了 IInstanceStore | ✓ 已验证 | IClusterStore.cs 存在，grep 显示无 IInstanceStore 引用 |
**得分：** 7/7 事实已验证
### 必需产物
| 产物 | 预期 | 状态 | 详情 |
|------|------|------|------|
| `GwCluster.cs` | 集群聚合根，50+ 行 | ✓ 已验证 | 79 行，所有字段完整 |
| `GwDestination.cs` | 值对象，30+ 行 | ✓ 已验证 | 37 行 |
| `GwHealthCheckConfig.cs` | 值对象，20+ 行 | ✓ 已验证 | 27 行 |
| `GwSessionAffinityConfig.cs` | 值对象，20+ 行 | ✓ 已验证 | 22 行 |
| `GwTenantRoute.cs` | 扩展的路由实体 | ✓ 已验证 | 115 行，包含 YARP 字段 |
| `IClusterStore.cs` | Store 接口，40+ 行 | ✓ 已验证 | 27 行 |
| `ClusterStore.cs` | Store 实现 | ✓ 已验证 | 153 行 |
| `PlatformDbContext.cs` | 更新的 DbContext | ✓ 已验证 | GwCluster DbSet + EF Core 配置 |
| `Extensions.cs` | DI 注册 | ✓ 已验证 | IClusterStore 已注册 |
| `GatewayExtensions.cs` | DI 注册 | ✓ 已验证 | IClusterStore 已注册 |
### 关键链接验证
| 从 | 到 | 方式 | 状态 | 详情 |
|----|----|----|------|------|
| GwCluster | GwDestination | OwnsMany | ✓ 已连接 | PlatformDbContext 第 114-122 行 |
| GwCluster | GwHealthCheckConfig | OwnsOne | ✓ 已连接 | PlatformDbContext 第 125-128 行 |
| GwCluster | GwSessionAffinityConfig | OwnsOne | ✓ 已连接 | PlatformDbContext 第 131-135 行 |
| Extensions | IClusterStore | DI 注册 | ✓ 已连接 | Extensions.cs 第 28 行 |
| GatewayExtensions | IClusterStore | DI 注册 | ✓ 已连接 | GatewayExtensions.cs 第 21 行 |
### 需求覆盖
| 需求 | 来源计划 | 描述 | 状态 | 证据 |
|------|----------|------|------|------|
| GATEWAY-RESTRUCTURE-01 | 03-gateway-cluster-entities | GwCluster 聚合根 | ✓ 已满足 | GwCluster.cs 已创建，所有字段完整 |
| GATEWAY-RESTRUCTURE-02 | 03-gateway-cluster-entities | GwCluster 值对象 | ✓ 已满足 | GwDestination、GwHealthCheckConfig、GwSessionAffinityConfig 已创建 |
| GATEWAY-RESTRUCTURE-03 | 03-gateway-route-update | 扩展的 GwTenantRoute | ✓ 已满足 | 新的 YARP 字段已添加 |
| GATEWAY-RESTRUCTURE-04 | 03-gateway-route-update | 移除废弃实体 | ✓ 已满足 | GwTenant.cs、GwServiceInstance.cs 已删除 |
| GATEWAY-RESTRUCTURE-05 | 03-gateway-infrastructure-update | PlatformDbContext 更新 | ✓ 已满足 | DbSet<GwCluster> 已添加配置 |
| GATEWAY-RESTRUCTURE-06 | 03-gateway-infrastructure-update | IClusterStore | ✓ 已满足 | IClusterStore/ClusterStore 已创建 |
| GATEWAY-RESTRUCTURE-07 | 03-gateway-di-update | DI 注册 | ✓ 已满足 | Extensions.cs 已更新 |
**注意：** .planning/ 目录中不存在 REQUIREMENTS.md 文件，但所有 PLAN 前言中的需求 ID 均已验证。
### 发现的反模式
| 文件 | 行 | 模式 | 严重性 | 影响 |
|------|----|----|--------|------|
| 无 | - | - | - | - |
### 构建验证
- ✓ Fengling.Platform.Domain: 0 错误，1 警告
- ✓ Fengling.Platform.Infrastructure: 0 错误，2 警告
### 需人工验证项
无 - 所有检查均为自动化且已验证。
### 总结
**所有必备项已验证。** 阶段目标已达成：
1. **GwCluster 聚合根** 已创建，使用 GUID 字符串 Id、内嵌 Destinations、HealthCheck 和 SessionAffinity
2. **值对象** 在 EF Core 中正确配置为 Owned Entity
3. **GwTenantRoute** 已扩展 YARP 路由字段（Methods、Hosts、Headers、LoadBalancingPolicy、AuthorizationPolicy、CorsPolicy、Transforms）
4. **废弃实体**（GwTenant、GwServiceInstance）已从领域层移除
5. **基础设施** 已更新 IClusterStore/ClusterStore，旧的 IInstanceStore/InstanceStore 已删除
6. **DI 注册** 已在 Extensions.cs 和 GatewayExtensions.cs 中更新
网关集群管理已成功重构，用 GwCluster 聚合根替代了 GwServiceInstance。
---
_验证时间: 2026-03-03_
_验证者: Claude (gsd-verifier)_

207
.planning/phases/03-/03-gateway-cluster-entities-PLAN.md
View File

@ -1,207 +0,0 @@
---
phase: 03-
plan: 01
type: execute
wave: 1
depends_on: []
files_modified:
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs
autonomous: true
requirements:
- GATEWAY-RESTRUCTURE-01
- GATEWAY-RESTRUCTURE-02
must_haves:
truths:
- "GwCluster 使用 string Id (GUID)"
- "GwDestination 作为 Owned Entity 内嵌"
- "值对象使用 Owned Entity 配置"
artifacts:
- path: "Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs"
provides: "集群聚合根"
min_lines: 50
- path: "Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs"
provides: "目标端点值对象"
min_lines: 30
- path: "Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs"
provides: "健康检查配置值对象"
min_lines: 20
- path: "Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs"
provides: "会话亲和配置值对象"
min_lines: 20
---
# 计划 01: 创建 GwCluster 聚合根和值对象
## 目标
创建新的 GwCluster 聚合根及相关值对象，替代原有的 GwServiceInstance 实体设计。
**目的:** 将服务实例管理改为集群聚合根模式，内嵌 Destinations 列表，符合 YARP ClusterConfig 结构。
**输出:** GwCluster 聚合根、GwDestination 值对象、GwHealthCheckConfig 值对象、GwSessionAffinityConfig 值对象。
## 上下文
@.planning/phases/03-/03-CONTEXT.md
@.planning/phases/03-/03-RESEARCH.md
@Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs (现有实体参考)
@Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GatewayEnums.cs (枚举)
## 任务
<task type="auto">
<name>任务 1: 创建 GwHealthCheckConfig 值对象</name>
<files>Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs</files>
<action>
创建健康检查配置值对象：
```csharp
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 健康检查配置（值对象）
/// </summary>
public class GwHealthCheckConfig
{
/// <summary>
/// 是否启用健康检查
/// </summary>
public bool Enabled { get; set; }
/// <summary>
/// 健康检查路径
/// </summary>
public string? Path { get; set; }
/// <summary>
/// 检查间隔（秒）
/// </summary>
public int IntervalSeconds { get; set; } = 30;
/// <summary>
/// 超时时间（秒）
/// </summary>
public int TimeoutSeconds { get; set; } = 10;
}
```
</action>
<verify>文件可编译</verify>
<done>GwHealthCheckConfig 值对象已创建</done>
</task>
<task type="auto">
<name>任务 2: 创建 GwSessionAffinityConfig 值对象</name>
<files>Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs</files>
<action>
创建会话亲和配置值对象：
```csharp
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 会话亲和配置（值对象）
/// </summary>
public class GwSessionAffinityConfig
{
/// <summary>
/// 是否启用会话亲和
/// </summary>
public bool Enabled { get; set; }
/// <summary>
/// 策略：Header, Cookie
/// </summary>
public string Policy { get; set; } = "Header";
/// <summary>
/// 亲和键名称
/// </summary>
public string AffinityKeyName { get; set; } = "X-Session-Key";
}
```
</action>
<verify>文件可编译</verify>
<done>GwSessionAffinityConfig 值对象已创建</done>
</task>
<task type="auto">
<name>任务 3: 创建 GwDestination 值对象</name>
<files>Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs</files>
<action>
创建目标端点值对象：
```csharp
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 目标端点（值对象，内嵌于 GwCluster）
/// </summary>
public class GwDestination
{
/// <summary>
/// 目标标识
/// </summary>
public string DestinationId { get; set; } = string.Empty;
/// <summary>
/// 后端地址
/// </summary>
public string Address { get; set; } = string.Empty;
/// <summary>
/// 健康检查端点
/// </summary>
public string? Health { get; set; }
/// <summary>
/// 权重（用于加权负载均衡）
/// </summary>
public int Weight { get; set; } = 1;
/// <summary>
/// 健康状态
/// </summary>
public int HealthStatus { get; set; } = 1;
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
}
```
</action>
<verify>文件可编译</verify>
<done>GwDestination 值对象已创建</done>
</task>
<task type="auto">
<name>任务 4: 创建 GwCluster 聚合根</name>
<files>Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs</files>
<action>
创建 GwCluster 聚合根：
- Id: string (GUID)
- ClusterId: string (业务标识)
- Name: string
- Description: string?
- Destinations: List&lt;GwDestination&gt; (内嵌)
- LoadBalancingPolicy: string
- HealthCheck: GwHealthCheckConfig?
- SessionAffinity: GwSessionAffinityConfig?
- Status: int
- 审计字段
参考现有 GwTenantRoute 的结构风格。
</action>
<verify>dotnet build Fengling.Platform.Domain 通过</verify>
<done>GwCluster 聚合根已创建，包含所有字段</done>
</task>
## 验证
- [ ] 所有 4 个文件已创建
- [ ] Build 无错误通过
- [ ] 值对象结构符合 YARP 配置模型
## 成功标准
Domain 实体准备好进行 Infrastructure 层更新。

70
.planning/phases/03-/03-gateway-cluster-entities-SUMMARY.md
View File

@ -1,70 +0,0 @@
---
phase: "03-"
plan: 01
subsystem: Gateway
tags: [gateway, cluster, domain-entities, yarp]
dependency_graph:
requires: []
provides: [GwCluster, GwDestination, GwHealthCheckConfig, GwSessionAffinityConfig]
affects: [GwTenantRoute]
tech_stack:
added:
- GwCluster (集群聚合根)
- GwDestination (目标端点值对象)
- GwHealthCheckConfig (健康检查配置值对象)
- GwSessionAffinityConfig (会话亲和配置值对象)
patterns:
- 值对象使用 Owned Entity
- GUID 字符串 ID
- 软删除 + 乐观并发
key_files:
created:
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs
decisions:
- "GwCluster 使用 string Id (GUID) 以兼容 YARP"
- "GwDestination 作为 Owned Entity 内嵌于 GwCluster"
- "值对象在 EF Core 中配置为 Owned Entity"
metrics:
duration: ""
completed_date: "2026-03-03"
---
# 阶段 03 - 计划 01: 网关集群实体总结
## 一句话概述
创建了 GwCluster 聚合根及其内嵌值对象（GwDestination、GwHealthCheckConfig、GwSessionAffinityConfig），替代旧的 GwServiceInstance 设计，与 YARP ClusterConfig 结构对齐。
## 已完成任务
| 任务 | 名称 | 提交 | 文件 |
|------|------|------|------|
| 1 | 创建 GwHealthCheckConfig 值对象 | 198dc2a | GwHealthCheckConfig.cs |
| 2 | 创建 GwSessionAffinityConfig 值对象 | b07f56c | GwSessionAffinityConfig.cs |
| 3 | 创建 GwDestination 值对象 | 7ec34fa | GwDestination.cs |
| 4 | 创建 GwCluster 聚合根 | 774e3fb | GwCluster.cs |
## 验证结果
- [x] 全部 4 个文件已创建
- [x] 构建通过，0 个错误
- [x] 值对象结构与 YARP 配置模型匹配
## 计划偏差
无 - 完全按计划执行。
## 认证门槛
无。
## 备注
新的 GwCluster 聚合遵循现有的 GatewayAggregate 代码风格：
- GUID 字符串 ID 以兼容 YARP
- 软删除（IsDeleted）和乐观并发（Version）字段
- 内嵌 Destinations 列表和配置值对象
- 标准审计字段（CreatedBy、CreatedTime、UpdatedBy、UpdatedTime）

74
.planning/phases/03-/03-gateway-di-update-PLAN.md
View File

@ -1,74 +0,0 @@
---
phase: 03-
plan: 04
type: execute
wave: 3
depends_on:
- 03-gateway-infrastructure-update
files_modified:
- Fengling.Platform.Infrastructure/Extensions.cs
- Fengling.Platform.Infrastructure/GatewayExtensions.cs
autonomous: true
requirements:
- GATEWAY-RESTRUCTURE-07
must_haves:
truths:
- "Extensions.cs 注册 IClusterStore 而非 IInstanceStore"
- "GatewayExtensions 可独立使用"
---
# 计划 04: 更新 Extensions 和 DI 注册
## 目标
更新 Extensions.cs 以注册新的 IClusterStore，清理旧的 IInstanceStore 注册。
**目的:** 完成 DI 容器配置的更新，使新服务可被注入使用。
**输出:** 更新的 Extensions.cs。
## 上下文
@Fengling.Platform.Infrastructure/Extensions.cs
@Fengling.Platform.Infrastructure/GatewayExtensions.cs
## 任务
<task type="auto">
<name>任务 1: 更新 Extensions.cs</name>
<files>Fengling.Platform.Infrastructure/Extensions.cs</files>
<action>
在 AddPlatformCore 方法中：
1. 移除旧注册：
- 移除 services.AddScoped&lt;IInstanceStore, InstanceStore&lt;TContext&gt;&gt;()
- 移除 services.AddScoped&lt;IRouteManager, RouteManager&gt;()（如果之前在 Gateway 部分）
2. 添加新注册：
- 添加 services.AddScoped&lt;IClusterStore, ClusterStore&lt;TContext&gt;&gt;()
注意：保持与现有 GatewayExtensions 的兼容性。
</action>
<verify>dotnet build 通过</verify>
<done>Extensions.cs 已更新</done>
</task>
<task type="auto">
<name>任务 2: 更新 GatewayExtensions.cs（如需要）</name>
<files>Fengling.Platform.Infrastructure/GatewayExtensions.cs</files>
<action>
检查 GatewayExtensions.cs：
- 如果已注册 IClusterStore，确保与 Extensions.cs 一致
- 如果需要，添加注释说明两种注册方式
</action>
<verify>dotnet build 通过</verify>
<done>GatewayExtensions 检查完成</done>
</task>
## 验证
- [ ] Extensions.cs 已更新
- [ ] Build 无错误通过
## 成功标准
Gateway 模块重构完成，所有服务正确注册。

73
.planning/phases/03-/03-gateway-di-update-SUMMARY.md
View File

@ -1,73 +0,0 @@
---
phase: "03-"
plan: 04
subsystem: Gateway
tags: [gateway, di, registration, extensions]
dependency_graph:
requires: [IClusterStore (来自计划 03)]
provides: [更新的 DI 注册]
affects: [Extensions, GatewayExtensions]
tech_stack:
added: []
patterns:
- ASP.NET Core DI 注册
- 泛型 DbContext 约束
key_files:
created: []
modified:
- Fengling.Platform.Infrastructure/Extensions.cs
- Fengling.Platform.Infrastructure/GatewayExtensions.cs
deleted: []
decisions:
- "IClusterStore 注册为 Scoped 服务"
- "AddPlatformCore 和 AddGatewayCore 均注册 IClusterStore"
metrics:
duration: "包含在计划 03 中"
completed_date: "2026-03-03"
requirements_completed: [GATEWAY-RESTRUCTURE-07]
---
# 阶段 03 - 计划 04: 网关 DI 更新总结
## 一句话概述
更新 Extensions.cs 和 GatewayExtensions.cs 中的 DI 注册，将 IClusterStore/ClusterStore 替代已废弃的 IInstanceStore。
## 已完成任务
| 任务 | 名称 | 状态 | 提交 |
|------|------|------|------|
| 1 | 更新 Extensions.cs | ✅ 完成 | a655813 |
| 2 | 更新 GatewayExtensions.cs | ✅ 完成 | a655813 |
**注意：** 任务作为计划 03 的偏差修复的一部分完成（规则 2 - 自动添加缺失功能）。
## 验证结果
- [x] Extensions.cs 在 AddPlatformCore 中注册 IClusterStore
- [x] GatewayExtensions.cs 在 AddGatewayCore 中注册 IClusterStore
- [x] IInstanceStore 引用已移除
- [x] 构建通过，0 个错误
## 计划偏差
**作为计划 03 偏差修复的一部分完成：**
- Wave 2 代理在基础设施更新期间主动更新了 DI 注册文件
- 这是修复因删除 IInstanceStore 引用导致的构建错误所必需的
- 无需额外提交 - 变更已包含在计划 03 的提交 `a655813` 中
## 认证门槛
无。
## 备注
DI 注册更新在逻辑上是基础设施更新的一部分，因为：
1. IClusterStore/ClusterStore 在计划 03 中创建
2. Extensions 必须立即引用新的 Store 才能编译
3. 拆分提交会产生一个损坏的中间状态
---
*阶段: 03-*
*完成时间: 2026-03-03*

128
.planning/phases/03-/03-gateway-infrastructure-update-PLAN.md
View File

@ -1,128 +0,0 @@
---
phase: 03-
plan: 03
type: execute
wave: 2
depends_on:
- 03-gateway-cluster-entities
- 03-gateway-route-update
files_modified:
- Fengling.Platform.Infrastructure/PlatformDbContext.cs
- Fengling.Platform.Infrastructure/IInstanceStore.cs
- Fengling.Platform.Infrastructure/InstanceStore.cs
- Fengling.Platform.Infrastructure/IClusterStore.cs
- Fengling.Platform.Infrastructure/ClusterStore.cs
autonomous: true
requirements:
- GATEWAY-RESTRUCTURE-05
- GATEWAY-RESTRUCTURE-06
must_haves:
truths:
- "PlatformDbContext 包含GwCluster DbSet"
- "IClusterStore 替代 IInstanceStore"
artifacts:
- path: "Fengling.Platform.Infrastructure/PlatformDbContext.cs"
provides: "更新的 DbContext"
- path: "Fengling.Platform.Infrastructure/IClusterStore.cs"
provides: "集群存储接口"
min_lines: 40
---
# 计划 03: 更新 Infrastructure 层
## 目标
更新 PlatformDbContext 配置，创建 IClusterStore 接口和实现，替换原有的 IInstanceStore。
**目的:** 支持新的 GwCluster 聚合根，移除已废弃的实体 DbSet。
**输出:** 更新的 PlatformDbContext、IClusterStore/ClusterStore。
## 上下文
@Fengling.Platform.Infrastructure/PlatformDbContext.cs
@Fengling.Platform.Infrastructure/IInstanceStore.cs
@Fengling.Platform.Infrastructure/RouteStore.cs (参考模式)
## 任务
<task type="auto">
<name>任务 1: 更新 PlatformDbContext</name>
<files>Fengling.Platform.Infrastructure/PlatformDbContext.cs</files>
<action>
1. 移除 DbSet：
- 移除 DbSet&lt;GwTenant&gt; GwTenants
- 移除 DbSet&lt;GwServiceInstance&gt; GwServiceInstances
2. 添加 DbSet：
- 添加 DbSet&lt;GwCluster&gt; GwClusters
3. 在 OnModelCreating 中配置：
- GwCluster 聚合根配置
- OwnsMany GwDestinations 配置
- OwnsOne GwHealthCheckConfig 配置
- OwnsOne GwSessionAffinityConfig 配置
参考 03-RESEARCH.md 中的 EF Core 配置代码。
</action>
<verify>dotnet build 通过</verify>
<done>PlatformDbContext 已更新</done>
</task>
<task type="auto">
<name>任务 2: 创建 IClusterStore 接口</name>
<files>Fengling.Platform.Infrastructure/IClusterStore.cs</files>
<action>
创建 IClusterStore 接口，包含：
- FindByIdAsync, FindByClusterIdAsync
- GetAllAsync, GetPagedAsync, GetCountAsync
- CreateAsync, UpdateAsync, DeleteAsync
- AddDestinationAsync, UpdateDestinationAsync, RemoveDestinationAsync
参考 IRouteStore 模式。
</action>
<verify>文件可编译</verify>
<done>IClusterStore 接口已创建</done>
</task>
<task type="auto">
<name>任务 3: 创建 ClusterStore 实现</name>
<files>Fengling.Platform.Infrastructure/ClusterStore.cs</files>
<action>
创建 ClusterStore&lt;TContext&gt; 实现 IClusterStore：
- 泛型约束: where TContext : PlatformDbContext
- 实现所有接口方法
- 支持软删除
- 支持内嵌 Destination 的 CRUD
参考 RouteStore 模式。
</action>
<verify>dotnet build 通过</verify>
<done>ClusterStore 实现已创建</done>
</task>
<task type="auto">
<name>任务 4: 删除 IInstanceStore 和 InstanceStore</name>
<files>
Fengling.Platform.Infrastructure/IInstanceStore.cs
Fengling.Platform.Infrastructure/InstanceStore.cs
</files>
<action>
删除这两个文件：
- 已被 IClusterStore/ClusterStore 替代
- 确认无其他引用
</action>
<verify>dotnet build 通过</verify>
<done>旧文件已删除</done>
</task>
## 验证
- [ ] PlatformDbContext 已更新
- [ ] IClusterStore/ClusterStore 已创建
- [ ] 旧文件已删除
- [ ] Build 无错误通过
## 成功标准
Infrastructure 层更新完成，准备更新 DI 注册。

86
.planning/phases/03-/03-gateway-infrastructure-update-SUMMARY.md
View File

@ -1,86 +0,0 @@
---
phase: "03-"
plan: 03
subsystem: Gateway
tags: [gateway, infrastructure, cluster, store, efcore]
dependency_graph:
requires: [GwCluster (来自计划 01)]
provides: [IClusterStore, ClusterStore, PlatformDbContext 更新]
affects: [Extensions, GatewayExtensions]
tech_stack:
added:
- IClusterStore 接口
- ClusterStore<TContext> 实现
patterns:
- Manager + Store 模式（ASP.NET Core Identity 风格）
- 泛型 DbContext 约束
- 软删除
- 内嵌集合使用 Owned Entity
key_files:
created:
- Fengling.Platform.Infrastructure/IClusterStore.cs
- Fengling.Platform.Infrastructure/ClusterStore.cs
modified:
- Fengling.Platform.Infrastructure/PlatformDbContext.cs
- Fengling.Platform.Infrastructure/Extensions.cs
- Fengling.Platform.Infrastructure/GatewayExtensions.cs
deleted:
- Fengling.Platform.Infrastructure/IInstanceStore.cs
- Fengling.Platform.Infrastructure/InstanceStore.cs
decisions:
- "IClusterStore 遵循 IRouteStore 模式以保持一致性"
- "ClusterStore 对 GwCluster 实体使用软删除"
- "OwnsMany 用于 EF Core 中内嵌的 Destinations 集合"
metrics:
duration: ""
completed_date: "2026-03-03"
---
# 阶段 03 - 计划 03: 网关基础设施更新总结
## 一句话概述
更新 PlatformDbContext 以包含 GwCluster DbSet 和 EF Core 配置，创建 IClusterStore/ClusterStore 以替代已废弃的 IInstanceStore/InstanceStore。
## 已完成任务
| 任务 | 名称 | 提交 | 文件 |
|------|------|------|------|
| 1 | 更新 PlatformDbContext | a655813 | PlatformDbContext.cs |
| 2 | 创建 IClusterStore 接口 | a655813 | IClusterStore.cs |
| 3 | 创建 ClusterStore 实现 | a655813 | ClusterStore.cs |
| 4 | 删除 IInstanceStore 和 InstanceStore | a655813 | IInstanceStore.cs, InstanceStore.cs (已删除) |
## 验证结果
- [x] PlatformDbContext 已更新 - 移除 GwTenant/GwServiceInstance DbSets，添加 GwCluster 及 EF Core 配置
- [x] IClusterStore 接口已创建，包含所有 CRUD + Destination 管理方法
- [x] ClusterStore<TContext> 实现已创建，支持软删除
- [x] 旧的 IInstanceStore/InstanceStore 已删除（被 IClusterStore 替代）
- [x] 构建通过，0 个错误
## 计划偏差
**1. [规则 2 - 自动添加缺失功能] 修复 DI 注册引用**
- **发现时机：** 构建验证
- **问题：** Extensions.cs 和 GatewayExtensions.cs 仍引用已删除的 IInstanceStore
- **修复：** 更新两个文件以注册 IClusterStore/ClusterStore
- **修改文件：** Extensions.cs、GatewayExtensions.cs
**2. [规则 1 - 自动修复 Bug] 修复 EF Core OwnsMany 配置**
- **发现时机：** 构建验证
- **问题：** PlatformDbContext 中 OwnsMany 构建器使用不正确
- **修复：** 更正配置以使用正确的 OwnedMany 模式，包含外键的影子属性
- **修改文件：** PlatformDbContext.cs
## 认证门槛
无。
## 备注
基础设施层现已准备好进入下一阶段：
- GwCluster 聚合已在 DbContext 中正确配置
- IClusterStore 遵循已建立的 Manager + Store 模式
- 所有已废弃的 IInstanceStore 引用已被移除
- DI 注册已在 Extensions.cs 和 GatewayExtensions.cs 中更新

105
.planning/phases/03-/03-gateway-route-update-PLAN.md
View File

@ -1,105 +0,0 @@
---
phase: 03-
plan: 02
type: execute
wave: 1
depends_on:
- 03-gateway-cluster-entities
files_modified:
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenant.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwServiceInstance.cs
autonomous: true
requirements:
- GATEWAY-RESTRUCTURE-03
- GATEWAY-RESTRUCTURE-04
must_haves:
truths:
- "GwTenantRoute 扩展了 Methods, Hosts, Headers, Transforms 等字段"
- "旧实体 GwTenant 和 GwServiceInstance 标记为删除或移除"
artifacts:
- path: "Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs"
provides: "扩展的路由实体"
min_lines: 50
---
# 计划 02: 扩展 GwTenantRoute 并删除旧实体
## 目标
扩展 GwTenantRoute 实体以支持完整的路由匹配能力和转换规则，并删除已废弃的 GwTenant 和 GwServiceInstance 实体。
**目的:** 添加 YARP 所需的路由匹配字段，同时清理不再需要的实体。
**输出:** 更新的 GwTenantRoute.cs，删除的 GwTenant.cs 和 GwServiceInstance.cs。
## 上下文
@.planning/phases/03-/03-CONTEXT.md
@Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs (现有)
## 任务
<task type="auto">
<name>任务 1: 扩展 GwTenantRoute 字段</name>
<files>Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs</files>
<action>
在 GwTenantRoute 中添加以下新字段：
1. 路由匹配能力：
- Methods?: string (HTTP 方法，如 "GET,POST")
- Hosts?: string (Host 头匹配，如 "api.example.com")
- Headers?: string (Header 匹配规则，JSON 格式)
2. 策略配置：
- LoadBalancingPolicy?: string (路由级别负载均衡策略覆盖)
- AuthorizationPolicy?: string (授权策略)
- CorsPolicy?: string (CORS 策略)
3. 请求转换：
- Transforms?: string (请求/响应转换规则，JSON 格式)
保留现有字段：Id, TenantCode, ServiceName, ClusterId, PathPattern, Priority, Status, IsGlobal
</action>
<verify>dotnet build 通过</verify>
<done>GwTenantRoute 已扩展新字段</done>
</task>
<task type="auto">
<name>任务 2: 删除 GwTenant 实体</name>
<files>
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenant.cs
</files>
<action>
删除 GwTenant.cs 文件：
- 原因：使用 Platform.Tenant 通过 TenantCode 关联
- 确认无其他依赖引用此实体
</action>
<verify>dotnet build 通过</verify>
<done>GwTenant 实体已删除</done>
</task>
<task type="auto">
<name>任务 3: 删除 GwServiceInstance 实体</name>
<files>
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwServiceInstance.cs
</files>
<action>
删除 GwServiceInstance.cs 文件：
- 原因：改用 GwCluster 聚合根内嵌 Destination
- 确认无其他依赖引用此实体
</action>
<verify>dotnet build 通过</verify>
<done>GwServiceInstance 实体已删除</done>
</task>
## 验证
- [ ] GwTenantRoute 扩展字段已添加
- [ ] GwTenant.cs 已删除
- [ ] GwServiceInstance.cs 已删除
- [ ] Build 无错误通过
## 成功标准
Domain 层实体重构完成，准备进行 Infrastructure 层更新。

81
.planning/phases/03-/03-gateway-route-update-SUMMARY.md
View File

@ -1,81 +0,0 @@
---
phase: "03-"
plan: 02
subsystem: Gateway
tags: [gateway, domain, yarp]
dependency_graph:
requires:
- 03-gateway-cluster-entities
provides:
- 扩展的 GwTenantRoute 实体
affects:
- PlatformDbContext (需要更新以移除已删除实体的 DbSet)
tech_stack:
added:
- GwTenantRoute 新字段（Methods、Hosts、Headers、LoadBalancingPolicy、AuthorizationPolicy、CorsPolicy、Transforms）
patterns:
- 领域驱动设计实体扩展
key_files:
created: []
modified:
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs
deleted:
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenant.cs
- Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwServiceInstance.cs
decisions:
- "GwTenant 已移除 - 改用 Platform.Tenant 通过 TenantCode 关联"
- "GwServiceInstance 已移除 - 改用 GwCluster 内嵌的 Destination 集合"
- "扩展字段使用可空字符串类型，以支持可选的 YARP 配置"
metrics:
duration: ~5 分钟
completed_date: "2026-03-03"
---
# 阶段 03 计划 02: 网关路由更新总结
## 一句话概述
扩展 GwTenantRoute 以支持 YARP 路由匹配字段，并移除已废弃的 GwTenant/GwServiceInstance 实体。
## 已完成任务
| 任务 | 名称 | 提交 | 文件 |
|------|------|------|------|
| 1 | 扩展 GwTenantRoute 字段 | 3fbd9d0 | GwTenantRoute.cs |
| 2 | 删除 GwTenant 实体 | 3fbd9d0 | GwTenant.cs |
| 3 | 删除 GwServiceInstance 实体 | 3fbd9d0 | GwServiceInstance.cs |
## 总结
成功完成网关路由实体的领域层重构：
- **扩展 GwTenantRoute** 新增字段以支持完整的 YARP 路由能力：
- `Methods`、`Hosts`、`Headers` - 路由匹配
- `LoadBalancingPolicy`、`AuthorizationPolicy`、`CorsPolicy` - 策略配置
- `Transforms` - 请求/响应转换
- **移除已废弃实体**：
- `GwTenant` - 应使用 Platform.Tenant 聚合并通过 TenantCode 关联
- `GwServiceInstance` - 应使用 GwCluster 内嵌的 Destination 集合
## 验证结果
- 领域层构建：**通过**（0 错误，2 警告）
- 基础设施层：**需要更新** - 对已删除实体的引用需在后续计划中清理
## 计划偏差
### 基础设施层引用
**发现时机：** 构建验证
**问题：** 基础设施层（PlatformDbContext、InstanceStore、IInstanceStore）仍引用已删除的 GwTenant 和 GwServiceInstance 实体
**影响：** 基础设施层构建失败，直到更新完成
**决策：** 推迟到后续计划 - 领域层变更已按计划范围完成
**受影响文件：** PlatformDbContext.cs、IInstanceStore.cs、InstanceStore.cs
## 备注
- 已删除的实体是初始网关实现的一部分，现已被以下替代：
- Platform.Tenant 聚合用于租户信息
- GwCluster 聚合的内嵌 Destination 集合用于服务实例
- 基础设施层清理应在下一个涵盖基础设施更新的计划中处理

3
Directory.Packages.props
View File

@ -6,10 +6,13 @@
<ItemGroup>
<PackageVersion Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="10.0.0" />
<PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.0" />
<PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.0" />
<PackageVersion Include="NetCorePal.Extensions.Repository.EntityFrameworkCore.Snowflake" Version="3.2.1" />
<PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.0" />
<PackageVersion Include="NetCorePal.Extensions.Repository.EntityFrameworkCore" Version="$(NetCorePalVersion)" />
<PackageVersion Include="NetCorePal.Extensions.Domain.Abstractions" Version="$(NetCorePalVersion)" />
<PackageVersion Include="NetCorePal.Extensions.Primitives" Version="$(NetCorePalVersion)" />
<PackageVersion Include="MediatR" Version="12.5.0" />
<PackageVersion Include="OpenIddict.EntityFrameworkCore" Version="7.2.0" />
</ItemGroup>
</Project>

44
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwDestination.cs
View File

@ -1,44 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 目标端点（值对象，内嵌于 GwCluster）
/// </summary>
public class GwDestination
{
/// <summary>
/// 目标标识
/// </summary>
public string DestinationId { get; set; } = string.Empty;
/// <summary>
/// 后端地址
/// </summary>
public string Address { get; set; } = string.Empty;
/// <summary>
/// 健康检查端点
/// </summary>
public string? Health { get; set; }
/// <summary>
/// 权重（用于加权负载均衡）
/// </summary>
public int Weight { get; set; } = 1;
/// <summary>
/// 健康状态
/// </summary>
public int HealthStatus { get; set; } = 1;
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
/// <summary>
/// 租户代码，用于区分租户专属目标
/// null 或空字符串表示默认目标（所有租户共享）
/// 有值表示该目标专属于指定租户
/// </summary>
public string? TenantCode { get; set; }
}

27
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwHealthCheckConfig.cs
View File

@ -1,27 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 健康检查配置（值对象）
/// </summary>
public class GwHealthCheckConfig
{
/// <summary>
/// 是否启用健康检查
/// </summary>
public bool Enabled { get; set; }
/// <summary>
/// 健康检查路径
/// </summary>
public string? Path { get; set; }
/// <summary>
/// 检查间隔（秒）
/// </summary>
public int IntervalSeconds { get; set; } = 30;
/// <summary>
/// 超时时间（秒）
/// </summary>
public int TimeoutSeconds { get; set; } = 10;
}

14
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwLoadBalancingPolicy.cs
View File

@ -1,14 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 负载均衡策略
/// </summary>
public enum GwLoadBalancingPolicy
{
RoundRobin = 0,
Random = 1,
PowerOfTwoChoices = 2,
LeastRequests = 3,
First = 4,
WeightedRoundRobin = 5
}

96
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwRoute.cs
View File

@ -1,96 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 网关路由实体 - 表示全局路由规则配置
/// </summary>
public class GwRoute
{
public string Id { get; set; } = Guid.CreateVersion7().ToString("N");
/// <summary>
/// 服务名称
/// </summary>
public string ServiceName { get; set; } = string.Empty;
/// <summary>
/// 集群ID
/// </summary>
public string ClusterId { get; set; } = string.Empty;
/// <summary>
/// 路由匹配配置（JSON 列存储）
/// </summary>
public GwRouteMatch Match { get; set; } = new();
/// <summary>
/// 优先级（对应 YARP Order，数值越小优先级越高）
/// </summary>
public int Priority { get; set; } = 0;
/// <summary>
/// 路由级别负载均衡策略覆盖（可选，默认使用集群策略）
/// </summary>
public GwLoadBalancingPolicy? LoadBalancingPolicy { get; set; }
/// <summary>
/// 授权策略名称
/// </summary>
public string? AuthorizationPolicy { get; set; }
/// <summary>
/// CORS 策略名称
/// </summary>
public string? CorsPolicy { get; set; }
/// <summary>
/// 限流策略名称
/// </summary>
public string? RateLimiterPolicy { get; set; }
/// <summary>
/// 请求/响应转换规则（JSON 列存储）
/// </summary>
public List<GwTransform>? Transforms { get; set; }
/// <summary>
/// 请求超时时间（秒）
/// </summary>
public int? TimeoutSeconds { get; set; }
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
/// <summary>
/// 创建人ID
/// </summary>
public long? CreatedBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; } = DateTime.UtcNow;
/// <summary>
/// 更新人ID
/// </summary>
public long? UpdatedBy { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime? UpdatedTime { get; set; }
/// <summary>
/// 是否删除
/// </summary>
public bool IsDeleted { get; set; } = false;
/// <summary>
/// 版本号，用于乐观并发
/// </summary>
public int Version { get; set; } = 0;
}

116
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwRouteMatch.cs
View File

@ -1,116 +0,0 @@
using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text.Json.Serialization;
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 路由匹配配置（值对象）
/// 对应 YARP 的 RouteMatch，以 JSON 存储在数据库中
/// </summary>
public class GwRouteMatch
{
/// <summary>
/// 路径匹配模式
/// </summary>
public string Path { get; set; } = string.Empty;
/// <summary>
/// HTTP 方法列表（如 ["GET", "POST"]）
/// </summary>
public List<string>? Methods { get; set; }
/// <summary>
/// Host 匹配列表（如 ["api.example.com", "*.example.com"]）
/// </summary>
public List<string>? Hosts { get; set; }
/// <summary>
/// Header 匹配规则
/// </summary>
[NotMapped]
[JsonInclude]
public List<GwRouteHeader>? Headers { get; set; }
/// <summary>
/// 查询参数匹配规则
/// </summary>
[NotMapped]
[JsonInclude]
public List<GwRouteQueryParameter>? QueryParameters { get; set; }
}
/// <summary>
/// Header 匹配规则（值对象）
/// </summary>
public class GwRouteHeader
{
/// <summary>
/// Header 名称
/// </summary>
public string Name { get; set; } = string.Empty;
/// <summary>
/// 匹配值列表
/// </summary>
public List<string> Values { get; set; } = [];
/// <summary>
/// 匹配模式
/// </summary>
public GwHeaderMatchMode Mode { get; set; } = GwHeaderMatchMode.ExactHeader;
/// <summary>
/// 是否区分大小写
/// </summary>
public bool IsCaseSensitive { get; set; } = false;
}
/// <summary>
/// 查询参数匹配规则（值对象）
/// </summary>
public class GwRouteQueryParameter
{
/// <summary>
/// 参数名称
/// </summary>
public string Name { get; set; } = string.Empty;
/// <summary>
/// 匹配值列表
/// </summary>
public List<string> Values { get; set; } = [];
/// <summary>
/// 匹配模式
/// </summary>
public GwQueryParameterMatchMode Mode { get; set; } = GwQueryParameterMatchMode.Exact;
/// <summary>
/// 是否区分大小写
/// </summary>
public bool IsCaseSensitive { get; set; } = false;
}
/// <summary>
/// Header 匹配模式
/// </summary>
public enum GwHeaderMatchMode
{
ExactHeader = 0,
Prefix = 1,
Contains = 2,
NotContains = 3,
Exists = 4
}
/// <summary>
/// 查询参数匹配模式
/// </summary>
public enum GwQueryParameterMatchMode
{
Exact = 0,
Contains = 1,
Prefix = 2,
Exists = 3
}

69
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwServiceInstance.cs Normal file
View File

@ -0,0 +1,69 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 网关服务实例实体 - 表示负载均衡的服务实例
/// </summary>
public class GwServiceInstance
{
public long Id { get; set; }
/// <summary>
/// 集群ID
/// </summary>
public string ClusterId { get; set; } = string.Empty;
/// <summary>
/// 目标ID
/// </summary>
public string DestinationId { get; set; } = string.Empty;
/// <summary>
/// 地址
/// </summary>
public string Address { get; set; } = string.Empty;
/// <summary>
/// 健康状态
/// </summary>
public int Health { get; set; } = 1;
/// <summary>
/// 权重
/// </summary>
public int Weight { get; set; } = 1;
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
/// <summary>
/// 创建人ID
/// </summary>
public long? CreatedBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; } = DateTime.UtcNow;
/// <summary>
/// 更新人ID
/// </summary>
public long? UpdatedBy { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime? UpdatedTime { get; set; }
/// <summary>
/// 是否删除
/// </summary>
public bool IsDeleted { get; set; } = false;
/// <summary>
/// 版本号，用于乐观并发
/// </summary>
public int Version { get; set; } = 0;
}

22
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwSessionAffinityConfig.cs
View File

@ -1,22 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 会话亲和配置（值对象）
/// </summary>
public class GwSessionAffinityConfig
{
/// <summary>
/// 是否启用会话亲和
/// </summary>
public bool Enabled { get; set; }
/// <summary>
/// 策略：Header, Cookie
/// </summary>
public string Policy { get; set; } = "Header";
/// <summary>
/// 亲和键名称
/// </summary>
public string AffinityKeyName { get; set; } = "X-Session-Key";
}

54
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenant.cs Normal file
View File

@ -0,0 +1,54 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 网关租户实体 - 表示租户在网关中的配置
/// </summary>
public class GwTenant
{
public long Id { get; set; }
/// <summary>
/// 租户代码
/// </summary>
public string TenantCode { get; set; } = string.Empty;
/// <summary>
/// 租户名称
/// </summary>
public string TenantName { get; set; } = string.Empty;
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
/// <summary>
/// 创建人ID
/// </summary>
public long? CreatedBy { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreatedTime { get; set; } = DateTime.UtcNow;
/// <summary>
/// 更新人ID
/// </summary>
public long? UpdatedBy { get; set; }
/// <summary>
/// 更新时间
/// </summary>
public DateTime? UpdatedTime { get; set; }
/// <summary>
/// 是否删除
/// </summary>
public bool IsDeleted { get; set; } = false;
/// <summary>
/// 版本号，用于乐观并发
/// </summary>
public int Version { get; set; } = 0;
}

51
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwCluster.cs → Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTenantRoute.cs
View File

@ -1,52 +1,47 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 网关集群聚合根 - 表示后端服务集群配置
/// 网关租户路由实体 - 表示路由规则配置
/// </summary>
public class GwCluster
public class GwTenantRoute
{
public string Id { get; set; } = Guid.CreateVersion7().ToString("N");
public long Id { get; set; }
/// <summary>
/// 集群业务标识
/// 租户代码
/// </summary>
public string TenantCode { get; set; } = string.Empty;
/// <summary>
/// 服务名称
/// </summary>
public string ServiceName { get; set; } = string.Empty;
/// <summary>
/// 集群ID
/// </summary>
public string ClusterId { get; set; } = string.Empty;
/// <summary>
/// 集群名称
/// 路径匹配模式
/// </summary>
public string Name { get; set; } = string.Empty;
public string PathPattern { get; set; } = string.Empty;
/// <summary>
/// 描述
/// 优先级
/// </summary>
public string? Description { get; set; }
/// <summary>
/// 目标端点列表（内嵌）
/// </summary>
public List<GwDestination> Destinations { get; set; } = [];
/// <summary>
/// 负载均衡策略
/// </summary>
public GwLoadBalancingPolicy LoadBalancingPolicy { get; set; } = GwLoadBalancingPolicy.RoundRobin;
/// <summary>
/// 健康检查配置（JSON 列存储）
/// </summary>
public GwHealthCheckConfig? HealthCheck { get; set; }
/// <summary>
/// 会话亲和配置（JSON 列存储）
/// </summary>
public GwSessionAffinityConfig? SessionAffinity { get; set; }
public int Priority { get; set; } = 0;
/// <summary>
/// 状态
/// </summary>
public int Status { get; set; } = 1;
/// <summary>
/// 是否全局路由
/// </summary>
public bool IsGlobal { get; set; } = false;
/// <summary>
/// 创建人ID
/// </summary>

77
Fengling.Platform.Domain/AggregatesModel/GatewayAggregate/GwTransform.cs
View File

@ -1,77 +0,0 @@
namespace Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
/// <summary>
/// 请求/响应转换规则（值对象）
/// 以 JSON 列存储在数据库中
/// </summary>
public class GwTransform
{
/// <summary>
/// 转换规则键值对
/// 例如: {"RequestHeader": "X-Custom-Header", "Set": "value"}
/// </summary>
public Dictionary<string, string> Rules { get; set; } = new();
}
/// <summary>
/// 常用转换规则工厂
/// </summary>
public static class GwTransforms
{
/// <summary>
/// 设置请求头
/// </summary>
public static GwTransform SetRequestHeader(string headerName, string value)
=> new() { Rules = new Dictionary<string, string>
{
{ "RequestHeader", headerName },
{ "Set", value }
}};
/// <summary>
/// 添加请求头
/// </summary>
public static GwTransform AppendRequestHeader(string headerName, string value)
=> new() { Rules = new Dictionary<string, string>
{
{ "RequestHeader", headerName },
{ "Append", value }
}};
/// <summary>
/// 设置响应头
/// </summary>
public static GwTransform SetResponseHeader(string headerName, string value)
=> new() { Rules = new Dictionary<string, string>
{
{ "ResponseHeader", headerName },
{ "Set", value }
}};
/// <summary>
/// 移除路径前缀
/// </summary>
public static GwTransform PathRemovePrefix(string prefix)
=> new() { Rules = new Dictionary<string, string>
{
{ "PathRemovePrefix", prefix }
}};
/// <summary>
/// 设置路径前缀
/// </summary>
public static GwTransform PathSetPrefix(string prefix)
=> new() { Rules = new Dictionary<string, string>
{
{ "PathPrefix", prefix }
}};
/// <summary>
/// 使用原始 Host 头
/// </summary>
public static GwTransform RequestHeaderOriginalHost()
=> new() { Rules = new Dictionary<string, string>
{
{ "RequestHeaderOriginalHost", "true" }
}};
}

8
Fengling.Platform.Domain/Fengling.Platform.Domain.csproj
View File

@ -4,10 +4,8 @@
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
<EnableDefaultEmbeddedResourceItems>false</EnableDefaultEmbeddedResourceItems>
<Version>1.0.0</Version>
<PackageVersion>1.0.0</PackageVersion>
</PropertyGroup>
<ItemGroup>
@ -16,4 +14,8 @@
<PackageReference Include="NetCorePal.Extensions.Primitives" />
</ItemGroup>
<ItemGroup>
<Folder Include="Items\" />
</ItemGroup>
</Project>

153
Fengling.Platform.Infrastructure/ClusterStore.cs
View File

@ -1,153 +0,0 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
namespace Fengling.Platform.Infrastructure;
/// <summary>
/// 集群存储实现
/// </summary>
public class ClusterStore<TContext> : IClusterStore
where TContext : PlatformDbContext
{
private readonly TContext _context;
private readonly DbSet<GwCluster> _clusters;
public ClusterStore(TContext context)
{
_context = context;
_clusters = context.GwClusters;
}
public void Dispose() { }
public virtual Task<GwCluster?> FindByIdAsync(string? id, CancellationToken cancellationToken = default)
{
if (id == null) return Task.FromResult<GwCluster?>(null);
return _clusters.FirstOrDefaultAsync(c => c.Id == id, cancellationToken);
}
public virtual Task<GwCluster?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default)
{
return _clusters.FirstOrDefaultAsync(c => c.ClusterId == clusterId && !c.IsDeleted, cancellationToken);
}
public virtual async Task<IList<GwCluster>> GetAllAsync(CancellationToken cancellationToken = default)
{
return await _clusters.Where(c => !c.IsDeleted).ToListAsync(cancellationToken);
}
public virtual async Task<IList<GwCluster>> GetPagedAsync(int page, int pageSize, string? clusterId = null,
string? name = null, int? status = null, CancellationToken cancellationToken = default)
{
var query = _clusters.AsQueryable();
if (!string.IsNullOrEmpty(clusterId))
query = query.Where(c => c.ClusterId.Contains(clusterId));
if (!string.IsNullOrEmpty(name))
query = query.Where(c => c.Name.Contains(name));
if (status.HasValue)
query = query.Where(c => c.Status == status.Value);
return await query
.Where(c => !c.IsDeleted)
.OrderByDescending(c => c.CreatedTime)
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync(cancellationToken);
}
public virtual async Task<int> GetCountAsync(string? clusterId = null, string? name = null,
int? status = null, CancellationToken cancellationToken = default)
{
var query = _clusters.AsQueryable();
if (!string.IsNullOrEmpty(clusterId))
query = query.Where(c => c.ClusterId.Contains(clusterId));
if (!string.IsNullOrEmpty(name))
query = query.Where(c => c.Name.Contains(name));
if (status.HasValue)
query = query.Where(c => c.Status == status.Value);
return await query.Where(c => !c.IsDeleted).CountAsync(cancellationToken);
}
public virtual async Task<IdentityResult> CreateAsync(GwCluster cluster, CancellationToken cancellationToken = default)
{
_clusters.Add(cluster);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> UpdateAsync(GwCluster cluster, CancellationToken cancellationToken = default)
{
cluster.UpdatedTime = DateTime.UtcNow;
_clusters.Update(cluster);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> DeleteAsync(GwCluster cluster, CancellationToken cancellationToken = default)
{
// 软删除
cluster.IsDeleted = true;
cluster.UpdatedTime = DateTime.UtcNow;
_clusters.Update(cluster);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<GwCluster?> AddDestinationAsync(string clusterId, GwDestination destination, CancellationToken cancellationToken = default)
{
var cluster = await _clusters.FirstOrDefaultAsync(c => c.ClusterId == clusterId && !c.IsDeleted, cancellationToken);
if (cluster == null) return null;
cluster.Destinations.Add(destination);
cluster.UpdatedTime = DateTime.UtcNow;
await _context.SaveChangesAsync(cancellationToken);
return cluster;
}
public virtual async Task<GwCluster?> UpdateDestinationAsync(string clusterId, string destinationId, GwDestination destination, CancellationToken cancellationToken = default)
{
var cluster = await _clusters
.Include(c => c.Destinations)
.FirstOrDefaultAsync(c => c.ClusterId == clusterId && !c.IsDeleted, cancellationToken);
if (cluster == null) return null;
var existingDest = cluster.Destinations.FirstOrDefault(d => d.DestinationId == destinationId);
if (existingDest == null) return null;
existingDest.Address = destination.Address;
existingDest.Health = destination.Health;
existingDest.Weight = destination.Weight;
existingDest.HealthStatus = destination.HealthStatus;
existingDest.Status = destination.Status;
cluster.UpdatedTime = DateTime.UtcNow;
await _context.SaveChangesAsync(cancellationToken);
return cluster;
}
public virtual async Task<GwCluster?> RemoveDestinationAsync(string clusterId, string destinationId, CancellationToken cancellationToken = default)
{
var cluster = await _clusters
.Include(c => c.Destinations)
.FirstOrDefaultAsync(c => c.ClusterId == clusterId && !c.IsDeleted, cancellationToken);
if (cluster == null) return null;
var destination = cluster.Destinations.FirstOrDefault(d => d.DestinationId == destinationId);
if (destination == null) return null;
cluster.Destinations.Remove(destination);
cluster.UpdatedTime = DateTime.UtcNow;
await _context.SaveChangesAsync(cancellationToken);
return cluster;
}
}

27
Fengling.Platform.Infrastructure/DesignTimeApplicationDbContextFactory.cs Normal file
View File

@ -0,0 +1,27 @@
namespace Fengling.Platform.Infrastructure;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Design;
using Microsoft.Extensions.DependencyInjection;
public class DesignTimeApplicationDbContextFactory : IDesignTimeDbContextFactory<PlatformDbContext>
{
public PlatformDbContext CreateDbContext(string[] args)
{
IServiceCollection services = new ServiceCollection();
services.AddMediatR(c =>
c.RegisterServicesFromAssemblies(typeof(DesignTimeApplicationDbContextFactory).Assembly));
services.AddDbContext<PlatformDbContext>(options =>
{
options.UseNpgsql("Host=localhost;Database=fengling_platform;Username=postgres;Password=postgres",
b =>
{
b.MigrationsAssembly(typeof(DesignTimeApplicationDbContextFactory).Assembly.FullName);
});
options.UseOpenIddict();
});
var provider = services.BuildServiceProvider();
var dbContext = provider.CreateScope().ServiceProvider.GetRequiredService<PlatformDbContext>();
return dbContext;
}
}

2
Fengling.Platform.Infrastructure/Extensions.cs
View File

@ -25,7 +25,7 @@ public static class Extensions
// Gateway 服务
services.AddScoped<IRouteStore, RouteStore<TContext>>();
services.AddScoped<IClusterStore, ClusterStore<TContext>>();
services.AddScoped<IInstanceStore, InstanceStore<TContext>>();
services.AddScoped<IRouteManager, RouteManager>();
serviceAction?.Invoke(services);

4
Fengling.Platform.Infrastructure/Fengling.Platform.Infrastructure.csproj
View File

@ -10,8 +10,12 @@
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" />
<PackageReference Include="Microsoft.EntityFrameworkCore" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" />
<PackageReference Include="NetCorePal.Extensions.Repository.EntityFrameworkCore.Snowflake" />
<PackageReference Include="NetCorePal.Extensions.Repository.EntityFrameworkCore" />
<PackageReference Include="MediatR" />
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
<PackageReference Include="OpenIddict.EntityFrameworkCore" />
</ItemGroup>

28
Fengling.Platform.Infrastructure/GatewayExtensions.cs
View File

@ -1,28 +0,0 @@
using Microsoft.Extensions.DependencyInjection;
namespace Fengling.Platform.Infrastructure;
/// <summary>
/// Gateway 服务扩展方法
/// </summary>
public static class GatewayExtensions
{
/// <summary>
/// 注册 Gateway 核心服务
/// </summary>
/// <typeparam name="TContext">数据库上下文类型</typeparam>
/// <param name="services">服务集合</param>
/// <returns>服务集合</returns>
public static IServiceCollection AddGatewayCore<TContext>(this IServiceCollection services)
where TContext : PlatformDbContext
{
// 注册 Gateway stores
services.AddScoped<IRouteStore, RouteStore<TContext>>();
services.AddScoped<IClusterStore, ClusterStore<TContext>>();
// 注册 Gateway managers
services.AddScoped<IRouteManager, RouteManager>();
return services;
}
}

6
Fengling.Platform.Infrastructure/GlobalUsings.cs
View File

@ -1 +1,7 @@
global using NetCorePal.Extensions.Domain;
global using NetCorePal.Extensions.Primitives;
global using NetCorePal.Extensions.Repository;
global using NetCorePal.Extensions.Repository.EntityFrameworkCore;
global using MediatR;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.EntityFrameworkCore.Metadata.Builders;

27
Fengling.Platform.Infrastructure/IClusterStore.cs
View File

@ -1,27 +0,0 @@
using Microsoft.AspNetCore.Identity;
using Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
namespace Fengling.Platform.Infrastructure;
/// <summary>
/// 集群存储接口
/// </summary>
public interface IClusterStore
{
Task<GwCluster?> FindByIdAsync(string? id, CancellationToken cancellationToken = default);
Task<GwCluster?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default);
Task<IList<GwCluster>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IList<GwCluster>> GetPagedAsync(int page, int pageSize, string? clusterId = null,
string? name = null, int? status = null, CancellationToken cancellationToken = default);
Task<int> GetCountAsync(string? clusterId = null, string? name = null,
int? status = null, CancellationToken cancellationToken = default);
Task<IdentityResult> CreateAsync(GwCluster cluster, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateAsync(GwCluster cluster, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteAsync(GwCluster cluster, CancellationToken cancellationToken = default);
// Destination management
Task<GwCluster?> AddDestinationAsync(string clusterId, GwDestination destination, CancellationToken cancellationToken = default);
Task<GwCluster?> UpdateDestinationAsync(string clusterId, string destinationId, GwDestination destination, CancellationToken cancellationToken = default);
Task<GwCluster?> RemoveDestinationAsync(string clusterId, string destinationId, CancellationToken cancellationToken = default);
}

23
Fengling.Platform.Infrastructure/IInstanceStore.cs Normal file
View File

@ -0,0 +1,23 @@
using Microsoft.AspNetCore.Identity;
using Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
namespace Fengling.Platform.Infrastructure;
/// <summary>
/// 服务实例存储接口
/// </summary>
public interface IInstanceStore
{
Task<GwServiceInstance?> FindByIdAsync(long? id, CancellationToken cancellationToken = default);
Task<GwServiceInstance?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default);
Task<GwServiceInstance?> FindByDestinationAsync(string clusterId, string destinationId, CancellationToken cancellationToken = default);
Task<IList<GwServiceInstance>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IList<GwServiceInstance>> GetPagedAsync(int page, int pageSize, string? clusterId = null,
InstanceHealth? health = null, InstanceStatus? status = null, CancellationToken cancellationToken = default);
Task<int> GetCountAsync(string? clusterId = null,
InstanceHealth? health = null, InstanceStatus? status = null, CancellationToken cancellationToken = default);
Task<IdentityResult> CreateAsync(GwServiceInstance instance, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateAsync(GwServiceInstance instance, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteAsync(GwServiceInstance instance, CancellationToken cancellationToken = default);
}

11
Fengling.Platform.Infrastructure/IRouteManager.cs
View File

@ -9,9 +9,10 @@ namespace Fengling.Platform.Infrastructure;
/// </summary>
public interface IRouteManager
{
Task<GwRoute?> FindByIdAsync(string? id, CancellationToken cancellationToken = default);
Task<IList<GwRoute>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IdentityResult> CreateRouteAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateRouteAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteRouteAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<GwTenantRoute?> FindByIdAsync(long? id, CancellationToken cancellationToken = default);
Task<GwTenantRoute?> FindByTenantCodeAsync(string tenantCode, CancellationToken cancellationToken = default);
Task<IList<GwTenantRoute>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IdentityResult> CreateRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
}

17
Fengling.Platform.Infrastructure/IRouteStore.cs
View File

@ -9,14 +9,15 @@ namespace Fengling.Platform.Infrastructure;
/// </summary>
public interface IRouteStore
{
Task<GwRoute?> FindByIdAsync(string? id, CancellationToken cancellationToken = default);
Task<GwRoute?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default);
Task<IList<GwRoute>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IList<GwRoute>> GetPagedAsync(int page, int pageSize,
Task<GwTenantRoute?> FindByIdAsync(long? id, CancellationToken cancellationToken = default);
Task<GwTenantRoute?> FindByTenantCodeAsync(string tenantCode, CancellationToken cancellationToken = default);
Task<GwTenantRoute?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default);
Task<IList<GwTenantRoute>> GetAllAsync(CancellationToken cancellationToken = default);
Task<IList<GwTenantRoute>> GetPagedAsync(int page, int pageSize, string? tenantCode = null,
string? serviceName = null, RouteStatus? status = null, CancellationToken cancellationToken = default);
Task<int> GetCountAsync(string? serviceName = null,
Task<int> GetCountAsync(string? tenantCode = null, string? serviceName = null,
RouteStatus? status = null, CancellationToken cancellationToken = default);
Task<IdentityResult> CreateAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteAsync(GwRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> CreateAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> UpdateAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
Task<IdentityResult> DeleteAsync(GwTenantRoute route, CancellationToken cancellationToken = default);
}

108
Fengling.Platform.Infrastructure/InstanceStore.cs Normal file
View File

@ -0,0 +1,108 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
namespace Fengling.Platform.Infrastructure;
/// <summary>
/// 服务实例存储实现
/// </summary>
public class InstanceStore<TContext> : IInstanceStore
where TContext : PlatformDbContext
{
private readonly TContext _context;
private readonly DbSet<GwServiceInstance> _instances;
public InstanceStore(TContext context)
{
_context = context;
_instances = context.GwServiceInstances;
}
public void Dispose() { }
public virtual Task<GwServiceInstance?> FindByIdAsync(long? id, CancellationToken cancellationToken = default)
{
if (id == null) return Task.FromResult<GwServiceInstance?>(null);
return _instances.FirstOrDefaultAsync(i => i.Id == id, cancellationToken);
}
public virtual Task<GwServiceInstance?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default)
{
return _instances.FirstOrDefaultAsync(i => i.ClusterId == clusterId && !i.IsDeleted, cancellationToken);
}
public virtual Task<GwServiceInstance?> FindByDestinationAsync(string clusterId, string destinationId, CancellationToken cancellationToken = default)
{
return _instances.FirstOrDefaultAsync(i => i.ClusterId == clusterId && i.DestinationId == destinationId && !i.IsDeleted, cancellationToken);
}
public virtual async Task<IList<GwServiceInstance>> GetAllAsync(CancellationToken cancellationToken = default)
{
return await _instances.Where(i => !i.IsDeleted).ToListAsync(cancellationToken);
}
public virtual async Task<IList<GwServiceInstance>> GetPagedAsync(int page, int pageSize, string? clusterId = null,
InstanceHealth? health = null, InstanceStatus? status = null, CancellationToken cancellationToken = default)
{
var query = _instances.AsQueryable();
if (!string.IsNullOrEmpty(clusterId))
query = query.Where(i => i.ClusterId.Contains(clusterId));
if (health.HasValue)
query = query.Where(i => i.Health == (int)health.Value);
if (status.HasValue)
query = query.Where(i => i.Status == (int)status.Value);
return await query
.Where(i => !i.IsDeleted)
.OrderByDescending(i => i.CreatedTime)
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync(cancellationToken);
}
public virtual async Task<int> GetCountAsync(string? clusterId = null,
InstanceHealth? health = null, InstanceStatus? status = null, CancellationToken cancellationToken = default)
{
var query = _instances.AsQueryable();
if (!string.IsNullOrEmpty(clusterId))
query = query.Where(i => i.ClusterId.Contains(clusterId));
if (health.HasValue)
query = query.Where(i => i.Health == (int)health.Value);
if (status.HasValue)
query = query.Where(i => i.Status == (int)status.Value);
return await query.Where(i => !i.IsDeleted).CountAsync(cancellationToken);
}
public virtual async Task<IdentityResult> CreateAsync(GwServiceInstance instance, CancellationToken cancellationToken = default)
{
_instances.Add(instance);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> UpdateAsync(GwServiceInstance instance, CancellationToken cancellationToken = default)
{
instance.UpdatedTime = DateTime.UtcNow;
_instances.Update(instance);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> DeleteAsync(GwServiceInstance instance, CancellationToken cancellationToken = default)
{
// 软删除
instance.IsDeleted = true;
instance.UpdatedTime = DateTime.UtcNow;
_instances.Update(instance);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
}

565
Fengling.Platform.Infrastructure/Migrations/20260221065049_Initial.Designer.cs generated Normal file
View File

@ -0,0 +1,565 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using Fengling.Platform.Infrastructure;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Fengling.Platform.Infrastructure.Migrations
{
[DbContext(typeof(PlatformDbContext))]
[Migration("20260221065049_Initial")]
partial class Initial
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.0")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<bool>("IsSystem")
.HasColumnType("boolean");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.PrimitiveCollection<List<string>>("Permissions")
.HasColumnType("text[]");
b.Property<long?>("TenantId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex");
b.ToTable("AspNetRoles", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.Tenant", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ContactEmail")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("ContactName")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ContactPhone")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<DateTime?>("ExpiresAt")
.HasColumnType("timestamp with time zone");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<int?>("MaxUsers")
.HasColumnType("integer");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<long>("RowVersion")
.HasColumnType("bigint");
b.Property<int>("Status")
.HasColumnType("integer");
b.Property<string>("TenantCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("UpdatedAt")
.HasColumnType("timestamp with time zone");
b.HasKey("Id");
b.HasIndex("Status");
b.HasIndex("TenantCode")
.IsUnique();
b.ToTable("Platform_Tenants", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AccessLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<int>("Duration")
.HasColumnType("integer");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Method")
.HasMaxLength(10)
.HasColumnType("character varying(10)");
b.Property<string>("RequestData")
.HasColumnType("text");
b.Property<string>("Resource")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("ResponseData")
.HasColumnType("text");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("UserAgent")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("UserName")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Status");
b.HasIndex("TenantId");
b.HasIndex("UserName");
b.ToTable("AccessLogs");
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<int>("AccessFailedCount")
.HasColumnType("integer");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("boolean");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<bool>("LockoutEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("timestamp with time zone");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("PasswordHash")
.HasColumnType("text");
b.Property<string>("PhoneNumber")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("boolean");
b.Property<string>("RealName")
.IsRequired()
.HasColumnType("text");
b.Property<string>("SecurityStamp")
.HasColumnType("text");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("UpdatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex");
b.HasIndex("PhoneNumber")
.IsUnique();
b.ToTable("AspNetUsers", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AuditLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("NewValue")
.HasColumnType("text");
b.Property<string>("OldValue")
.HasColumnType("text");
b.Property<string>("Operation")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("Operator")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<long?>("TargetId")
.HasColumnType("bigint");
b.Property<string>("TargetName")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("TargetType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Operation");
b.HasIndex("Operator");
b.HasIndex("TenantId");
b.ToTable("AuditLogs");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("AspNetRoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("AspNetUserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("ProviderKey")
.HasColumnType("text");
b.Property<string>("ProviderDisplayName")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("AspNetUserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("AspNetUserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("Name")
.HasColumnType("text");
b.Property<string>("Value")
.HasColumnType("text");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("AspNetUserTokens", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.OwnsOne("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.TenantInfo", "TenantInfo", b1 =>
{
b1.Property<long>("ApplicationUserId")
.HasColumnType("bigint");
b1.Property<string>("TenantCode")
.HasColumnType("text")
.HasColumnName("TenantCode");
b1.Property<long?>("TenantId")
.HasColumnType("bigint")
.HasColumnName("TenantId");
b1.Property<string>("TenantName")
.HasColumnType("text")
.HasColumnName("TenantName");
b1.HasKey("ApplicationUserId");
b1.ToTable("AspNetUsers");
b1.WithOwner()
.HasForeignKey("ApplicationUserId");
});
b.Navigation("TenantInfo");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
#pragma warning restore 612, 618
}
}
}

391
Fengling.Platform.Infrastructure/Migrations/20260221065049_Initial.cs Normal file
View File

@ -0,0 +1,391 @@
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore.Migrations;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Fengling.Platform.Infrastructure.Migrations
{
/// <inheritdoc />
public partial class Initial : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "AccessLogs",
columns: table => new
{
Id = table.Column<long>(type: "bigint", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
UserName = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
TenantId = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
Action = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
Resource = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
Method = table.Column<string>(type: "character varying(10)", maxLength: 10, nullable: true),
IpAddress = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
UserAgent = table.Column<string>(type: "character varying(500)", maxLength: 500, nullable: true),
Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
Duration = table.Column<int>(type: "integer", nullable: false),
RequestData = table.Column<string>(type: "text", nullable: true),
ResponseData = table.Column<string>(type: "text", nullable: true),
ErrorMessage = table.Column<string>(type: "text", nullable: true),
CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_AccessLogs", x => x.Id);
});
migrationBuilder.CreateTable(
name: "AspNetRoles",
columns: table => new
{
Id = table.Column<long>(type: "bigint", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
Description = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
CreatedTime = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
TenantId = table.Column<long>(type: "bigint", nullable: true),
IsSystem = table.Column<bool>(type: "boolean", nullable: false),
DisplayName = table.Column<string>(type: "text", nullable: true),
Permissions = table.Column<List<string>>(type: "text[]", nullable: true),
Name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
NormalizedName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
ConcurrencyStamp = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetRoles", x => x.Id);
});
migrationBuilder.CreateTable(
name: "AspNetUsers",
columns: table => new
{
Id = table.Column<long>(type: "bigint", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
RealName = table.Column<string>(type: "text", nullable: false),
TenantId = table.Column<long>(type: "bigint", nullable: true),
TenantCode = table.Column<string>(type: "text", nullable: true),
TenantName = table.Column<string>(type: "text", nullable: true),
CreatedTime = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
UpdatedTime = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
IsDeleted = table.Column<bool>(type: "boolean", nullable: false),
UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
NormalizedUserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
Email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
NormalizedEmail = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
EmailConfirmed = table.Column<bool>(type: "boolean", nullable: false),
PasswordHash = table.Column<string>(type: "text", nullable: true),
SecurityStamp = table.Column<string>(type: "text", nullable: true),
ConcurrencyStamp = table.Column<string>(type: "text", nullable: true),
PhoneNumber = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: true),
PhoneNumberConfirmed = table.Column<bool>(type: "boolean", nullable: false),
TwoFactorEnabled = table.Column<bool>(type: "boolean", nullable: false),
LockoutEnd = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
LockoutEnabled = table.Column<bool>(type: "boolean", nullable: false),
AccessFailedCount = table.Column<int>(type: "integer", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetUsers", x => x.Id);
});
migrationBuilder.CreateTable(
name: "AuditLogs",
columns: table => new
{
Id = table.Column<long>(type: "bigint", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
Operator = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
TenantId = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
Operation = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
Action = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
TargetType = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
TargetId = table.Column<long>(type: "bigint", nullable: true),
TargetName = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
IpAddress = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
Description = table.Column<string>(type: "character varying(500)", maxLength: 500, nullable: true),
OldValue = table.Column<string>(type: "text", nullable: true),
NewValue = table.Column<string>(type: "text", nullable: true),
ErrorMessage = table.Column<string>(type: "text", nullable: true),
Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_AuditLogs", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Platform_Tenants",
columns: table => new
{
Id = table.Column<long>(type: "bigint", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
TenantCode = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
Name = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
ContactName = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
ContactEmail = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
ContactPhone = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: true),
MaxUsers = table.Column<int>(type: "integer", nullable: true),
CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
ExpiresAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
Description = table.Column<string>(type: "character varying(500)", maxLength: 500, nullable: true),
Status = table.Column<int>(type: "integer", nullable: false),
IsDeleted = table.Column<bool>(type: "boolean", nullable: false),
RowVersion = table.Column<long>(type: "bigint", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Platform_Tenants", x => x.Id);
});
migrationBuilder.CreateTable(
name: "AspNetRoleClaims",
columns: table => new
{
Id = table.Column<int>(type: "integer", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
RoleId = table.Column<long>(type: "bigint", nullable: false),
ClaimType = table.Column<string>(type: "text", nullable: true),
ClaimValue = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
table.ForeignKey(
name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
column: x => x.RoleId,
principalTable: "AspNetRoles",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "AspNetUserClaims",
columns: table => new
{
Id = table.Column<int>(type: "integer", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
UserId = table.Column<long>(type: "bigint", nullable: false),
ClaimType = table.Column<string>(type: "text", nullable: true),
ClaimValue = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
table.ForeignKey(
name: "FK_AspNetUserClaims_AspNetUsers_UserId",
column: x => x.UserId,
principalTable: "AspNetUsers",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "AspNetUserLogins",
columns: table => new
{
LoginProvider = table.Column<string>(type: "text", nullable: false),
ProviderKey = table.Column<string>(type: "text", nullable: false),
ProviderDisplayName = table.Column<string>(type: "text", nullable: true),
UserId = table.Column<long>(type: "bigint", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
table.ForeignKey(
name: "FK_AspNetUserLogins_AspNetUsers_UserId",
column: x => x.UserId,
principalTable: "AspNetUsers",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "AspNetUserRoles",
columns: table => new
{
UserId = table.Column<long>(type: "bigint", nullable: false),
RoleId = table.Column<long>(type: "bigint", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
table.ForeignKey(
name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
column: x => x.RoleId,
principalTable: "AspNetRoles",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_AspNetUserRoles_AspNetUsers_UserId",
column: x => x.UserId,
principalTable: "AspNetUsers",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "AspNetUserTokens",
columns: table => new
{
UserId = table.Column<long>(type: "bigint", nullable: false),
LoginProvider = table.Column<string>(type: "text", nullable: false),
Name = table.Column<string>(type: "text", nullable: false),
Value = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
table.ForeignKey(
name: "FK_AspNetUserTokens_AspNetUsers_UserId",
column: x => x.UserId,
principalTable: "AspNetUsers",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateIndex(
name: "IX_AccessLogs_Action",
table: "AccessLogs",
column: "Action");
migrationBuilder.CreateIndex(
name: "IX_AccessLogs_CreatedAt",
table: "AccessLogs",
column: "CreatedAt");
migrationBuilder.CreateIndex(
name: "IX_AccessLogs_Status",
table: "AccessLogs",
column: "Status");
migrationBuilder.CreateIndex(
name: "IX_AccessLogs_TenantId",
table: "AccessLogs",
column: "TenantId");
migrationBuilder.CreateIndex(
name: "IX_AccessLogs_UserName",
table: "AccessLogs",
column: "UserName");
migrationBuilder.CreateIndex(
name: "IX_AspNetRoleClaims_RoleId",
table: "AspNetRoleClaims",
column: "RoleId");
migrationBuilder.CreateIndex(
name: "RoleNameIndex",
table: "AspNetRoles",
column: "NormalizedName",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_AspNetUserClaims_UserId",
table: "AspNetUserClaims",
column: "UserId");
migrationBuilder.CreateIndex(
name: "IX_AspNetUserLogins_UserId",
table: "AspNetUserLogins",
column: "UserId");
migrationBuilder.CreateIndex(
name: "IX_AspNetUserRoles_RoleId",
table: "AspNetUserRoles",
column: "RoleId");
migrationBuilder.CreateIndex(
name: "EmailIndex",
table: "AspNetUsers",
column: "NormalizedEmail");
migrationBuilder.CreateIndex(
name: "IX_AspNetUsers_PhoneNumber",
table: "AspNetUsers",
column: "PhoneNumber",
unique: true);
migrationBuilder.CreateIndex(
name: "UserNameIndex",
table: "AspNetUsers",
column: "NormalizedUserName",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_AuditLogs_Action",
table: "AuditLogs",
column: "Action");
migrationBuilder.CreateIndex(
name: "IX_AuditLogs_CreatedAt",
table: "AuditLogs",
column: "CreatedAt");
migrationBuilder.CreateIndex(
name: "IX_AuditLogs_Operation",
table: "AuditLogs",
column: "Operation");
migrationBuilder.CreateIndex(
name: "IX_AuditLogs_Operator",
table: "AuditLogs",
column: "Operator");
migrationBuilder.CreateIndex(
name: "IX_AuditLogs_TenantId",
table: "AuditLogs",
column: "TenantId");
migrationBuilder.CreateIndex(
name: "IX_Platform_Tenants_Status",
table: "Platform_Tenants",
column: "Status");
migrationBuilder.CreateIndex(
name: "IX_Platform_Tenants_TenantCode",
table: "Platform_Tenants",
column: "TenantCode",
unique: true);
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "AccessLogs");
migrationBuilder.DropTable(
name: "AspNetRoleClaims");
migrationBuilder.DropTable(
name: "AspNetUserClaims");
migrationBuilder.DropTable(
name: "AspNetUserLogins");
migrationBuilder.DropTable(
name: "AspNetUserRoles");
migrationBuilder.DropTable(
name: "AspNetUserTokens");
migrationBuilder.DropTable(
name: "AuditLogs");
migrationBuilder.DropTable(
name: "Platform_Tenants");
migrationBuilder.DropTable(
name: "AspNetRoles");
migrationBuilder.DropTable(
name: "AspNetUsers");
}
}
}

809
Fengling.Platform.Infrastructure/Migrations/20260221071055_OpenIddict.Designer.cs generated Normal file
View File

@ -0,0 +1,809 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using Fengling.Platform.Infrastructure;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Fengling.Platform.Infrastructure.Migrations
{
[DbContext(typeof(PlatformDbContext))]
[Migration("20260221071055_OpenIddict")]
partial class OpenIddict
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.0")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<bool>("IsSystem")
.HasColumnType("boolean");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.PrimitiveCollection<List<string>>("Permissions")
.HasColumnType("text[]");
b.Property<long?>("TenantId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex");
b.ToTable("AspNetRoles", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.Tenant", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ContactEmail")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("ContactName")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ContactPhone")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<DateTime?>("ExpiresAt")
.HasColumnType("timestamp with time zone");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<int?>("MaxUsers")
.HasColumnType("integer");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<long>("RowVersion")
.HasColumnType("bigint");
b.Property<int>("Status")
.HasColumnType("integer");
b.Property<string>("TenantCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("UpdatedAt")
.HasColumnType("timestamp with time zone");
b.HasKey("Id");
b.HasIndex("Status");
b.HasIndex("TenantCode")
.IsUnique();
b.ToTable("Platform_Tenants", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AccessLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<int>("Duration")
.HasColumnType("integer");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Method")
.HasMaxLength(10)
.HasColumnType("character varying(10)");
b.Property<string>("RequestData")
.HasColumnType("text");
b.Property<string>("Resource")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("ResponseData")
.HasColumnType("text");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("UserAgent")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("UserName")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Status");
b.HasIndex("TenantId");
b.HasIndex("UserName");
b.ToTable("AccessLogs");
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<int>("AccessFailedCount")
.HasColumnType("integer");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("boolean");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<bool>("LockoutEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("timestamp with time zone");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("PasswordHash")
.HasColumnType("text");
b.Property<string>("PhoneNumber")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("boolean");
b.Property<string>("RealName")
.IsRequired()
.HasColumnType("text");
b.Property<string>("SecurityStamp")
.HasColumnType("text");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("UpdatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex");
b.HasIndex("PhoneNumber")
.IsUnique();
b.ToTable("AspNetUsers", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AuditLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("NewValue")
.HasColumnType("text");
b.Property<string>("OldValue")
.HasColumnType("text");
b.Property<string>("Operation")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("Operator")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<long?>("TargetId")
.HasColumnType("bigint");
b.Property<string>("TargetName")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("TargetType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Operation");
b.HasIndex("Operator");
b.HasIndex("TenantId");
b.ToTable("AuditLogs");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("AspNetRoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("AspNetUserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("ProviderKey")
.HasColumnType("text");
b.Property<string>("ProviderDisplayName")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("AspNetUserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("AspNetUserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("Name")
.HasColumnType("text");
b.Property<string>("Value")
.HasColumnType("text");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("AspNetUserTokens", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ClientId")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("ClientSecret")
.HasColumnType("text");
b.Property<string>("ClientType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ConsentType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<string>("DisplayNames")
.HasColumnType("text");
b.Property<string>("JsonWebKeySet")
.HasColumnType("text");
b.Property<string>("Permissions")
.HasColumnType("text");
b.Property<string>("PostLogoutRedirectUris")
.HasColumnType("text");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("RedirectUris")
.HasColumnType("text");
b.Property<string>("Requirements")
.HasColumnType("text");
b.Property<string>("Settings")
.HasColumnType("text");
b.HasKey("Id");
b.HasIndex("ClientId")
.IsUnique();
b.ToTable("OpenIddictApplications", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationId")
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("CreationDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("Scopes")
.HasColumnType("text");
b.Property<string>("Status")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Subject")
.HasMaxLength(400)
.HasColumnType("character varying(400)");
b.Property<string>("Type")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("ApplicationId", "Status", "Subject", "Type");
b.ToTable("OpenIddictAuthorizations", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreScope", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Description")
.HasColumnType("text");
b.Property<string>("Descriptions")
.HasColumnType("text");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<string>("DisplayNames")
.HasColumnType("text");
b.Property<string>("Name")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("Resources")
.HasColumnType("text");
b.HasKey("Id");
b.HasIndex("Name")
.IsUnique();
b.ToTable("OpenIddictScopes", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationId")
.HasColumnType("text");
b.Property<string>("AuthorizationId")
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("CreationDate")
.HasColumnType("timestamp with time zone");
b.Property<DateTime?>("ExpirationDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("Payload")
.HasColumnType("text");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<DateTime?>("RedemptionDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("ReferenceId")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("Status")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Subject")
.HasMaxLength(400)
.HasColumnType("character varying(400)");
b.Property<string>("Type")
.HasMaxLength(150)
.HasColumnType("character varying(150)");
b.HasKey("Id");
b.HasIndex("AuthorizationId");
b.HasIndex("ReferenceId")
.IsUnique();
b.HasIndex("ApplicationId", "Status", "Subject", "Type");
b.ToTable("OpenIddictTokens", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.OwnsOne("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.TenantInfo", "TenantInfo", b1 =>
{
b1.Property<long>("ApplicationUserId")
.HasColumnType("bigint");
b1.Property<string>("TenantCode")
.HasColumnType("text")
.HasColumnName("TenantCode");
b1.Property<long?>("TenantId")
.HasColumnType("bigint")
.HasColumnName("TenantId");
b1.Property<string>("TenantName")
.HasColumnType("text")
.HasColumnName("TenantName");
b1.HasKey("ApplicationUserId");
b1.ToTable("AspNetUsers");
b1.WithOwner()
.HasForeignKey("ApplicationUserId");
});
b.Navigation("TenantInfo");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
.WithMany("Authorizations")
.HasForeignKey("ApplicationId");
b.Navigation("Application");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
{
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
.WithMany("Tokens")
.HasForeignKey("ApplicationId");
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", "Authorization")
.WithMany("Tokens")
.HasForeignKey("AuthorizationId");
b.Navigation("Application");
b.Navigation("Authorization");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
{
b.Navigation("Authorizations");
b.Navigation("Tokens");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.Navigation("Tokens");
});
#pragma warning restore 612, 618
}
}
}

166
Fengling.Platform.Infrastructure/Migrations/20260221071055_OpenIddict.cs Normal file
View File

@ -0,0 +1,166 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace Fengling.Platform.Infrastructure.Migrations
{
/// <inheritdoc />
public partial class OpenIddict : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "OpenIddictApplications",
columns: table => new
{
Id = table.Column<string>(type: "text", nullable: false),
ApplicationType = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
ClientId = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
ClientSecret = table.Column<string>(type: "text", nullable: true),
ClientType = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
ConcurrencyToken = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
ConsentType = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
DisplayName = table.Column<string>(type: "text", nullable: true),
DisplayNames = table.Column<string>(type: "text", nullable: true),
JsonWebKeySet = table.Column<string>(type: "text", nullable: true),
Permissions = table.Column<string>(type: "text", nullable: true),
PostLogoutRedirectUris = table.Column<string>(type: "text", nullable: true),
Properties = table.Column<string>(type: "text", nullable: true),
RedirectUris = table.Column<string>(type: "text", nullable: true),
Requirements = table.Column<string>(type: "text", nullable: true),
Settings = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_OpenIddictApplications", x => x.Id);
});
migrationBuilder.CreateTable(
name: "OpenIddictScopes",
columns: table => new
{
Id = table.Column<string>(type: "text", nullable: false),
ConcurrencyToken = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
Description = table.Column<string>(type: "text", nullable: true),
Descriptions = table.Column<string>(type: "text", nullable: true),
DisplayName = table.Column<string>(type: "text", nullable: true),
DisplayNames = table.Column<string>(type: "text", nullable: true),
Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
Properties = table.Column<string>(type: "text", nullable: true),
Resources = table.Column<string>(type: "text", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_OpenIddictScopes", x => x.Id);
});
migrationBuilder.CreateTable(
name: "OpenIddictAuthorizations",
columns: table => new
{
Id = table.Column<string>(type: "text", nullable: false),
ApplicationId = table.Column<string>(type: "text", nullable: true),
ConcurrencyToken = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
CreationDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
Properties = table.Column<string>(type: "text", nullable: true),
Scopes = table.Column<string>(type: "text", nullable: true),
Status = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
Subject = table.Column<string>(type: "character varying(400)", maxLength: 400, nullable: true),
Type = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_OpenIddictAuthorizations", x => x.Id);
table.ForeignKey(
name: "FK_OpenIddictAuthorizations_OpenIddictApplications_Application~",
column: x => x.ApplicationId,
principalTable: "OpenIddictApplications",
principalColumn: "Id");
});
migrationBuilder.CreateTable(
name: "OpenIddictTokens",
columns: table => new
{
Id = table.Column<string>(type: "text", nullable: false),
ApplicationId = table.Column<string>(type: "text", nullable: true),
AuthorizationId = table.Column<string>(type: "text", nullable: true),
ConcurrencyToken = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
CreationDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
ExpirationDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
Payload = table.Column<string>(type: "text", nullable: true),
Properties = table.Column<string>(type: "text", nullable: true),
RedemptionDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
ReferenceId = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
Status = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
Subject = table.Column<string>(type: "character varying(400)", maxLength: 400, nullable: true),
Type = table.Column<string>(type: "character varying(150)", maxLength: 150, nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_OpenIddictTokens", x => x.Id);
table.ForeignKey(
name: "FK_OpenIddictTokens_OpenIddictApplications_ApplicationId",
column: x => x.ApplicationId,
principalTable: "OpenIddictApplications",
principalColumn: "Id");
table.ForeignKey(
name: "FK_OpenIddictTokens_OpenIddictAuthorizations_AuthorizationId",
column: x => x.AuthorizationId,
principalTable: "OpenIddictAuthorizations",
principalColumn: "Id");
});
migrationBuilder.CreateIndex(
name: "IX_OpenIddictApplications_ClientId",
table: "OpenIddictApplications",
column: "ClientId",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_OpenIddictAuthorizations_ApplicationId_Status_Subject_Type",
table: "OpenIddictAuthorizations",
columns: new[] { "ApplicationId", "Status", "Subject", "Type" });
migrationBuilder.CreateIndex(
name: "IX_OpenIddictScopes_Name",
table: "OpenIddictScopes",
column: "Name",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_OpenIddictTokens_ApplicationId_Status_Subject_Type",
table: "OpenIddictTokens",
columns: new[] { "ApplicationId", "Status", "Subject", "Type" });
migrationBuilder.CreateIndex(
name: "IX_OpenIddictTokens_AuthorizationId",
table: "OpenIddictTokens",
column: "AuthorizationId");
migrationBuilder.CreateIndex(
name: "IX_OpenIddictTokens_ReferenceId",
table: "OpenIddictTokens",
column: "ReferenceId",
unique: true);
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "OpenIddictScopes");
migrationBuilder.DropTable(
name: "OpenIddictTokens");
migrationBuilder.DropTable(
name: "OpenIddictAuthorizations");
migrationBuilder.DropTable(
name: "OpenIddictApplications");
}
}
}

806
Fengling.Platform.Infrastructure/Migrations/PlatformDbContextModelSnapshot.cs Normal file
View File

@ -0,0 +1,806 @@
// <auto-generated />
using System;
using System.Collections.Generic;
using Fengling.Platform.Infrastructure;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
namespace Fengling.Platform.Infrastructure.Migrations
{
[DbContext(typeof(PlatformDbContext))]
partial class PlatformDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.0")
.HasAnnotation("Relational:MaxIdentifierLength", 63);
NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<bool>("IsSystem")
.HasColumnType("boolean");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.PrimitiveCollection<List<string>>("Permissions")
.HasColumnType("text[]");
b.Property<long?>("TenantId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex");
b.ToTable("AspNetRoles", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.Tenant", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("ContactEmail")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("ContactName")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ContactPhone")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<DateTime?>("ExpiresAt")
.HasColumnType("timestamp with time zone");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<int?>("MaxUsers")
.HasColumnType("integer");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<long>("RowVersion")
.HasColumnType("bigint");
b.Property<int>("Status")
.HasColumnType("integer");
b.Property<string>("TenantCode")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("UpdatedAt")
.HasColumnType("timestamp with time zone");
b.HasKey("Id");
b.HasIndex("Status");
b.HasIndex("TenantCode")
.IsUnique();
b.ToTable("Platform_Tenants", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AccessLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<int>("Duration")
.HasColumnType("integer");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Method")
.HasMaxLength(10)
.HasColumnType("character varying(10)");
b.Property<string>("RequestData")
.HasColumnType("text");
b.Property<string>("Resource")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("ResponseData")
.HasColumnType("text");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("UserAgent")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("UserName")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Status");
b.HasIndex("TenantId");
b.HasIndex("UserName");
b.ToTable("AccessLogs");
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<int>("AccessFailedCount")
.HasColumnType("integer");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("text");
b.Property<DateTimeOffset>("CreatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("boolean");
b.Property<bool>("IsDeleted")
.HasColumnType("boolean");
b.Property<bool>("LockoutEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("timestamp with time zone");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.Property<string>("PasswordHash")
.HasColumnType("text");
b.Property<string>("PhoneNumber")
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("boolean");
b.Property<string>("RealName")
.IsRequired()
.HasColumnType("text");
b.Property<string>("SecurityStamp")
.HasColumnType("text");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("boolean");
b.Property<DateTimeOffset?>("UpdatedTime")
.HasColumnType("timestamp with time zone");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("character varying(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex");
b.HasIndex("PhoneNumber")
.IsUnique();
b.ToTable("AspNetUsers", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.AuditLog", b =>
{
b.Property<long>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("bigint");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
b.Property<string>("Action")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<DateTime>("CreatedAt")
.HasColumnType("timestamp with time zone");
b.Property<string>("Description")
.HasMaxLength(500)
.HasColumnType("character varying(500)");
b.Property<string>("ErrorMessage")
.HasColumnType("text");
b.Property<string>("IpAddress")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("NewValue")
.HasColumnType("text");
b.Property<string>("OldValue")
.HasColumnType("text");
b.Property<string>("Operation")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<string>("Operator")
.IsRequired()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Status")
.IsRequired()
.HasMaxLength(20)
.HasColumnType("character varying(20)");
b.Property<long?>("TargetId")
.HasColumnType("bigint");
b.Property<string>("TargetName")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("TargetType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("TenantId")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("Action");
b.HasIndex("CreatedAt");
b.HasIndex("Operation");
b.HasIndex("Operator");
b.HasIndex("TenantId");
b.ToTable("AuditLogs");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("AspNetRoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("text");
b.Property<string>("ClaimValue")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("AspNetUserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("ProviderKey")
.HasColumnType("text");
b.Property<string>("ProviderDisplayName")
.HasColumnType("text");
b.Property<long>("UserId")
.HasColumnType("bigint");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("AspNetUserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<long>("RoleId")
.HasColumnType("bigint");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("AspNetUserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.Property<long>("UserId")
.HasColumnType("bigint");
b.Property<string>("LoginProvider")
.HasColumnType("text");
b.Property<string>("Name")
.HasColumnType("text");
b.Property<string>("Value")
.HasColumnType("text");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("AspNetUserTokens", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ClientId")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("ClientSecret")
.HasColumnType("text");
b.Property<string>("ClientType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("ConsentType")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<string>("DisplayNames")
.HasColumnType("text");
b.Property<string>("JsonWebKeySet")
.HasColumnType("text");
b.Property<string>("Permissions")
.HasColumnType("text");
b.Property<string>("PostLogoutRedirectUris")
.HasColumnType("text");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("RedirectUris")
.HasColumnType("text");
b.Property<string>("Requirements")
.HasColumnType("text");
b.Property<string>("Settings")
.HasColumnType("text");
b.HasKey("Id");
b.HasIndex("ClientId")
.IsUnique();
b.ToTable("OpenIddictApplications", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationId")
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("CreationDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("Scopes")
.HasColumnType("text");
b.Property<string>("Status")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Subject")
.HasMaxLength(400)
.HasColumnType("character varying(400)");
b.Property<string>("Type")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.HasKey("Id");
b.HasIndex("ApplicationId", "Status", "Subject", "Type");
b.ToTable("OpenIddictAuthorizations", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreScope", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Description")
.HasColumnType("text");
b.Property<string>("Descriptions")
.HasColumnType("text");
b.Property<string>("DisplayName")
.HasColumnType("text");
b.Property<string>("DisplayNames")
.HasColumnType("text");
b.Property<string>("Name")
.HasMaxLength(200)
.HasColumnType("character varying(200)");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<string>("Resources")
.HasColumnType("text");
b.HasKey("Id");
b.HasIndex("Name")
.IsUnique();
b.ToTable("OpenIddictScopes", (string)null);
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
{
b.Property<string>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("text");
b.Property<string>("ApplicationId")
.HasColumnType("text");
b.Property<string>("AuthorizationId")
.HasColumnType("text");
b.Property<string>("ConcurrencyToken")
.IsConcurrencyToken()
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<DateTime?>("CreationDate")
.HasColumnType("timestamp with time zone");
b.Property<DateTime?>("ExpirationDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("Payload")
.HasColumnType("text");
b.Property<string>("Properties")
.HasColumnType("text");
b.Property<DateTime?>("RedemptionDate")
.HasColumnType("timestamp with time zone");
b.Property<string>("ReferenceId")
.HasMaxLength(100)
.HasColumnType("character varying(100)");
b.Property<string>("Status")
.HasMaxLength(50)
.HasColumnType("character varying(50)");
b.Property<string>("Subject")
.HasMaxLength(400)
.HasColumnType("character varying(400)");
b.Property<string>("Type")
.HasMaxLength(150)
.HasColumnType("character varying(150)");
b.HasKey("Id");
b.HasIndex("AuthorizationId");
b.HasIndex("ReferenceId")
.IsUnique();
b.HasIndex("ApplicationId", "Status", "Subject", "Type");
b.ToTable("OpenIddictTokens", (string)null);
});
modelBuilder.Entity("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", b =>
{
b.OwnsOne("Fengling.Platform.Domain.AggregatesModel.TenantAggregate.TenantInfo", "TenantInfo", b1 =>
{
b1.Property<long>("ApplicationUserId")
.HasColumnType("bigint");
b1.Property<string>("TenantCode")
.HasColumnType("text")
.HasColumnName("TenantCode");
b1.Property<long?>("TenantId")
.HasColumnType("bigint")
.HasColumnName("TenantId");
b1.Property<string>("TenantName")
.HasColumnType("text")
.HasColumnName("TenantName");
b1.HasKey("ApplicationUserId");
b1.ToTable("AspNetUsers");
b1.WithOwner()
.HasForeignKey("ApplicationUserId");
});
b.Navigation("TenantInfo");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.RoleAggregate.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<long>", b =>
{
b.HasOne("Fengling.Platform.Domain.AggregatesModel.UserAggregate.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
.WithMany("Authorizations")
.HasForeignKey("ApplicationId");
b.Navigation("Application");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
{
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
.WithMany("Tokens")
.HasForeignKey("ApplicationId");
b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", "Authorization")
.WithMany("Tokens")
.HasForeignKey("AuthorizationId");
b.Navigation("Application");
b.Navigation("Authorization");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
{
b.Navigation("Authorizations");
b.Navigation("Tokens");
});
modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
{
b.Navigation("Tokens");
});
#pragma warning restore 612, 618
}
}
}

191
Fengling.Platform.Infrastructure/Migrations/sql/20260221065049_initial.sql Normal file
View File

@ -0,0 +1,191 @@
CREATE TABLE IF NOT EXISTS "__EFMigrationsHistory" (
"MigrationId" character varying(150) NOT NULL,
"ProductVersion" character varying(32) NOT NULL,
CONSTRAINT "PK___EFMigrationsHistory" PRIMARY KEY ("MigrationId")
);
START TRANSACTION;
CREATE TABLE "AccessLogs" (
"Id" bigint GENERATED BY DEFAULT AS IDENTITY,
"UserName" character varying(50),
"TenantId" character varying(50),
"Action" character varying(20) NOT NULL,
"Resource" character varying(200),
"Method" character varying(10),
"IpAddress" character varying(50),
"UserAgent" character varying(500),
"Status" character varying(20) NOT NULL,
"Duration" integer NOT NULL,
"RequestData" text,
"ResponseData" text,
"ErrorMessage" text,
"CreatedAt" timestamp with time zone NOT NULL,
CONSTRAINT "PK_AccessLogs" PRIMARY KEY ("Id")
);
CREATE TABLE "AspNetRoles" (
"Id" bigint GENERATED BY DEFAULT AS IDENTITY,
"Description" character varying(200),
"CreatedTime" timestamp with time zone NOT NULL,
"TenantId" bigint,
"IsSystem" boolean NOT NULL,
"DisplayName" text,
"Permissions" text[],
"Name" character varying(256),
"NormalizedName" character varying(256),
"ConcurrencyStamp" text,
CONSTRAINT "PK_AspNetRoles" PRIMARY KEY ("Id")
);
CREATE TABLE "AspNetUsers" (
"Id" bigint GENERATED BY DEFAULT AS IDENTITY,
"RealName" text NOT NULL,
"TenantId" bigint,
"TenantCode" text,
"TenantName" text,
"CreatedTime" timestamp with time zone NOT NULL,
"UpdatedTime" timestamp with time zone,
"IsDeleted" boolean NOT NULL,
"UserName" character varying(256),
"NormalizedUserName" character varying(256),
"Email" character varying(256),
"NormalizedEmail" character varying(256),
"EmailConfirmed" boolean NOT NULL,
"PasswordHash" text,
"SecurityStamp" text,
"ConcurrencyStamp" text,
"PhoneNumber" character varying(20),
"PhoneNumberConfirmed" boolean NOT NULL,
"TwoFactorEnabled" boolean NOT NULL,
"LockoutEnd" timestamp with time zone,
"LockoutEnabled" boolean NOT NULL,
"AccessFailedCount" integer NOT NULL,
CONSTRAINT "PK_AspNetUsers" PRIMARY KEY ("Id")
);
CREATE TABLE "AuditLogs" (
"Id" bigint GENERATED BY DEFAULT AS IDENTITY,
"Operator" character varying(50) NOT NULL,
"TenantId" character varying(50),
"Operation" character varying(20) NOT NULL,
"Action" character varying(20) NOT NULL,
"TargetType" character varying(50),
"TargetId" bigint,
"TargetName" character varying(100),
"IpAddress" character varying(50) NOT NULL,
"Description" character varying(500),
"OldValue" text,
"NewValue" text,
"ErrorMessage" text,
"Status" character varying(20) NOT NULL,
"CreatedAt" timestamp with time zone NOT NULL,
CONSTRAINT "PK_AuditLogs" PRIMARY KEY ("Id")
);
CREATE TABLE "Platform_Tenants" (
"Id" bigint GENERATED BY DEFAULT AS IDENTITY,
"TenantCode" character varying(50) NOT NULL,
"Name" character varying(100) NOT NULL,
"ContactName" character varying(50) NOT NULL,
"ContactEmail" character varying(100) NOT NULL,
"ContactPhone" character varying(20),
"MaxUsers" integer,
"CreatedAt" timestamp with time zone NOT NULL,
"UpdatedAt" timestamp with time zone,
"ExpiresAt" timestamp with time zone,
"Description" character varying(500),
"Status" integer NOT NULL,
"IsDeleted" boolean NOT NULL,
"RowVersion" bigint NOT NULL,
CONSTRAINT "PK_Platform_Tenants" PRIMARY KEY ("Id")
);
CREATE TABLE "AspNetRoleClaims" (
"Id" integer GENERATED BY DEFAULT AS IDENTITY,
"RoleId" bigint NOT NULL,
"ClaimType" text,
"ClaimValue" text,
CONSTRAINT "PK_AspNetRoleClaims" PRIMARY KEY ("Id"),
CONSTRAINT "FK_AspNetRoleClaims_AspNetRoles_RoleId" FOREIGN KEY ("RoleId") REFERENCES "AspNetRoles" ("Id") ON DELETE CASCADE
);
CREATE TABLE "AspNetUserClaims" (
"Id" integer GENERATED BY DEFAULT AS IDENTITY,
"UserId" bigint NOT NULL,
"ClaimType" text,
"ClaimValue" text,
CONSTRAINT "PK_AspNetUserClaims" PRIMARY KEY ("Id"),
CONSTRAINT "FK_AspNetUserClaims_AspNetUsers_UserId" FOREIGN KEY ("UserId") REFERENCES "AspNetUsers" ("Id") ON DELETE CASCADE
);
CREATE TABLE "AspNetUserLogins" (
"LoginProvider" text NOT NULL,
"ProviderKey" text NOT NULL,
"ProviderDisplayName" text,
"UserId" bigint NOT NULL,
CONSTRAINT "PK_AspNetUserLogins" PRIMARY KEY ("LoginProvider", "ProviderKey"),
CONSTRAINT "FK_AspNetUserLogins_AspNetUsers_UserId" FOREIGN KEY ("UserId") REFERENCES "AspNetUsers" ("Id") ON DELETE CASCADE
);
CREATE TABLE "AspNetUserRoles" (
"UserId" bigint NOT NULL,
"RoleId" bigint NOT NULL,
CONSTRAINT "PK_AspNetUserRoles" PRIMARY KEY ("UserId", "RoleId"),
CONSTRAINT "FK_AspNetUserRoles_AspNetRoles_RoleId" FOREIGN KEY ("RoleId") REFERENCES "AspNetRoles" ("Id") ON DELETE CASCADE,
CONSTRAINT "FK_AspNetUserRoles_AspNetUsers_UserId" FOREIGN KEY ("UserId") REFERENCES "AspNetUsers" ("Id") ON DELETE CASCADE
);
CREATE TABLE "AspNetUserTokens" (
"UserId" bigint NOT NULL,
"LoginProvider" text NOT NULL,
"Name" text NOT NULL,
"Value" text,
CONSTRAINT "PK_AspNetUserTokens" PRIMARY KEY ("UserId", "LoginProvider", "Name"),
CONSTRAINT "FK_AspNetUserTokens_AspNetUsers_UserId" FOREIGN KEY ("UserId") REFERENCES "AspNetUsers" ("Id") ON DELETE CASCADE
);
CREATE INDEX "IX_AccessLogs_Action" ON "AccessLogs" ("Action");
CREATE INDEX "IX_AccessLogs_CreatedAt" ON "AccessLogs" ("CreatedAt");
CREATE INDEX "IX_AccessLogs_Status" ON "AccessLogs" ("Status");
CREATE INDEX "IX_AccessLogs_TenantId" ON "AccessLogs" ("TenantId");
CREATE INDEX "IX_AccessLogs_UserName" ON "AccessLogs" ("UserName");
CREATE INDEX "IX_AspNetRoleClaims_RoleId" ON "AspNetRoleClaims" ("RoleId");
CREATE UNIQUE INDEX "RoleNameIndex" ON "AspNetRoles" ("NormalizedName");
CREATE INDEX "IX_AspNetUserClaims_UserId" ON "AspNetUserClaims" ("UserId");
CREATE INDEX "IX_AspNetUserLogins_UserId" ON "AspNetUserLogins" ("UserId");
CREATE INDEX "IX_AspNetUserRoles_RoleId" ON "AspNetUserRoles" ("RoleId");
CREATE INDEX "EmailIndex" ON "AspNetUsers" ("NormalizedEmail");
CREATE UNIQUE INDEX "IX_AspNetUsers_PhoneNumber" ON "AspNetUsers" ("PhoneNumber");
CREATE UNIQUE INDEX "UserNameIndex" ON "AspNetUsers" ("NormalizedUserName");
CREATE INDEX "IX_AuditLogs_Action" ON "AuditLogs" ("Action");
CREATE INDEX "IX_AuditLogs_CreatedAt" ON "AuditLogs" ("CreatedAt");
CREATE INDEX "IX_AuditLogs_Operation" ON "AuditLogs" ("Operation");
CREATE INDEX "IX_AuditLogs_Operator" ON "AuditLogs" ("Operator");
CREATE INDEX "IX_AuditLogs_TenantId" ON "AuditLogs" ("TenantId");
CREATE INDEX "IX_Platform_Tenants_Status" ON "Platform_Tenants" ("Status");
CREATE UNIQUE INDEX "IX_Platform_Tenants_TenantCode" ON "Platform_Tenants" ("TenantCode");
INSERT INTO "__EFMigrationsHistory" ("MigrationId", "ProductVersion")
VALUES ('20260221065049_Initial', '10.0.0');
COMMIT;

84
Fengling.Platform.Infrastructure/Migrations/sql/20260221_openiddict.sql Normal file
View File

@ -0,0 +1,84 @@
START TRANSACTION;
CREATE TABLE "OpenIddictApplications" (
"Id" text NOT NULL,
"ApplicationType" character varying(50),
"ClientId" character varying(100),
"ClientSecret" text,
"ClientType" character varying(50),
"ConcurrencyToken" character varying(50),
"ConsentType" character varying(50),
"DisplayName" text,
"DisplayNames" text,
"JsonWebKeySet" text,
"Permissions" text,
"PostLogoutRedirectUris" text,
"Properties" text,
"RedirectUris" text,
"Requirements" text,
"Settings" text,
CONSTRAINT "PK_OpenIddictApplications" PRIMARY KEY ("Id")
);
CREATE TABLE "OpenIddictScopes" (
"Id" text NOT NULL,
"ConcurrencyToken" character varying(50),
"Description" text,
"Descriptions" text,
"DisplayName" text,
"DisplayNames" text,
"Name" character varying(200),
"Properties" text,
"Resources" text,
CONSTRAINT "PK_OpenIddictScopes" PRIMARY KEY ("Id")
);
CREATE TABLE "OpenIddictAuthorizations" (
"Id" text NOT NULL,
"ApplicationId" text,
"ConcurrencyToken" character varying(50),
"CreationDate" timestamp with time zone,
"Properties" text,
"Scopes" text,
"Status" character varying(50),
"Subject" character varying(400),
"Type" character varying(50),
CONSTRAINT "PK_OpenIddictAuthorizations" PRIMARY KEY ("Id"),
CONSTRAINT "FK_OpenIddictAuthorizations_OpenIddictApplications_Application~" FOREIGN KEY ("ApplicationId") REFERENCES "OpenIddictApplications" ("Id")
);
CREATE TABLE "OpenIddictTokens" (
"Id" text NOT NULL,
"ApplicationId" text,
"AuthorizationId" text,
"ConcurrencyToken" character varying(50),
"CreationDate" timestamp with time zone,
"ExpirationDate" timestamp with time zone,
"Payload" text,
"Properties" text,
"RedemptionDate" timestamp with time zone,
"ReferenceId" character varying(100),
"Status" character varying(50),
"Subject" character varying(400),
"Type" character varying(150),
CONSTRAINT "PK_OpenIddictTokens" PRIMARY KEY ("Id"),
CONSTRAINT "FK_OpenIddictTokens_OpenIddictApplications_ApplicationId" FOREIGN KEY ("ApplicationId") REFERENCES "OpenIddictApplications" ("Id"),
CONSTRAINT "FK_OpenIddictTokens_OpenIddictAuthorizations_AuthorizationId" FOREIGN KEY ("AuthorizationId") REFERENCES "OpenIddictAuthorizations" ("Id")
);
CREATE UNIQUE INDEX "IX_OpenIddictApplications_ClientId" ON "OpenIddictApplications" ("ClientId");
CREATE INDEX "IX_OpenIddictAuthorizations_ApplicationId_Status_Subject_Type" ON "OpenIddictAuthorizations" ("ApplicationId", "Status", "Subject", "Type");
CREATE UNIQUE INDEX "IX_OpenIddictScopes_Name" ON "OpenIddictScopes" ("Name");
CREATE INDEX "IX_OpenIddictTokens_ApplicationId_Status_Subject_Type" ON "OpenIddictTokens" ("ApplicationId", "Status", "Subject", "Type");
CREATE INDEX "IX_OpenIddictTokens_AuthorizationId" ON "OpenIddictTokens" ("AuthorizationId");
CREATE UNIQUE INDEX "IX_OpenIddictTokens_ReferenceId" ON "OpenIddictTokens" ("ReferenceId");
INSERT INTO "__EFMigrationsHistory" ("MigrationId", "ProductVersion")
VALUES ('20260221071055_OpenIddict', '10.0.0');
COMMIT;

113
Fengling.Platform.Infrastructure/PlatformDbContext.cs
View File

@ -1,15 +1,15 @@
using Fengling.Platform.Domain.AggregatesModel.GatewayAggregate;
using Fengling.Platform.Domain.AggregatesModel.RoleAggregate;
using Fengling.Platform.Domain.AggregatesModel.TenantAggregate;
using Fengling.Platform.Domain.AggregatesModel.UserAggregate;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using System.Text.Json;
namespace Fengling.Platform.Infrastructure;
public class PlatformDbContext(DbContextOptions options)
: IdentityDbContext<ApplicationUser, ApplicationRole, long>(options)
{
@ -18,8 +18,9 @@ public class PlatformDbContext(DbContextOptions options)
public DbSet<AuditLog> AuditLogs => Set<AuditLog>();
// Gateway 实体
public DbSet<GwRoute> GwRoutes => Set<GwRoute>();
public DbSet<GwCluster> GwClusters => Set<GwCluster>();
public DbSet<GwTenant> GwTenants => Set<GwTenant>();
public DbSet<GwTenantRoute> GwTenantRoutes => Set<GwTenantRoute>();
public DbSet<GwServiceInstance> GwServiceInstances => Set<GwServiceInstance>();
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
@ -28,12 +29,6 @@ public class PlatformDbContext(DbContextOptions options)
throw new ArgumentNullException(nameof(modelBuilder));
}
// 忽略这些类型，让它们只作为 JSON 值对象使用
modelBuilder.Ignore<GwRouteMatch>();
modelBuilder.Ignore<GwRouteHeader>();
modelBuilder.Ignore<GwRouteQueryParameter>();
modelBuilder.Ignore<GwTransform>();
modelBuilder.Entity<ApplicationUser>(entity =>
{
entity.Property(e => e.PhoneNumber).HasMaxLength(20);
@ -91,95 +86,35 @@ public class PlatformDbContext(DbContextOptions options)
});
// Gateway 实体配置
modelBuilder.Entity<GwRoute>(entity =>
modelBuilder.Entity<GwTenant>(entity =>
{
entity.ToTable("GwRoutes");
entity.HasKey(e => e.Id);
entity.Property(e => e.TenantCode).HasMaxLength(50).IsRequired();
entity.Property(e => e.TenantName).HasMaxLength(100).IsRequired();
entity.HasIndex(e => e.TenantCode).IsUnique();
});
modelBuilder.Entity<GwTenantRoute>(entity =>
{
entity.HasKey(e => e.Id);
entity.Property(e => e.TenantCode).HasMaxLength(50);
entity.Property(e => e.ServiceName).HasMaxLength(100).IsRequired();
entity.Property(e => e.ClusterId).HasMaxLength(100).IsRequired();
entity.Property(e => e.AuthorizationPolicy).HasMaxLength(100);
entity.Property(e => e.CorsPolicy).HasMaxLength(100);
entity.Property(e => e.RateLimiterPolicy).HasMaxLength(100);
// 枚举转换为字符串
entity.Property(e => e.LoadBalancingPolicy)
.HasConversion(
v => v.HasValue ? v.Value.ToString() : null,
v => v != null ? Enum.Parse<GwLoadBalancingPolicy>(v) : null
)
.HasMaxLength(50);
// 值对象映射为 JSON 列 - 使用值转换器
var jsonOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
entity.Property(e => e.Match)
.HasConversion(
v => JsonSerializer.Serialize(v, jsonOptions),
v => JsonSerializer.Deserialize<GwRouteMatch>(v, jsonOptions)!,
new ValueComparer<GwRouteMatch>(
(c1, c2) => JsonSerializer.Serialize(c1, jsonOptions) == JsonSerializer.Serialize(c2, jsonOptions),
c => c == null ? 0 : JsonSerializer.Serialize(c, jsonOptions).GetHashCode(),
c => JsonSerializer.Deserialize<GwRouteMatch>(JsonSerializer.Serialize(c, jsonOptions), jsonOptions)!))
.HasColumnType("jsonb");
// 转换规则映射为 JSON 列 - 使用值转换器
entity.Property(e => e.Transforms)
.HasConversion(
v => JsonSerializer.Serialize(v, jsonOptions),
v => JsonSerializer.Deserialize<List<GwTransform>>(v, jsonOptions),
new ValueComparer<List<GwTransform>>(
(c1, c2) => JsonSerializer.Serialize(c1, jsonOptions) == JsonSerializer.Serialize(c2, jsonOptions),
c => c == null ? 0 : JsonSerializer.Serialize(c, jsonOptions).GetHashCode(),
c => JsonSerializer.Deserialize<List<GwTransform>>(JsonSerializer.Serialize(c, jsonOptions), jsonOptions)!))
.HasColumnType("jsonb");
entity.Property(e => e.PathPattern).HasMaxLength(200).IsRequired();
entity.HasIndex(e => e.TenantCode);
entity.HasIndex(e => e.ServiceName);
entity.HasIndex(e => e.ClusterId);
entity.HasIndex(e => new { e.ServiceName, e.Status });
entity.HasIndex(e => new { e.ServiceName, e.IsGlobal, e.Status });
});
// GwCluster 聚合根配置
modelBuilder.Entity<GwCluster>(entity =>
modelBuilder.Entity<GwServiceInstance>(entity =>
{
entity.ToTable("ServiceInstances");
entity.HasKey(e => e.Id);
entity.Property(e => e.ClusterId).HasMaxLength(100).IsRequired();
entity.Property(e => e.Name).HasMaxLength(100).IsRequired();
entity.Property(e => e.Description).HasMaxLength(500);
// 枚举转换为字符串
entity.Property(e => e.LoadBalancingPolicy)
.HasConversion(
v => v.ToString(),
v => Enum.Parse<GwLoadBalancingPolicy>(v)
)
.HasMaxLength(50);
entity.HasIndex(e => e.ClusterId).IsUnique();
entity.HasIndex(e => e.Name);
entity.HasIndex(e => e.Status);
// 配置内嵌的目标端点列表
entity.OwnsMany(e => e.Destinations, owned =>
{
owned.WithOwner().HasForeignKey("ClusterId");
owned.Property<string>("ClusterId").HasMaxLength(100);
owned.Property(d => d.DestinationId).HasMaxLength(100).IsRequired();
owned.Property(d => d.Address).HasMaxLength(200).IsRequired();
owned.Property(d => d.Health).HasMaxLength(200);
owned.HasIndex("ClusterId", "DestinationId");
});
// 配置内嵌健康检查配置（JSON 列）
entity.OwnsOne(e => e.HealthCheck, owned =>
{
owned.ToJson();
});
// 配置内嵌会话亲和配置（JSON 列）
entity.OwnsOne(e => e.SessionAffinity, owned =>
{
owned.ToJson();
});
entity.Property(e => e.DestinationId).HasMaxLength(100).IsRequired();
entity.Property(e => e.Address).HasMaxLength(200).IsRequired();
entity.HasIndex(e => new { e.ClusterId, e.DestinationId }).IsUnique();
entity.HasIndex(e => e.Health);
});
modelBuilder.ApplyConfigurationsFromAssembly(typeof(PlatformDbContext).Assembly);

13
Fengling.Platform.Infrastructure/RouteManager.cs
View File

@ -15,21 +15,24 @@ public class RouteManager : IRouteManager
_store = store;
}
public virtual Task<GwRoute?> FindByIdAsync(string? id, CancellationToken cancellationToken = default)
public virtual Task<GwTenantRoute?> FindByIdAsync(long? id, CancellationToken cancellationToken = default)
=> _store.FindByIdAsync(id, cancellationToken);
public virtual Task<IList<GwRoute>> GetAllAsync(CancellationToken cancellationToken = default)
public virtual Task<GwTenantRoute?> FindByTenantCodeAsync(string tenantCode, CancellationToken cancellationToken = default)
=> _store.FindByTenantCodeAsync(tenantCode, cancellationToken);
public virtual Task<IList<GwTenantRoute>> GetAllAsync(CancellationToken cancellationToken = default)
=> _store.GetAllAsync(cancellationToken);
public virtual Task<IdentityResult> CreateRouteAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual Task<IdentityResult> CreateRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
{
route.CreatedTime = DateTime.UtcNow;
return _store.CreateAsync(route, cancellationToken);
}
public virtual Task<IdentityResult> UpdateRouteAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual Task<IdentityResult> UpdateRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
=> _store.UpdateAsync(route, cancellationToken);
public virtual Task<IdentityResult> DeleteRouteAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual Task<IdentityResult> DeleteRouteAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
=> _store.DeleteAsync(route, cancellationToken);
}

33
Fengling.Platform.Infrastructure/RouteStore.cs
View File

@ -11,37 +11,45 @@ public class RouteStore<TContext> : IRouteStore
where TContext : PlatformDbContext
{
private readonly TContext _context;
private readonly DbSet<GwRoute> _routes;
private readonly DbSet<GwTenantRoute> _routes;
public RouteStore(TContext context)
{
_context = context;
_routes = context.GwRoutes;
_routes = context.GwTenantRoutes;
}
public void Dispose() { }
public virtual Task<GwRoute?> FindByIdAsync(string? id, CancellationToken cancellationToken = default)
public virtual Task<GwTenantRoute?> FindByIdAsync(long? id, CancellationToken cancellationToken = default)
{
if (id == null) return Task.FromResult<GwRoute?>(null);
if (id == null) return Task.FromResult<GwTenantRoute?>(null);
return _routes.FirstOrDefaultAsync(r => r.Id == id, cancellationToken);
}
public virtual Task<GwRoute?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default)
public virtual Task<GwTenantRoute?> FindByTenantCodeAsync(string tenantCode, CancellationToken cancellationToken = default)
{
return _routes.FirstOrDefaultAsync(r => r.TenantCode == tenantCode && !r.IsDeleted, cancellationToken);
}
public virtual Task<GwTenantRoute?> FindByClusterIdAsync(string clusterId, CancellationToken cancellationToken = default)
{
return _routes.FirstOrDefaultAsync(r => r.ClusterId == clusterId && !r.IsDeleted, cancellationToken);
}
public virtual async Task<IList<GwRoute>> GetAllAsync(CancellationToken cancellationToken = default)
public virtual async Task<IList<GwTenantRoute>> GetAllAsync(CancellationToken cancellationToken = default)
{
return await _routes.Where(r => !r.IsDeleted).ToListAsync(cancellationToken);
}
public virtual async Task<IList<GwRoute>> GetPagedAsync(int page, int pageSize,
public virtual async Task<IList<GwTenantRoute>> GetPagedAsync(int page, int pageSize, string? tenantCode = null,
string? serviceName = null, RouteStatus? status = null, CancellationToken cancellationToken = default)
{
var query = _routes.AsQueryable();
if (!string.IsNullOrEmpty(tenantCode))
query = query.Where(r => r.TenantCode.Contains(tenantCode));
if (!string.IsNullOrEmpty(serviceName))
query = query.Where(r => r.ServiceName.Contains(serviceName));
@ -56,11 +64,14 @@ public class RouteStore<TContext> : IRouteStore
.ToListAsync(cancellationToken);
}
public virtual async Task<int> GetCountAsync(string? serviceName = null,
public virtual async Task<int> GetCountAsync(string? tenantCode = null, string? serviceName = null,
RouteStatus? status = null, CancellationToken cancellationToken = default)
{
var query = _routes.AsQueryable();
if (!string.IsNullOrEmpty(tenantCode))
query = query.Where(r => r.TenantCode.Contains(tenantCode));
if (!string.IsNullOrEmpty(serviceName))
query = query.Where(r => r.ServiceName.Contains(serviceName));
@ -70,14 +81,14 @@ public class RouteStore<TContext> : IRouteStore
return await query.Where(r => !r.IsDeleted).CountAsync(cancellationToken);
}
public virtual async Task<IdentityResult> CreateAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual async Task<IdentityResult> CreateAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
{
_routes.Add(route);
await _context.SaveChangesAsync(cancellationToken);
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> UpdateAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual async Task<IdentityResult> UpdateAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
{
route.UpdatedTime = DateTime.UtcNow;
_routes.Update(route);
@ -85,7 +96,7 @@ public class RouteStore<TContext> : IRouteStore
return IdentityResult.Success;
}
public virtual async Task<IdentityResult> DeleteAsync(GwRoute route, CancellationToken cancellationToken = default)
public virtual async Task<IdentityResult> DeleteAsync(GwTenantRoute route, CancellationToken cancellationToken = default)
{
// 软删除
route.IsDeleted = true;

5
Fengling.Platform.Infrastructure/TenantStore.cs
View File

@ -1,7 +1,8 @@
using Microsoft.AspNetCore.Identity;
using Fengling.Platform.Domain.AggregatesModel.TenantAggregate;
namespace Fengling.Platform.Infrastructure;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Fengling.Platform.Domain.AggregatesModel.TenantAggregate;
public class TenantStore<TContext> : ITenantStore
where TContext : PlatformDbContext

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/Microsoft.Build.Locator.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.exe Executable file
View File

Binary file not shown.

56
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.exe.config Executable file
View File

@ -0,0 +1,56 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
</startup>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Framework" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Utilities.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Tasks.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.IO.Redist" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.1" newVersion="6.0.0.1" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections.Immutable" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-4.0.1.2" newVersion="4.0.1.2" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/Microsoft.IO.Redist.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/Newtonsoft.Json.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Buffers.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Collections.Immutable.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.CommandLine.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Memory.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Numerics.Vectors.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Runtime.CompilerServices.Unsafe.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/System.Threading.Tasks.Extensions.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/cs/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/de/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/es/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/fr/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/it/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/ja/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/ko/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/pl/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/pt-BR/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/ru/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/tr/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/zh-Hans/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-net472/zh-Hant/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Microsoft.Build.Locator.dll Executable file
View File

Binary file not shown.

260
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.deps.json Executable file
View File

@ -0,0 +1,260 @@
{
"runtimeTarget": {
"name": ".NETCoreApp,Version=v6.0",
"signature": ""
},
"compilationOptions": {},
"targets": {
".NETCoreApp,Version=v6.0": {
"Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost/4.14.0-3.25262.10": {
"dependencies": {
"Microsoft.Build.Locator": "1.6.10",
"Microsoft.CodeAnalysis.NetAnalyzers": "8.0.0-preview.23468.1",
"Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers": "3.3.4-beta1.22504.1",
"Microsoft.DotNet.XliffTasks": "9.0.0-beta.25255.5",
"Microsoft.VisualStudio.Threading.Analyzers": "17.13.2",
"Newtonsoft.Json": "13.0.3",
"Roslyn.Diagnostics.Analyzers": "3.11.0-beta1.24081.1",
"System.Collections.Immutable": "9.0.0",
"System.CommandLine": "2.0.0-beta4.24528.1"
},
"runtime": {
"Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.dll": {}
},
"resources": {
"cs/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "cs"
},
"de/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "de"
},
"es/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "es"
},
"fr/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "fr"
},
"it/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "it"
},
"ja/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "ja"
},
"ko/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "ko"
},
"pl/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "pl"
},
"pt-BR/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "pt-BR"
},
"ru/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "ru"
},
"tr/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "tr"
},
"zh-Hans/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "zh-Hans"
},
"zh-Hant/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.resources.dll": {
"locale": "zh-Hant"
}
}
},
"Microsoft.Build.Locator/1.6.10": {
"runtime": {
"lib/net6.0/Microsoft.Build.Locator.dll": {
"assemblyVersion": "1.0.0.0",
"fileVersion": "1.6.10.57384"
}
}
},
"Microsoft.CodeAnalysis.BannedApiAnalyzers/3.11.0-beta1.24081.1": {},
"Microsoft.CodeAnalysis.NetAnalyzers/8.0.0-preview.23468.1": {},
"Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers/3.3.4-beta1.22504.1": {},
"Microsoft.CodeAnalysis.PublicApiAnalyzers/3.11.0-beta1.24081.1": {},
"Microsoft.DotNet.XliffTasks/9.0.0-beta.25255.5": {},
"Microsoft.VisualStudio.Threading.Analyzers/17.13.2": {},
"Newtonsoft.Json/13.0.3": {
"runtime": {
"lib/net6.0/Newtonsoft.Json.dll": {
"assemblyVersion": "13.0.0.0",
"fileVersion": "13.0.3.27908"
}
}
},
"Roslyn.Diagnostics.Analyzers/3.11.0-beta1.24081.1": {
"dependencies": {
"Microsoft.CodeAnalysis.BannedApiAnalyzers": "3.11.0-beta1.24081.1",
"Microsoft.CodeAnalysis.PublicApiAnalyzers": "3.11.0-beta1.24081.1"
}
},
"System.Collections.Immutable/9.0.0": {
"dependencies": {
"System.Memory": "4.5.5",
"System.Runtime.CompilerServices.Unsafe": "6.0.0"
},
"runtime": {
"lib/netstandard2.0/System.Collections.Immutable.dll": {
"assemblyVersion": "9.0.0.0",
"fileVersion": "9.0.24.52809"
}
}
},
"System.CommandLine/2.0.0-beta4.24528.1": {
"dependencies": {
"System.Memory": "4.5.5"
},
"runtime": {
"lib/netstandard2.0/System.CommandLine.dll": {
"assemblyVersion": "2.0.0.0",
"fileVersion": "2.0.24.52801"
}
},
"resources": {
"lib/netstandard2.0/cs/System.CommandLine.resources.dll": {
"locale": "cs"
},
"lib/netstandard2.0/de/System.CommandLine.resources.dll": {
"locale": "de"
},
"lib/netstandard2.0/es/System.CommandLine.resources.dll": {
"locale": "es"
},
"lib/netstandard2.0/fr/System.CommandLine.resources.dll": {
"locale": "fr"
},
"lib/netstandard2.0/it/System.CommandLine.resources.dll": {
"locale": "it"
},
"lib/netstandard2.0/ja/System.CommandLine.resources.dll": {
"locale": "ja"
},
"lib/netstandard2.0/ko/System.CommandLine.resources.dll": {
"locale": "ko"
},
"lib/netstandard2.0/pl/System.CommandLine.resources.dll": {
"locale": "pl"
},
"lib/netstandard2.0/pt-BR/System.CommandLine.resources.dll": {
"locale": "pt-BR"
},
"lib/netstandard2.0/ru/System.CommandLine.resources.dll": {
"locale": "ru"
},
"lib/netstandard2.0/tr/System.CommandLine.resources.dll": {
"locale": "tr"
},
"lib/netstandard2.0/zh-Hans/System.CommandLine.resources.dll": {
"locale": "zh-Hans"
},
"lib/netstandard2.0/zh-Hant/System.CommandLine.resources.dll": {
"locale": "zh-Hant"
}
}
},
"System.Memory/4.5.5": {},
"System.Runtime.CompilerServices.Unsafe/6.0.0": {}
}
},
"libraries": {
"Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost/4.14.0-3.25262.10": {
"type": "project",
"serviceable": false,
"sha512": ""
},
"Microsoft.Build.Locator/1.6.10": {
"type": "package",
"serviceable": true,
"sha512": "sha512-DJhCkTGqy1LMJzEmG/2qxRTMHwdPc3WdVoGQI5o5mKHVo4dsHrCMLIyruwU/NSvPNSdvONlaf7jdFXnAMuxAuA==",
"path": "microsoft.build.locator/1.6.10",
"hashPath": "microsoft.build.locator.1.6.10.nupkg.sha512"
},
"Microsoft.CodeAnalysis.BannedApiAnalyzers/3.11.0-beta1.24081.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-DH6L3rsbjppLrHM2l2/NKbnMaYd0NFHx2pjZaFdrVcRkONrV3i9FHv6Id8Dp6/TmjhXQsJVJJFbhhjkpuP1xxg==",
"path": "microsoft.codeanalysis.bannedapianalyzers/3.11.0-beta1.24081.1",
"hashPath": "microsoft.codeanalysis.bannedapianalyzers.3.11.0-beta1.24081.1.nupkg.sha512"
},
"Microsoft.CodeAnalysis.NetAnalyzers/8.0.0-preview.23468.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-ZhIvyxmUCqb8OiU/VQfxfuAmIB4lQsjqhMVYKeoyxzSI+d7uR5Pzx3ZKoaIhPizQ15wa4lnyD6wg3TnSJ6P4LA==",
"path": "microsoft.codeanalysis.netanalyzers/8.0.0-preview.23468.1",
"hashPath": "microsoft.codeanalysis.netanalyzers.8.0.0-preview.23468.1.nupkg.sha512"
},
"Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers/3.3.4-beta1.22504.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-2XRlqPAzVke7Sb80+UqaC7o57OwfK+tIr+aIOxrx41RWDMeR2SBUW7kL4sd6hfLFfBNsLo3W5PT+UwfvwPaOzA==",
"path": "microsoft.codeanalysis.performancesensitiveanalyzers/3.3.4-beta1.22504.1",
"hashPath": "microsoft.codeanalysis.performancesensitiveanalyzers.3.3.4-beta1.22504.1.nupkg.sha512"
},
"Microsoft.CodeAnalysis.PublicApiAnalyzers/3.11.0-beta1.24081.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-3bYGBihvoNO0rhCOG1U9O50/4Q8suZ+glHqQLIAcKvnodSnSW+dYWYzTNb1UbS8pUS8nAUfxSFMwuMup/G5DtQ==",
"path": "microsoft.codeanalysis.publicapianalyzers/3.11.0-beta1.24081.1",
"hashPath": "microsoft.codeanalysis.publicapianalyzers.3.11.0-beta1.24081.1.nupkg.sha512"
},
"Microsoft.DotNet.XliffTasks/9.0.0-beta.25255.5": {
"type": "package",
"serviceable": true,
"sha512": "sha512-bb0fZB5ViPscdfYeWlmtyXJMzNkgcpkV5RWmXktfV9lwIUZgNZmFotUXrdcTyZzrN7v1tQK/Y6BGnbkP9gEsXg==",
"path": "microsoft.dotnet.xlifftasks/9.0.0-beta.25255.5",
"hashPath": "microsoft.dotnet.xlifftasks.9.0.0-beta.25255.5.nupkg.sha512"
},
"Microsoft.VisualStudio.Threading.Analyzers/17.13.2": {
"type": "package",
"serviceable": true,
"sha512": "sha512-Qcd8IlaTXZVq3wolBnzby1P7kWihdWaExtD8riumiKuG1sHa8EgjV/o70TMjTaeUMhomBbhfdC9OPwAHoZfnjQ==",
"path": "microsoft.visualstudio.threading.analyzers/17.13.2",
"hashPath": "microsoft.visualstudio.threading.analyzers.17.13.2.nupkg.sha512"
},
"Newtonsoft.Json/13.0.3": {
"type": "package",
"serviceable": true,
"sha512": "sha512-HrC5BXdl00IP9zeV+0Z848QWPAoCr9P3bDEZguI+gkLcBKAOxix/tLEAAHC+UvDNPv4a2d18lOReHMOagPa+zQ==",
"path": "newtonsoft.json/13.0.3",
"hashPath": "newtonsoft.json.13.0.3.nupkg.sha512"
},
"Roslyn.Diagnostics.Analyzers/3.11.0-beta1.24081.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-reHqZCDKifA+DURcL8jUfYkMGL4FpgNt5LI0uWTS6IpM8kKVbu/kO8byZsqfhBu4wUzT3MBDcoMfzhZPdENIpg==",
"path": "roslyn.diagnostics.analyzers/3.11.0-beta1.24081.1",
"hashPath": "roslyn.diagnostics.analyzers.3.11.0-beta1.24081.1.nupkg.sha512"
},
"System.Collections.Immutable/9.0.0": {
"type": "package",
"serviceable": true,
"sha512": "sha512-QhkXUl2gNrQtvPmtBTQHb0YsUrDiDQ2QS09YbtTTiSjGcf7NBqtYbrG/BE06zcBPCKEwQGzIv13IVdXNOSub2w==",
"path": "system.collections.immutable/9.0.0",
"hashPath": "system.collections.immutable.9.0.0.nupkg.sha512"
},
"System.CommandLine/2.0.0-beta4.24528.1": {
"type": "package",
"serviceable": true,
"sha512": "sha512-Xt8tsSU8yd0ZpbT9gl5DAwkMYWLo8PV1fq2R/belrUbHVVOIKqhLfbWksbdknUDpmzMHZenBtD6AGAp9uJTa2w==",
"path": "system.commandline/2.0.0-beta4.24528.1",
"hashPath": "system.commandline.2.0.0-beta4.24528.1.nupkg.sha512"
},
"System.Memory/4.5.5": {
"type": "package",
"serviceable": true,
"sha512": "sha512-XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw==",
"path": "system.memory/4.5.5",
"hashPath": "system.memory.4.5.5.nupkg.sha512"
},
"System.Runtime.CompilerServices.Unsafe/6.0.0": {
"type": "package",
"serviceable": true,
"sha512": "sha512-/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg==",
"path": "system.runtime.compilerservices.unsafe/6.0.0",
"hashPath": "system.runtime.compilerservices.unsafe.6.0.0.nupkg.sha512"
}
}
}

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.dll Executable file
View File

Binary file not shown.

605
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.dll.config Executable file
View File

@ -0,0 +1,605 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Framework" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Utilities.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Build.Tasks.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-15.1.0.0" newVersion="15.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections.Immutable" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.VisualBasic.Core" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-11.0.0.0" newVersion="11.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Win32.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Microsoft.Win32.Registry" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Buffers" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections.Concurrent" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections.NonGeneric" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections.Specialized" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Collections" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ComponentModel.Annotations" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ComponentModel.EventBasedAsync" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ComponentModel.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ComponentModel.TypeConverter" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ComponentModel" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Console" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Data.Common" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.Contracts" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.FileVersionInfo" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.Process" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.StackTrace" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.TextWriterTraceListener" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.TraceSource" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Diagnostics.Tracing" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Drawing.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.Compression.ZipFile" publicKeyToken="b77a5c561934e089" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.Compression" publicKeyToken="b77a5c561934e089" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.FileSystem.AccessControl" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.FileSystem.DriveInfo" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.FileSystem.Watcher" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.IsolatedStorage" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.MemoryMappedFiles" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.Pipes.AccessControl" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.IO.Pipes" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Linq.Expressions" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Linq.Parallel" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Linq.Queryable" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Linq" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.HttpListener" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Mail" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.NameResolution" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.NetworkInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Ping" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Requests" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Security" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.ServicePoint" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.Sockets" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.WebClient" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.WebHeaderCollection" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.WebProxy" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.WebSockets.Client" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Net.WebSockets" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Numerics.Vectors" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.ObjectModel" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Reflection.Emit.ILGeneration" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Reflection.Emit.Lightweight" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Reflection.Emit" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Reflection.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Resources.Writer" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.CompilerServices.VisualC" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.InteropServices.RuntimeInformation" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.InteropServices" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Numerics" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Serialization.Formatters" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Serialization.Json" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Serialization.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime.Serialization.Xml" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Runtime" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.AccessControl" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Claims" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Algorithms" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Cng" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Csp" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Encoding" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Primitives" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.X509Certificates" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Principal.Windows" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Text.Encoding.Extensions" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Text.RegularExpressions" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Threading.Overlapped" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Threading.Tasks.Parallel" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Threading.Thread" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Threading.ThreadPool" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Threading" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Transactions.Local" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Web.HttpUtility" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Xml.ReaderWriter" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Xml.XDocument" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Xml.XPath.XDocument" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Xml.XPath" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Xml.XmlSerializer" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="netstandard" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-2.1.0.0" newVersion="2.1.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Configuration.ConfigurationManager" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.Security.Cryptography.Xml" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="System.CodeDom" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
<bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

13
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost.runtimeconfig.json Executable file
View File

@ -0,0 +1,13 @@
{
"runtimeOptions": {
"tfm": "net6.0",
"framework": {
"name": "Microsoft.NETCore.App",
"version": "6.0.0"
},
"rollForward": "Major",
"configProperties": {
"System.Reflection.Metadata.MetadataUpdater.IsSupported": false
}
}
}

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/Newtonsoft.Json.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/System.Collections.Immutable.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/System.CommandLine.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/cs/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/de/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/es/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/fr/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/it/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/ja/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/ko/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/pl/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/pt-BR/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/ru/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/tr/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/zh-Hans/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

BIN
Fengling.Platform.Infrastructure/bin\Debug/net10.0/BuildHost-netcore/zh-Hant/System.CommandLine.resources.dll Executable file
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More