Cursor rule

1---
2description: 服务(Service)
3globs: 
4---
5# 服务(Service)
6 
7我们一般将业务逻辑写在`Service`层，`Controller`层只做参数校验、数据转换等操作，`Service`层做具体的业务逻辑处理。
8 
9`cool-admin`对基本的`Service`进行封装；
10 
11## 重写 CRUD
12 
13`Controller`的六个快速方法，`add`、`update`、`delete`、`info`、`list`、`page`，是通过调用一个通用的`BaseService`的方法实现，所以我们可以重写`Service`的方法来实现自己的业务逻辑。
14 
15**示例**
16 
17重写 add 方法
18 
19```ts
20import { DemoGoodsEntity } from "./../entity/goods";
21import { Provide } from "@midwayjs/core";
22import { BaseService } from "@cool-midway/core";
23import { InjectEntityModel } from "@midwayjs/typeorm";
24import { Repository } from "typeorm";
25 
26/**
27 * 商品示例
28 */
29@Provide()
30export class DemoGoodsService extends BaseService {
31	@InjectEntityModel(DemoGoodsEntity)
32	demoGoodsEntity: Repository<DemoGoodsEntity>;
33 
34	/**
35	 * 新增
36	 * @param param
37	 * @returns
38	 */
39	async add(param: any) {
40		// 调用原本的add，如果不需要可以不用这样写，完全按照自己的新增逻辑写
41		const result = await super.add(param);
42		// 你自己的业务逻辑
43		return result;
44	}
45}
46```
47 
48记得在`Controller`上配置对应的`Service`才会使其生效
49 
50```ts
51import { DemoGoodsService } from "../../service/goods";
52import { DemoGoodsEntity } from "../../entity/goods";
53import { Body, Inject, Post, Provide } from "@midwayjs/core";
54import { CoolController, BaseController } from "@cool-midway/core";
55import { InjectEntityModel } from "@midwayjs/typeorm";
56import { Repository } from "typeorm";
57 
58/**
59 * 测试
60 */
61@Provide()
62@CoolController({
63	api: ["add", "delete", "update", "info", "list", "page"],
64	entity: DemoGoodsEntity,
65	service: DemoGoodsService
66})
67export class AppDemoGoodsController extends BaseController {}
68```
69 
70## 普通查询(TypeOrm)
71 
72普通查询基于[TypeOrm](mdc:https:/typeorm.io)，点击查看官方详细文档
73 
74**示例**
75 
76```ts
77import { DemoGoodsEntity } from "./../entity/goods";
78import { Provide } from "@midwayjs/core";
79import { BaseService } from "@cool-midway/core";
80import { InjectEntityModel } from "@midwayjs/typeorm";
81import { In, Repository } from "typeorm";
82 
83/**
84 * 商品示例
85 */
86@Provide()
87export class DemoGoodsService extends BaseService {
88	@InjectEntityModel(DemoGoodsEntity)
89	demoGoodsEntity: Repository<DemoGoodsEntity>;
90 
91	async typeorm() {
92		// 新增单个，传入的参数字段在数据库中一定要存在
93		await this.demoGoodsEntity.insert({ title: "xxx" });
94		// 新增单个，传入的参数字段在数据库中可以不存在
95		await this.demoGoodsEntity.save({ title: "xxx" });
96		// 新增多个
97		await this.demoGoodsEntity.save([{ title: "xxx" }]);
98		// 查找单个
99		await this.demoGoodsEntity.findOneBy({ id: 1 });
100		// 查找多个
101		await this.demoGoodsEntity.findBy({ id: In([1, 2]) });
102		// 删除单个
103		await this.demoGoodsEntity.delete(1);
104		// 删除多个
105		await this.demoGoodsEntity.delete([1]);
106		// 根据ID更新
107		await this.demoGoodsEntity.update(1, { title: "xxx" });
108		// 根据条件更新
109		await this.demoGoodsEntity.update({ price: 20 }, { title: "xxx" });
110		// 多条件操作
111		await this.demoGoodsEntity
112			.createQueryBuilder()
113			.where("id = :id", { id: 1 })
114			.andWhere("price = :price", { price: 20 })
115			.getOne();
116	}
117}
118```
119 
120## 高级查询(SQL)
121 
122**1、普通 SQL 查询**
123 
124```ts
125import { DemoGoodsEntity } from "./../entity/goods";
126import { Provide } from "@midwayjs/core";
127import { BaseService } from "@cool-midway/core";
128import { InjectEntityModel } from "@midwayjs/typeorm";
129import { Repository } from "typeorm";
130 
131/**
132 * 商品示例
133 */
134@Provide()
135export class DemoGoodsService extends BaseService {
136	@InjectEntityModel(DemoGoodsEntity)
137	demoGoodsEntity: Repository<DemoGoodsEntity>;
138 
139	/**
140	 * 执行sql
141	 */
142	async sql(query) {
143		return this.nativeQuery("select * from demo_goods a where a.id = ?", [query.id]);
144	}
145}
146```
147 
148**2、分页 SQL 查询**
149 
150```ts
151import { DemoGoodsEntity } from "./../entity/goods";
152import { Provide } from "@midwayjs/core";
153import { BaseService } from "@cool-midway/core";
154import { InjectEntityModel } from "@midwayjs/typeorm";
155import { Repository } from "typeorm";
156 
157/**
158 * 商品示例
159 */
160@Provide()
161export class DemoGoodsService extends BaseService {
162	@InjectEntityModel(DemoGoodsEntity)
163	demoGoodsEntity: Repository<DemoGoodsEntity>;
164 
165	/**
166	 * 执行分页sql
167	 */
168	async sqlPage(query) {
169		return this.sqlRenderPage("select * from demo_goods ORDER BY id ASC", query, false);
170	}
171}
172```
173 
174**3、非 SQL 的分页查询**
175 
176```ts
177import { DemoGoodsEntity } from "./../entity/goods";
178import { Provide } from "@midwayjs/core";
179import { BaseService } from "@cool-midway/core";
180import { InjectEntityModel } from "@midwayjs/typeorm";
181import { In, Repository } from "typeorm";
182 
183/**
184 * 商品示例
185 */
186@Provide()
187export class DemoGoodsService extends BaseService {
188	@InjectEntityModel(DemoGoodsEntity)
189	demoGoodsEntity: Repository<DemoGoodsEntity>;
190 
191	/**
192	 * 执行entity分页
193	 */
194	async entityPage(query) {
195		const find = this.demoGoodsEntity.createQueryBuilder();
196		find.where("id = :id", { id: 1 });
197		return this.entityRenderPage(find, query);
198	}
199}
200```
201 
202**4、SQL 动态条件**
203 
204分页查询和普通的 SQL 查询都支持动态条件，通过`this.setSql(条件,sql语句,参数)`来配置
205 
206```ts
207import { DemoGoodsEntity } from "./../entity/goods";
208import { Provide } from "@midwayjs/core";
209import { BaseService } from "@cool-midway/core";
210import { InjectEntityModel } from "@midwayjs/typeorm";
211import { Repository } from "typeorm";
212 
213/**
214 * 商品示例
215 */
216@Provide()
217export class DemoGoodsService extends BaseService {
218	@InjectEntityModel(DemoGoodsEntity)
219	demoGoodsEntity: Repository<DemoGoodsEntity>;
220 
221	/**
222	 * 执行sql
223	 */
224	async sql(query) {
225		return this.nativeQuery(`
226    select * from demo_goods a
227      WHERE 1=1
228      ${this.setSql(query.id, "and a.id = ?", [query.id])}
229    ORDER BY id ASC
230    `);
231	}
232}
233```
234 
235## 修改之前(modifyBefore)
236 
237有时候我们需要在数据进行修改动作之前，对它进行一些处理，比如：修改密码时，需要对密码进行加密，这时候我们可以使用`modifyBefore`方法来实现
238 
239```ts
240import { DemoGoodsEntity } from "./../entity/goods";
241import { Provide } from "@midwayjs/core";
242import { BaseService } from "@cool-midway/core";
243import { InjectEntityModel } from "@midwayjs/typeorm";
244import { Repository } from "typeorm";
245import * as md5 from "md5";
246 
247/**
248 * 商品示例
249 */
250@Provide()
251export class DemoGoodsService extends BaseService {
252	@InjectEntityModel(DemoGoodsEntity)
253	demoGoodsEntity: Repository<DemoGoodsEntity>;
254 
255	/**
256	 * 修改之前
257	 * @param data
258	 * @param type
259	 */
260	async modifyBefore(data: any, type: "delete" | "update" | "add") {
261		if (type == "update") {
262			data.password = md5(data.password);
263		}
264	}
265}
266```
267 
268## 修改之后(modifyAfter)
269 
270有时候我们需要在数据进行修改动作之后，对它进行一些处理，比如：修改完数据之后将它放入队列或者 ElasticSearch
271 
272```ts
273import { DemoGoodsEntity } from "./../entity/goods";
274import { Provide } from "@midwayjs/core";
275import { BaseService } from "@cool-midway/core";
276import { InjectEntityModel } from "@midwayjs/typeorm";
277import { Repository } from "typeorm";
278import * as md5 from "md5";
279 
280/**
281 * 商品示例
282 */
283@Provide()
284export class DemoGoodsService extends BaseService {
285	@InjectEntityModel(DemoGoodsEntity)
286	demoGoodsEntity: Repository<DemoGoodsEntity>;
287 
288	/**
289	 * 修改之后
290	 * @param data
291	 * @param type
292	 */
293	async modifyAfter(data: any, type: "delete" | "update" | "add") {
294		// 你想做的其他事情
295	}
296}
297```
298 
299## 设置实体
300 
301`Service`与`Service`之间相互调用`BaseService`里的方法，有可能出现“未设置操作实体”的问题可以通过以下方式设置实体
302 
303::: warning 建议
304但是一般不建议这样做，因为这样会导致`Service`与`Service`耦合，不利于代码的维护，如果要操作对应的表直接在当前的`Service`注入对应的表操作即可
305:::
306 
307```ts
308@Provide()
309export class XxxService extends BaseService {
310	@InjectEntityModel(XxxEntity)
311	xxxEntity: Repository<XxxEntity>;
312 
313	@Init()
314	async init() {
315		await super.init();
316		// 设置实体
317		this.setEntity(this.xxxEntity);
318	}
319}
320```
321