perf: 支持自动选择校验方式申请证书

packages/ui/certd-server/src/modules/pipeline/service/getter/domain-verifier-getter.ts

@@ -0,0 +1,17 @@
+import {DomainVerifiers, IDomainVerifierGetter} from "@certd/plugin-cert";
+import {DomainService} from "../../../cert/service/domain-service.js";
+
+export class DomainVerifierGetter implements IDomainVerifierGetter {
+  private userId: number;
+  private domainService: DomainService;
+
+  constructor(userId: number, domainService: DomainService) {
+    this.userId = userId;
+    this.domainService = domainService;
+  }
+
+  async getVerifiers(domains: string[]): Promise<DomainVerifiers>{
+    return await this.domainService.getDomainVerifiers(this.userId,domains);
+  }
+
+}

packages/ui/certd-server/src/modules/pipeline/service/getter/notification-getter.ts

@@ -1,5 +1,5 @@
 import { INotificationService, NotificationSendReq } from '@certd/pipeline';
-import { NotificationService } from './notification-service.js';
+import {NotificationService} from "../notification-service.js";
 
 export class NotificationGetter implements INotificationService {
   userId: number;

packages/ui/certd-server/src/modules/pipeline/service/getter/sub-domain-getter.ts

@@ -0,0 +1,17 @@
+import {ISubDomainsGetter} from "@certd/plugin-cert";
+import {SubDomainService} from "../service/sub-domain-service.js";
+
+export class SubDomainsGetter implements ISubDomainsGetter {
+  userId: number;
+  subDomainService: SubDomainService;
+
+  constructor(userId: number, subDomainService: SubDomainService) {
+    this.userId = userId;
+    this.subDomainService = subDomainService;
+  }
+
+  async getSubDomains() {
+    return await this.subDomainService.getListByUserId(this.userId)
+  }
+
+}

packages/ui/certd-server/src/modules/pipeline/service/getter/task-service-getter.ts

@@ -0,0 +1,81 @@
+import {IServiceGetter} from "@certd/pipeline";
+import {Inject, Provide, Scope, ScopeEnum} from "@midwayjs/core";
+import {SubDomainService} from "../sub-domain-service.js";
+import {AccessGetter, AccessService} from "@certd/lib-server";
+import {CnameProxyService} from "./cname-proxy-service.js";
+import {NotificationGetter} from "./notification-getter.js";
+import {NotificationService} from "../notification-service.js";
+import {CnameRecordService} from "../../../cname/service/cname-record-service.js";
+import {SubDomainsGetter} from './sub-domain-getter.js'
+import {DomainVerifierGetter} from "./domain-verifier-getter.js";
+import {Context} from "@midwayjs/koa";
+import {DomainService} from "../../../cert/service/domain-service.js";
+
+export class TaskServiceGetter implements IServiceGetter{
+  private userId: number;
+  private ctx : Context;
+  constructor(userId:number,ctx:Context) {
+    this.userId = userId;
+    this.ctx = ctx
+  }
+  async get<T>(serviceName: string): Promise<T> {
+
+    if(serviceName === 'subDomainsGetter'){
+      return await this.getSubDomainsGetter() as T
+    } if (serviceName === 'accessService') {
+      return await this.getAccessService() as T
+    } else if (serviceName === 'cnameProxyService') {
+      return await this.getCnameProxyService() as T
+    } else if (serviceName === 'notificationService') {
+      return await this.getNotificationService() as T
+    } else if (serviceName === 'domainVerifierGetter') {
+      return await this.getDomainVerifierGetter() as T
+    }else{
+      throw new Error(`service ${serviceName} not found`)
+    }
+  }
+
+  async getSubDomainsGetter(): Promise<SubDomainsGetter> {
+    const subDomainsService = await  this.ctx.requestContext.getAsync("subDomainService")
+    return new SubDomainsGetter(this.userId, subDomainsService)
+  }
+
+  async getAccessService(): Promise<AccessGetter> {
+    const accessService:AccessService = await  this.ctx.requestContext.getAsync("accessService")
+    return new AccessGetter(this.userId, accessService.getById.bind(accessService));
+  }
+
+  async getCnameProxyService(): Promise<CnameProxyService> {
+    const cnameRecordService:CnameRecordService = await  this.ctx.requestContext.getAsync("cnameRecordService")
+    return new CnameProxyService(this.userId, cnameRecordService.getWithAccessByDomain.bind(cnameRecordService));
+  }
+
+  async getNotificationService(): Promise<NotificationGetter> {
+    const notificationService:NotificationService = await  this.ctx.requestContext.getAsync("notificationService")
+    return new NotificationGetter(this.userId, notificationService);
+  }
+
+  async getDomainVerifierGetter(): Promise<DomainVerifierGetter> {
+    const domainService:DomainService = await  this.ctx.requestContext.getAsync("domainService")
+    return new DomainVerifierGetter(this.userId, domainService);
+  }
+}
+export type TaskServiceCreateReq = {
+  userId: number;
+}
+
+@Provide()
+@Scope(ScopeEnum.Request, { allowDowngrade: true })
+export class TaskServiceBuilder  {
+  @Inject()
+  ctx: Context;
+
+  create(req:TaskServiceCreateReq){
+    const userId = req.userId;
+    return new TaskServiceGetter(userId,this.ctx)
+  }
+}
+
+
+
+

packages/ui/certd-server/src/modules/pipeline/service/pipeline-service.ts

@@ -44,7 +44,7 @@ import {UrlService} from "./url-service.js";
 import {NotificationService} from "./notification-service.js";
 import {UserSuiteEntity, UserSuiteService} from "@certd/commercial-core";
 import {CertInfoService} from "../../monitor/service/cert-info-service.js";
-import {TaskServiceBuilder} from "./task-service-getter.js";
+import {TaskServiceBuilder} from "./getter/task-service-getter.js";
 import {nanoid} from "nanoid";
 import {set} from "lodash-es";
 

packages/ui/certd-server/src/modules/pipeline/service/sub-domain-service.ts

@@ -4,7 +4,6 @@ import {InjectEntityModel} from '@midwayjs/typeorm';
 import {Repository} from 'typeorm';
 import {SubDomainEntity} from '../entity/sub-domain.js';
 import {EmailService} from '../../basic/service/email-service.js';
-import {ISubDomainsGetter} from "@certd/plugin-cert";
 
 @Provide()
 @Scope(ScopeEnum.Request, { allowDowngrade: true })
@@ -38,21 +37,3 @@ export class SubDomainService extends BaseService<SubDomainEntity> {
   }
 
 }
-
-
-
-
-export class SubDomainsGetter implements ISubDomainsGetter {
-  userId: number;
-  subDomainService: SubDomainService;
-
-  constructor(userId: number, subDomainService: SubDomainService) {
-    this.userId = userId;
-    this.subDomainService = subDomainService;
-  }
-
-  async getSubDomains() {
-    return await this.subDomainService.getListByUserId(this.userId)
-  }
-
-}

packages/ui/certd-server/src/modules/pipeline/service/task-service-getter.ts

@@ -1,63 +0,0 @@
-import {IServiceGetter} from "@certd/pipeline";
-import {Inject, Provide, Scope, ScopeEnum} from "@midwayjs/core";
-import {SubDomainService, SubDomainsGetter} from "./sub-domain-service.js";
-import {AccessGetter, AccessService} from "@certd/lib-server";
-import {CnameProxyService} from "./cname-proxy-service.js";
-import {NotificationGetter} from "./notification-getter.js";
-import {NotificationService} from "./notification-service.js";
-import {CnameRecordService} from "../../cname/service/cname-record-service.js";
-
-export class TaskServiceGetter implements IServiceGetter{
-  serviceContainer:Record<string, any>;
-  constructor(serviceContainer:Record<string, any>) {
-    this.serviceContainer = serviceContainer;
-  }
-  async get<T>(serviceName: string): Promise<T> {
-    const ret = this.serviceContainer[serviceName] as T;
-    if(!ret){
-      throw new Error(`service ${serviceName} not found`)
-    }
-    return ret
-  }
-}
-export type TaskServiceCreateReq = {
-  userId: number;
-}
-
-export type TaskServiceContainer = {
-  subDomainsGetter:SubDomainsGetter;
-  accessService: AccessGetter;
-  cnameProxyService: CnameProxyService;
-  notificationService: NotificationGetter;
-}
-
-@Provide()
-@Scope(ScopeEnum.Request, { allowDowngrade: true })
-export class TaskServiceBuilder  {
-
-  @Inject()
-  subDomainService: SubDomainService;
-  @Inject()
-  accessService: AccessService;
-  @Inject()
-  cnameRecordService: CnameRecordService;
-  @Inject()
-  notificationService: NotificationService;
-
-
-  create(req:TaskServiceCreateReq){
-
-    const userId = req.userId;
-    const accessGetter = new AccessGetter(userId, this.accessService.getById.bind(this.accessService));
-    const cnameProxyService = new CnameProxyService(userId, this.cnameRecordService.getWithAccessByDomain.bind(this.cnameRecordService));
-    const notificationGetter = new NotificationGetter(userId, this.notificationService);
-
-    const serviceContainer:TaskServiceContainer = {
-      subDomainsGetter:new SubDomainsGetter(req.userId, this.subDomainService),
-      accessService: accessGetter,
-      cnameProxyService:cnameProxyService,
-      notificationService:notificationGetter
-    }
-    return new TaskServiceGetter(serviceContainer)
-  }
-}