Compare commits

...

10 Commits

Author SHA1 Message Date
sugarBecomer 02737ef743 🐛 销假 2025-12-08 10:44:29 +08:00
sugarBecomer 74a1134cf1 🐛 邮件调整 2025-12-08 10:03:21 +08:00
sugarBecomer b6f777f997 🐛 调整任务执行 2025-12-08 09:55:50 +08:00
sugarBecomer 2dc233631e 🐛 调整任务执行 2025-12-08 09:55:27 +08:00
sugarBecomer 0c60eb5ae4 🐛 销假 2025-12-07 22:37:28 +08:00
sugarBecomer 450c026a6f 🐛 销假 2025-12-06 21:58:51 +08:00
sugarBecomer d9d6acee5f 🐛 销假 2025-12-06 15:12:43 +08:00
sugarBecomer 164d8956de 🐛 销假 & 学习通 2025-12-06 15:10:47 +08:00
sugarBecomer 3f1a08374e 🐛 日志格式 & 邮箱错误处理 2025-12-06 12:53:52 +08:00
sugarBecomer 334d597f9a 🐛 邮箱发送失败 2025-12-06 12:34:12 +08:00
19 changed files with 379 additions and 1139 deletions
+4 -4
View File
@@ -29,10 +29,10 @@ url = "redis://:jhkdjhkjdhsIUTYURTU_pEGmFP@database.out:56379"
smtpHost = "smtp-mail.outlook.com"
smtpPort = 587
# 发件人邮箱和密码(需要使用授权码,不是登录密码)
smtpUsername = "demo@likedream.xyz"
smtpUsername = "reply@likedream.xyz"
smtpPassword = "baca122..."
# 发件人邮箱和显示名称
fromEmail = "demo@likedream.xyz"
fromEmail = "reply@likedream.xyz"
fromName = "若梦系统"
@@ -43,7 +43,7 @@ baseUrl = "http://s3.out"
bucket = "likedream"
[cpdaily]
appVersion = "9.7.2"
appVersion = "9.8.8"
systemVersion = "iOS 17"
calVersion = "firstv"
sliderIds = ["1018764144934965", "sdhyxy", "hqdx"]
@@ -55,4 +55,4 @@ cpdailyTask = "0.5"
cpdailyLeave = "4"
cpdailyPhone = "0.25"
[task]
concurrency = 20
concurrency = 80
-403
View File
@@ -1,403 +0,0 @@
# 刷课接口文档
## 接口列表
### 1. 获取刷课列表
**接口地址**: `GET /course`
**请求参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| type | string | 否 | 类型,可选值:`xxt`(学习通) |
| username | string | 否 | 账号(模糊搜索) |
| status | string | 否 | 状态,可选值:`not_start`(未开始)、`waiting`(等待中)、`doing`(进行中)、`done`(已完成)、`fail`(失败)、`pause`(暂停) |
| page | int | 否 | 页码,默认 1 |
| size | int | 否 | 每页数量,默认 10 |
**返回示例**:
```json
{
"code": 200,
"message": "success",
"data": [
{
"id": 1,
"user_id": 1,
"username": "学习通账号",
"password": "",
"type": "xxt",
"course_name": "大学英语",
"course_id": "123456",
"need": "task",
"status": "waiting",
"task_count": 10,
"success_count": 5,
"exam_state": "not_start",
"violence": "no",
"desc": "备注信息",
"create_time": "2024-01-01T00:00:00Z",
"update_time": "2024-01-01T00:00:00Z"
}
],
"total": 100
}
```
**字段说明**:
- `type`: 类型 - `xxt`(学习通)
- `need`: 需要刷的内容 - `task`(任务点)、`exam`(考试)、`all`(全部)
- `status`: 状态 - `not_start`(未开始)、`waiting`(等待中)、`doing`(进行中)、`done`(已完成)、`fail`(失败)、`pause`(暂停)
- `exam_state`: 考试状态 - `not_start`(未开始)、`waiting`(等待中)、`doing`(进行中)、`done`(已完成)、`fail`(失败)
- `violence`: 是否暴力刷课 - `no`(否)、`yes`(是)
---
### 2. 查询课程列表
**接口地址**: `POST /course/query`
**说明**: 通过学习通账号密码查询当前可选的课程列表,用于在添加刷课前选择课程。
**请求参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| username | string | 是 | 学习通账号 |
| password | string | 是 | 学习通密码 |
**请求示例**:
```json
{
"username": "学习通账号",
"password": "学习通密码"
}
```
**返回示例**:
```json
{
"code": 200,
"message": "success",
"data": [
{
"cpi": 123456,
"key": "234567",
"courseId": "345678",
"chatId": "456789",
"courseTeacher": "张老师",
"courseName": "大学英语",
"courseImage": "https://example.com/image.jpg",
"courseImageBase64": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAA...",
"courseDataId": 567890,
"ContentID": 678901,
"isstart": true,
"state": 0
}
]
}
```
**字段说明**:
- `cpi`: 用户唯一标识
- `key`: 课程班级ID(classId)
- `courseId`: 课程ID(**添加刷课时需要使用**)
- `chatId`: 聊天ID
- `courseTeacher`: 授课教师
- `courseName`: 课程名称(**添加刷课时需要使用**)
- `courseImage`: 课程封面图片URL
- `courseImageBase64`: 课程封面图片Base64编码(包含Data URL前缀,可直接用于img标签的src属性)
- `courseDataId`: 课程数据ID
- `ContentID`: 内容ID
- `isstart`: 是否已开课(true:已开课,false:未开课)
- `state`: 课程状态(0:正常,1:已结束)
**注意事项**:
- `courseImageBase64` 字段已经包含了 Data URL 前缀(如 `data:image/jpeg;base64,`),可以直接设置到 `<img>` 标签的 `src` 属性
- 如果图片下载失败,`courseImageBase64` 字段将为空字符串,此时可以使用 `courseImage` URL 作为备用
**错误示例**:
```json
{
"code": 400,
"message": "登录失败,请检查账号密码",
"data": null
}
```
---
### 3. 添加刷课
**接口地址**: `POST /course`
**请求参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| username | string | 是 | 学习通账号 |
| password | string | 是 | 学习通密码 |
| type | string | 是 | 类型,目前只支持 `xxt`(学习通) |
| course_name | string | 是 | 课程名称 |
| course_id | string | 是 | 课程ID |
| need | string | 是 | 需要刷的内容,可选值:`task`(任务点)、`exam`(考试)、`all`(全部) |
| violence | string | 否 | 是否暴力刷课,可选值:`no`(否,默认)、`yes`(是) |
| desc | string | 否 | 备注信息 |
**请求示例**:
```json
{
"username": "学习通账号",
"password": "学习通密码",
"type": "xxt",
"course_name": "大学英语",
"course_id": "123456",
"need": "task",
"violence": "no",
"desc": "备注信息"
}
```
**返回示例**:
```json
{
"code": 200,
"message": "添加成功",
"data": null
}
```
**错误示例**:
```json
{
"code": 400,
"message": "该课程已存在刷课任务",
"data": null
}
```
---
### 4. 修改刷课密码
**接口地址**: `PUT /course/password/{id}`
**路径参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| id | int64 | 是 | 刷课任务ID |
**请求参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| password | string | 是 | 新密码 |
**请求示例**:
```json
{
"password": "新密码"
}
```
**返回示例**:
```json
{
"code": 200,
"message": "密码修改成功",
"data": null
}
```
**错误示例**:
```json
{
"code": 400,
"message": "课程不存在或无权限操作",
"data": null
}
```
---
### 5. 重刷课程
**接口地址**: `POST /course/restart/{id}`
**路径参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| id | int64 | 是 | 刷课任务ID |
**说明**: 只有状态为 `done`(已完成)的课程才能重刷,重刷后会重置课程状态、任务数量、成功数量和考试状态。
**返回示例**:
```json
{
"code": 200,
"message": "重刷成功",
"data": null
}
```
**错误示例**:
```json
{
"code": 400,
"message": "只有已完成的课程才能重刷",
"data": null
}
```
---
### 6. 暂停/恢复刷课
**接口地址**: `POST /course/pause/{id}`
**路径参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| id | int64 | 是 | 刷课任务ID |
**说明**: 该接口会在暂停和恢复之间切换:
- 如果当前状态是 `pause`(暂停),则恢复为 `waiting`(等待中)
- 如果当前状态不是暂停,则设置为 `pause`(暂停)
**返回示例(暂停)**:
```json
{
"code": 200,
"message": "已暂停刷课",
"data": null
}
```
**返回示例(恢复)**:
```json
{
"code": 200,
"message": "已恢复刷课",
"data": null
}
```
---
### 7. 删除刷课
**接口地址**: `DELETE /course/{id}`
**路径参数**:
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| id | int64 | 是 | 刷课任务ID |
**返回示例**:
```json
{
"code": 200,
"message": "删除成功",
"data": null
}
```
**错误示例**:
```json
{
"code": 400,
"message": "课程不存在或无权限操作",
"data": null
}
```
---
## 枚举值说明
### 类型 (type)
| 值 | 说明 |
|-----|------|
| xxt | 学习通 |
### 需要刷的内容 (need)
| 值 | 说明 |
|-----|------|
| task | 任务点 |
| exam | 考试 |
| all | 全部 |
### 状态 (status)
| 值 | 说明 |
|-----|------|
| not_start | 未开始 |
| waiting | 等待中 |
| doing | 进行中 |
| done | 已完成 |
| fail | 失败 |
| pause | 暂停 |
### 考试状态 (exam_state)
| 值 | 说明 |
|-----|------|
| not_start | 未开始 |
| waiting | 等待中 |
| doing | 进行中 |
| done | 已完成 |
| fail | 失败 |
### 是否暴力刷课 (violence)
| 值 | 说明 |
|-----|------|
| no | 否 |
| yes | 是 |
---
## 通用说明
### 认证
所有接口都需要用户认证,需要在请求头中携带认证信息(具体认证方式根据项目配置)。
### 权限
用户只能操作自己创建的刷课任务,无法访问或修改其他用户的数据。
### 错误码
| 错误码 | 说明 |
|--------|------|
| 200 | 成功 |
| 400 | 业务错误(如参数错误、权限不足等) |
| 401 | 未认证 |
| 500 | 服务器错误 |
+7 -4
View File
@@ -19,8 +19,11 @@ type GetLeaveListFromSystemReq struct {
}
type CpLeaveReportReq struct {
g.Meta `path:"/leave/report" method:"post" tags:"CpLeave" summary:"执行销假"`
CpUserId int64 `json:"cpUserId" v:"required#今日校园账号ID不能为空"`
LeaveId string `json:"leaveId" v:"required#请假记录ID不能为空"`
Title string `json:"title" v:"required#请假记录标题不能为空"`
g.Meta `path:"/leave/report" method:"post" tags:"CpLeave" summary:"执行销假"`
CpUserId int64 `json:"cpUserId" v:"required#今日校园账号ID不能为空"`
LeaveId string `json:"leaveId" v:"required#请假记录ID不能为空"`
Title string `json:"title" v:"required#请假记录标题不能为空"`
Longitude string `json:"longitude"` // 经度(可选,不传则使用系统默认)
Latitude string `json:"latitude"` // 纬度(可选,不传则使用系统默认)
Address string `json:"address"` // 地址(可选,不传则使用系统默认)
}
@@ -7,9 +7,9 @@ import (
)
func TestAesDecrypt(t *testing.T) {
str := "6XkC1UAk07fK0uTaGPUu77i/+r7j/o1JQ/XygRxee2LMiX5H+w/BOqOB6e7W o9kHDZMb1pqZNN43k1tjl0ephbPLEi8g9C1EqBw0suzxX74j3dUdCf6dd/0W 8KvntNXwju96Vy5B2oD2ZosLmUdB1m0xX5rxAdLJ//cTft87XDWoLM0fuasu fGvR4XXXYZN071x8F03+qqR52fD1UQGgn0uGkSa/nrUho32Sg7DNJzF/JBCk 6/z0lu0XmIPo1SDIVjOtYAmyUDMZGl/ZvSAu2w=="
str := "gTIjjNBTwN0Vdv2o5ZlTZ6gHbFcIA0MV0caRqvv/50tptfoSO+VASLxpQZWy Xa86lY21QtmXhwlvTsfd3XR819O0IUi2FynPOM6s0pDsSndM2JhhqoRNXBTK 4WqfMgt0RCQJ38KP8XtM5O+Ktkj1YHHM/OVEGqOxRcUh2M++JJCheJbSs+aQ 2T3va13/GWJH7PEd8JVEJgBiO3wXLOb9+CvvWuU/Frc9nNNxQL7LrgZTdQAv C9Yt+5/a2n41reOeOs7Bu5C4FFlHQSs71Rom/HtIhL67x1ecIre1rbgK9xxz 1AhTEHY6nhdZmktPGJD5CfxvLVWIeLv09CjKqdSaNodkP4e9YTScNEZ2s8TK y8Xhv8L0r6gllC9B3nla4GRe+lqMvhDPDZx7PFu7kxFspf9yoM4eOpgWfCr9 xbDwxO9cXphiktfWsQiX28W4g2jCFFEazh01WBtpjM9LsLfbBgZA+z3jgfYa AXZuOvFQMJuUnLyOIGPtsaSTwXFDlJwNRgEw+Ctl22JSJbbu1yOoM9S6Ge27 rUVMhbAS5snVbNbLhgAymQLQQVLRwfsMLbtUfLTZuCC8zO8d16eOYw56+DqR QWNG1EXQz3CLeFDs2hFqcNWrAt773qANQ3zLPA65"
str = strings.ReplaceAll(str, " ", "")
decodeString, _ := base64.StdEncoding.DecodeString(str)
decrypt := DesDecrypt(decodeString, Cat)
decrypt := AesDecryptForCat(decodeString)
t.Log(string(decrypt))
}
+30 -7
View File
@@ -10,6 +10,7 @@ import (
"likedream-goframe/internal/common/errors"
"likedream-goframe/internal/utils"
"github.com/bytedance/sonic"
"github.com/gogf/gf/v2/container/gvar"
"github.com/google/uuid"
"github.com/samber/oops"
@@ -74,6 +75,14 @@ func (c *CpdailyReportApp) GetLeaveList() []leavetype.LeaveListOne {
AceEndTime: row.Get("actEndTime").String(),
Status: row.Get("status").String(),
}
// 获取详情以填充位置信息
detail := c.LeaveDetail(leaveOne.Id)
lon, lat := c.GetLocation(detail)
leaveOne.Longitude = lon
leaveOne.Latitude = lat
leaveOne.Address = detail.Get("detail.applyLocation.address").String()
listList = append(listList, leaveOne)
}
return listList
@@ -104,16 +113,30 @@ func (c *CpdailyReportApp) LeaveDetail(leaveId string) gjson.Result {
return datas
}
type Attach struct {
Type string `json:"type"`
Url string `json:"url"`
}
func (c *CpdailyReportApp) FillReportForm(detail gjson.Result) map[string]*gvar.Var {
resultForm := make(map[string]*gvar.Var)
resultForm["id"] = gvar.New(detail.Get("detail.id").String())
resultForm["needApproval"] = gvar.New(1)
resultForm["leaveType"] = gvar.New(detail.Get("leaveType.code").Int())
resultForm["leaveType"] = gvar.New(detail.Get("leaveType.code").String())
resultForm["reportLocation"] = gvar.New(detail.Get("detail.applyLocation.address").String())
resultForm["approverWid"] = gvar.New("")
resultForm["reportApplyExplain"] = gvar.New(nil)
resultForm["reportAttach"] = gvar.New(detail.Get("detail.applyAttach").Array())
//resultForm["reportAttach"] = gvar.New(.Array())
resultForm["reportAttach"] = gvar.New([]string{})
resultForm["uaIsCpadaily"] = gvar.New(true)
attachStr := detail.Get("detail.applyAttach").String()
if attachStr != "" {
var attach []Attach
_ = sonic.Unmarshal([]byte(attachStr), &attach)
resultForm["reportAttach"] = gvar.New(attach)
} else {
resultForm["reportAttach"] = gvar.New([]string{})
}
return resultForm
}
@@ -141,11 +164,11 @@ func (c *CpdailyReportApp) SubmitReport(ctx context.Context, form map[string]*gv
bodyString := taskhelper.GetBodyString(ctx, form)
// 构造提交数据
submitData := map[string]*gvar.Var{
"lon": gvar.New(lon),
"version": gvar.New(cryptoutil.EncryptVersion),
"calVersion": gvar.New(cpdailyInfo.CalVersion),
"deviceId": extensionForm["deviceId"],
//"userId": gvar.New(username),
"lon": gvar.New(lon),
"version": gvar.New(cryptoutil.EncryptVersion),
"calVersion": gvar.New(cpdailyInfo.CalVersion),
"deviceId": extensionForm["deviceId"],
"userId": gvar.New(username),
"systemName": gvar.New("android"),
"bodyString": gvar.New(bodyString),
"lat": gvar.New(lat),
@@ -7,4 +7,8 @@ type LeaveListOne struct {
AceEndTime string `json:"aceEndTime"`
Reason string `json:"reason"`
Status string `json:"status"`
// 销假时填充的位置信息
Longitude string `json:"longitude"` // 经度
Latitude string `json:"latitude"` // 纬度
Address string `json:"address"` // 地址
}
@@ -44,9 +44,16 @@ const (
VideoEncKey = "d_yHJ!$pdA~5"
)
// ErrTimeRestriction 时间限制错误,表示当前时间不在允许执行的范围内
var ErrTimeRestriction = errors2.NewBusinessError(499, "当前时间不在允许执行的范围内")
// TimeCheckFunc 时间检查回调函数类型,返回 true 表示可以继续执行
type TimeCheckFunc func() bool
type XuexitongCourse struct {
client *resty.Client
userID string
client *resty.Client
userID string
timeCheckFunc TimeCheckFunc // 时间检查回调,每个任务点完成后调用
}
func NewXuexitongCourse(client *resty.Client) *XuexitongCourse {
@@ -55,6 +62,19 @@ func NewXuexitongCourse(client *resty.Client) *XuexitongCourse {
}
}
// SetTimeCheckFunc 设置时间检查回调函数
func (c *XuexitongCourse) SetTimeCheckFunc(fn TimeCheckFunc) {
c.timeCheckFunc = fn
}
// checkTimeRestriction 检查时间限制,如果设置了回调且返回 false,则返回时间限制错误
func (c *XuexitongCourse) checkTimeRestriction() error {
if c.timeCheckFunc != nil && !c.timeCheckFunc() {
return ErrTimeRestriction
}
return nil
}
func (c *XuexitongCourse) SetUserID(userID string) {
c.userID = userID
}
@@ -1149,12 +1169,22 @@ func (c *XuexitongCourse) AutoStudyCourse(ctx context.Context, course entity.Xue
// 遍历所有章节
for i, chapter := range chapters {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("course", course.CourseName))
return err
}
logger.Logger.Info(fmt.Sprintf("章节 [%d/%d]: %s (任务点: %d, 已完成: %d)",
i+1, len(chapters), chapter.Name, chapter.PointTotal, chapter.PointFinish))
if chapter.JobCount > 0 || chapter.PointTotal > chapter.PointFinish {
err := c.AutoStudyChapter(ctx, course, chapter)
if err != nil {
// 如果是时间限制错误,向上传递
if err == ErrTimeRestriction {
return err
}
logger.Logger.Error(fmt.Sprintf("刷章节失败: %s", chapter.Name), zap.Error(err))
continue
}
@@ -1267,6 +1297,11 @@ func (c *XuexitongCourse) AutoStudyChapter(ctx context.Context, course entity.Xu
// 刷视频
for i, video := range points.Videos {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("chapter", chapter.Name))
return err
}
logger.Logger.Info(fmt.Sprintf(" 视频任务点 [%d/%d]: %s", i+1, len(points.Videos), video.Title))
if err := c.AutoPlayVideo(ctx, course, &points.Videos[i]); err != nil {
logger.Logger.Error("视频刷课失败", zap.Error(err), zap.String("title", video.Title))
@@ -1276,6 +1311,11 @@ func (c *XuexitongCourse) AutoStudyChapter(ctx context.Context, course entity.Xu
// 刷文档
for i, doc := range points.Documents {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("chapter", chapter.Name))
return err
}
logger.Logger.Info(fmt.Sprintf(" 文档任务点 [%d/%d]: %s", i+1, len(points.Documents), doc.Title))
if err := c.AutoReadDocument(ctx, course, &points.Documents[i]); err != nil {
logger.Logger.Error("文档刷课失败", zap.Error(err), zap.String("title", doc.Title))
@@ -1285,6 +1325,11 @@ func (c *XuexitongCourse) AutoStudyChapter(ctx context.Context, course entity.Xu
// 刷作业
for i, work := range points.Works {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("chapter", chapter.Name))
return err
}
logger.Logger.Info(fmt.Sprintf(" 作业任务点 [%d/%d]: %s", i+1, len(points.Works), work.Title))
if err := c.AutoCompleteWork(ctx, course, &points.Works[i]); err != nil {
logger.Logger.Error("作业刷课失败", zap.Error(err), zap.String("title", work.Title))
@@ -1294,6 +1339,11 @@ func (c *XuexitongCourse) AutoStudyChapter(ctx context.Context, course entity.Xu
// 刷外链
for i, link := range points.Hyperlinks {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("chapter", chapter.Name))
return err
}
logger.Logger.Info(fmt.Sprintf(" 外链任务点 [%d/%d]: %s", i+1, len(points.Hyperlinks), link.Title))
if err := c.AutoCompleteHyperlink(ctx, course, &points.Hyperlinks[i]); err != nil {
logger.Logger.Error("外链刷课失败", zap.Error(err), zap.String("title", link.Title))
@@ -1303,6 +1353,11 @@ func (c *XuexitongCourse) AutoStudyChapter(ctx context.Context, course entity.Xu
// 刷直播
for i, live := range points.Lives {
// 检查时间限制
if err := c.checkTimeRestriction(); err != nil {
logger.Logger.Info("时间限制,暂停刷课", zap.String("chapter", chapter.Name))
return err
}
logger.Logger.Info(fmt.Sprintf(" 直播任务点 [%d/%d]: %s", i+1, len(points.Lives), live.Title))
if err := c.AutoWatchLive(ctx, course, &points.Lives[i]); err != nil {
logger.Logger.Error("直播刷课失败", zap.Error(err), zap.String("title", live.Title))
@@ -1,175 +0,0 @@
// ENT数据库文件,请勿编辑。
package sysannouncement
import (
"fmt"
"likedream-goframe/internal/framework/ent2"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
)
const (
// Label holds the string label denoting the sysannouncement type in the database.
Label = "sys_announcement"
// FieldID holds the string denoting the id field in the database.
FieldID = "id"
// FieldCreateTime holds the string denoting the create_time field in the database.
FieldCreateTime = "create_time"
// FieldUpdateTime holds the string denoting the update_time field in the database.
FieldUpdateTime = "update_time"
// FieldTitle holds the string denoting the title field in the database.
FieldTitle = "title"
// FieldContent holds the string denoting the content field in the database.
FieldContent = "content"
// FieldStatus holds the string denoting the status field in the database.
FieldStatus = "status"
// FieldPinned holds the string denoting the pinned field in the database.
FieldPinned = "pinned"
// FieldOrder holds the string denoting the order field in the database.
FieldOrder = "order"
// FieldCreatorID holds the string denoting the creator_id field in the database.
FieldCreatorID = "creator_id"
// EdgeCreator holds the string denoting the creator edge name in mutations.
EdgeCreator = "creator"
// Table holds the table name of the sysannouncement in the database.
Table = "sys_announcement"
// CreatorTable is the table that holds the creator relation/edge.
CreatorTable = "sys_announcement"
// CreatorInverseTable is the table name for the SysUser entity.
// It exists in this package in order to avoid circular dependency with the "sysuser" package.
CreatorInverseTable = "sys_user"
// CreatorColumn is the table column denoting the creator relation/edge.
CreatorColumn = "creator_id"
)
// Columns holds all SQL columns for sysannouncement fields.
var Columns = []string{
FieldID,
FieldCreateTime,
FieldUpdateTime,
FieldTitle,
FieldContent,
FieldStatus,
FieldPinned,
FieldOrder,
FieldCreatorID,
}
// ValidColumn reports if the column name is valid (part of the table columns).
func ValidColumn(column string) bool {
for i := range Columns {
if column == Columns[i] {
return true
}
}
return false
}
// Note that the variables below are initialized by the runtime
// package on the initialization of the application. Therefore,
// it should be imported in the main as follows:
//
// import _ "likedream-goframe/internal/ent/runtime"
var (
Hooks [1]ent.Hook
// DefaultCreateTime holds the default value on creation for the "create_time" field.
DefaultCreateTime func() *ent2.CustomTime
// DefaultUpdateTime holds the default value on creation for the "update_time" field.
DefaultUpdateTime func() *ent2.CustomTime
// DefaultPinned holds the default value on creation for the "pinned" field.
DefaultPinned bool
// DefaultOrder holds the default value on creation for the "order" field.
DefaultOrder uint
)
// Status defines the type for the "status" enum field.
type Status string
// StatusDraft is the default value of the Status enum.
const DefaultStatus = StatusDraft
// Status values.
const (
StatusDraft Status = "draft"
StatusPublished Status = "published"
StatusArchived Status = "archived"
)
func (s Status) String() string {
return string(s)
}
// StatusValidator is a validator for the "status" field enum values. It is called by the builders before save.
func StatusValidator(s Status) error {
switch s {
case StatusDraft, StatusPublished, StatusArchived:
return nil
default:
return fmt.Errorf("sysannouncement: invalid enum value for status field: %q", s)
}
}
// OrderOption defines the ordering options for the SysAnnouncement queries.
type OrderOption func(*sql.Selector)
// ByID orders the results by the id field.
func ByID(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldID, opts...).ToFunc()
}
// ByCreateTime orders the results by the create_time field.
func ByCreateTime(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldCreateTime, opts...).ToFunc()
}
// ByUpdateTime orders the results by the update_time field.
func ByUpdateTime(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldUpdateTime, opts...).ToFunc()
}
// ByTitle orders the results by the title field.
func ByTitle(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldTitle, opts...).ToFunc()
}
// ByContent orders the results by the content field.
func ByContent(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldContent, opts...).ToFunc()
}
// ByStatus orders the results by the status field.
func ByStatus(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldStatus, opts...).ToFunc()
}
// ByPinned orders the results by the pinned field.
func ByPinned(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldPinned, opts...).ToFunc()
}
// ByOrder orders the results by the order field.
func ByOrder(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldOrder, opts...).ToFunc()
}
// ByCreatorID orders the results by the creator_id field.
func ByCreatorID(opts ...sql.OrderTermOption) OrderOption {
return sql.OrderByField(FieldCreatorID, opts...).ToFunc()
}
// ByCreatorField orders the results by creator field.
func ByCreatorField(field string, opts ...sql.OrderTermOption) OrderOption {
return func(s *sql.Selector) {
sqlgraph.OrderByNeighborTerms(s, newCreatorStep(), sql.OrderByField(field, opts...))
}
}
func newCreatorStep() *sqlgraph.Step {
return sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.To(CreatorInverseTable, FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, CreatorTable, CreatorColumn),
)
}
-496
View File
@@ -1,496 +0,0 @@
// ENT数据库文件,请勿编辑。
package sysannouncement
import (
"likedream-goframe/internal/ent/internal"
"likedream-goframe/internal/ent/predicate"
"likedream-goframe/internal/framework/ent2"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
)
// ID filters vertices based on their ID field.
func ID(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldID, id))
}
// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldID, id))
}
// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldID, id))
}
// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldID, ids...))
}
// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldID, ids...))
}
// IDGT applies the GT predicate on the ID field.
func IDGT(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldID, id))
}
// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldID, id))
}
// IDLT applies the LT predicate on the ID field.
func IDLT(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldID, id))
}
// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldID, id))
}
// CreateTime applies equality check predicate on the "create_time" field. It's identical to CreateTimeEQ.
func CreateTime(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldCreateTime, v))
}
// UpdateTime applies equality check predicate on the "update_time" field. It's identical to UpdateTimeEQ.
func UpdateTime(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldUpdateTime, v))
}
// Title applies equality check predicate on the "title" field. It's identical to TitleEQ.
func Title(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldTitle, v))
}
// Content applies equality check predicate on the "content" field. It's identical to ContentEQ.
func Content(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldContent, v))
}
// Pinned applies equality check predicate on the "pinned" field. It's identical to PinnedEQ.
func Pinned(v bool) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldPinned, v))
}
// Order applies equality check predicate on the "order" field. It's identical to OrderEQ.
func Order(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldOrder, v))
}
// CreatorID applies equality check predicate on the "creator_id" field. It's identical to CreatorIDEQ.
func CreatorID(v int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldCreatorID, v))
}
// CreateTimeEQ applies the EQ predicate on the "create_time" field.
func CreateTimeEQ(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldCreateTime, v))
}
// CreateTimeNEQ applies the NEQ predicate on the "create_time" field.
func CreateTimeNEQ(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldCreateTime, v))
}
// CreateTimeIn applies the In predicate on the "create_time" field.
func CreateTimeIn(vs ...*ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldCreateTime, vs...))
}
// CreateTimeNotIn applies the NotIn predicate on the "create_time" field.
func CreateTimeNotIn(vs ...*ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldCreateTime, vs...))
}
// CreateTimeGT applies the GT predicate on the "create_time" field.
func CreateTimeGT(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldCreateTime, v))
}
// CreateTimeGTE applies the GTE predicate on the "create_time" field.
func CreateTimeGTE(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldCreateTime, v))
}
// CreateTimeLT applies the LT predicate on the "create_time" field.
func CreateTimeLT(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldCreateTime, v))
}
// CreateTimeLTE applies the LTE predicate on the "create_time" field.
func CreateTimeLTE(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldCreateTime, v))
}
// CreateTimeContains applies the Contains predicate on the "create_time" field.
func CreateTimeContains(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldContains(FieldCreateTime, vc))
}
// CreateTimeHasPrefix applies the HasPrefix predicate on the "create_time" field.
func CreateTimeHasPrefix(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldHasPrefix(FieldCreateTime, vc))
}
// CreateTimeHasSuffix applies the HasSuffix predicate on the "create_time" field.
func CreateTimeHasSuffix(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldHasSuffix(FieldCreateTime, vc))
}
// CreateTimeEqualFold applies the EqualFold predicate on the "create_time" field.
func CreateTimeEqualFold(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldEqualFold(FieldCreateTime, vc))
}
// CreateTimeContainsFold applies the ContainsFold predicate on the "create_time" field.
func CreateTimeContainsFold(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldContainsFold(FieldCreateTime, vc))
}
// UpdateTimeEQ applies the EQ predicate on the "update_time" field.
func UpdateTimeEQ(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldUpdateTime, v))
}
// UpdateTimeNEQ applies the NEQ predicate on the "update_time" field.
func UpdateTimeNEQ(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldUpdateTime, v))
}
// UpdateTimeIn applies the In predicate on the "update_time" field.
func UpdateTimeIn(vs ...*ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldUpdateTime, vs...))
}
// UpdateTimeNotIn applies the NotIn predicate on the "update_time" field.
func UpdateTimeNotIn(vs ...*ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldUpdateTime, vs...))
}
// UpdateTimeGT applies the GT predicate on the "update_time" field.
func UpdateTimeGT(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldUpdateTime, v))
}
// UpdateTimeGTE applies the GTE predicate on the "update_time" field.
func UpdateTimeGTE(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldUpdateTime, v))
}
// UpdateTimeLT applies the LT predicate on the "update_time" field.
func UpdateTimeLT(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldUpdateTime, v))
}
// UpdateTimeLTE applies the LTE predicate on the "update_time" field.
func UpdateTimeLTE(v *ent2.CustomTime) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldUpdateTime, v))
}
// UpdateTimeContains applies the Contains predicate on the "update_time" field.
func UpdateTimeContains(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldContains(FieldUpdateTime, vc))
}
// UpdateTimeHasPrefix applies the HasPrefix predicate on the "update_time" field.
func UpdateTimeHasPrefix(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldHasPrefix(FieldUpdateTime, vc))
}
// UpdateTimeHasSuffix applies the HasSuffix predicate on the "update_time" field.
func UpdateTimeHasSuffix(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldHasSuffix(FieldUpdateTime, vc))
}
// UpdateTimeEqualFold applies the EqualFold predicate on the "update_time" field.
func UpdateTimeEqualFold(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldEqualFold(FieldUpdateTime, vc))
}
// UpdateTimeContainsFold applies the ContainsFold predicate on the "update_time" field.
func UpdateTimeContainsFold(v *ent2.CustomTime) predicate.SysAnnouncement {
vc := v.String()
return predicate.SysAnnouncement(sql.FieldContainsFold(FieldUpdateTime, vc))
}
// TitleEQ applies the EQ predicate on the "title" field.
func TitleEQ(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldTitle, v))
}
// TitleNEQ applies the NEQ predicate on the "title" field.
func TitleNEQ(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldTitle, v))
}
// TitleIn applies the In predicate on the "title" field.
func TitleIn(vs ...string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldTitle, vs...))
}
// TitleNotIn applies the NotIn predicate on the "title" field.
func TitleNotIn(vs ...string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldTitle, vs...))
}
// TitleGT applies the GT predicate on the "title" field.
func TitleGT(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldTitle, v))
}
// TitleGTE applies the GTE predicate on the "title" field.
func TitleGTE(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldTitle, v))
}
// TitleLT applies the LT predicate on the "title" field.
func TitleLT(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldTitle, v))
}
// TitleLTE applies the LTE predicate on the "title" field.
func TitleLTE(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldTitle, v))
}
// TitleContains applies the Contains predicate on the "title" field.
func TitleContains(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldContains(FieldTitle, v))
}
// TitleHasPrefix applies the HasPrefix predicate on the "title" field.
func TitleHasPrefix(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldHasPrefix(FieldTitle, v))
}
// TitleHasSuffix applies the HasSuffix predicate on the "title" field.
func TitleHasSuffix(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldHasSuffix(FieldTitle, v))
}
// TitleEqualFold applies the EqualFold predicate on the "title" field.
func TitleEqualFold(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEqualFold(FieldTitle, v))
}
// TitleContainsFold applies the ContainsFold predicate on the "title" field.
func TitleContainsFold(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldContainsFold(FieldTitle, v))
}
// ContentEQ applies the EQ predicate on the "content" field.
func ContentEQ(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldContent, v))
}
// ContentNEQ applies the NEQ predicate on the "content" field.
func ContentNEQ(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldContent, v))
}
// ContentIn applies the In predicate on the "content" field.
func ContentIn(vs ...string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldContent, vs...))
}
// ContentNotIn applies the NotIn predicate on the "content" field.
func ContentNotIn(vs ...string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldContent, vs...))
}
// ContentGT applies the GT predicate on the "content" field.
func ContentGT(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldContent, v))
}
// ContentGTE applies the GTE predicate on the "content" field.
func ContentGTE(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldContent, v))
}
// ContentLT applies the LT predicate on the "content" field.
func ContentLT(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldContent, v))
}
// ContentLTE applies the LTE predicate on the "content" field.
func ContentLTE(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldContent, v))
}
// ContentContains applies the Contains predicate on the "content" field.
func ContentContains(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldContains(FieldContent, v))
}
// ContentHasPrefix applies the HasPrefix predicate on the "content" field.
func ContentHasPrefix(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldHasPrefix(FieldContent, v))
}
// ContentHasSuffix applies the HasSuffix predicate on the "content" field.
func ContentHasSuffix(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldHasSuffix(FieldContent, v))
}
// ContentEqualFold applies the EqualFold predicate on the "content" field.
func ContentEqualFold(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEqualFold(FieldContent, v))
}
// ContentContainsFold applies the ContainsFold predicate on the "content" field.
func ContentContainsFold(v string) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldContainsFold(FieldContent, v))
}
// StatusEQ applies the EQ predicate on the "status" field.
func StatusEQ(v Status) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldStatus, v))
}
// StatusNEQ applies the NEQ predicate on the "status" field.
func StatusNEQ(v Status) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldStatus, v))
}
// StatusIn applies the In predicate on the "status" field.
func StatusIn(vs ...Status) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldStatus, vs...))
}
// StatusNotIn applies the NotIn predicate on the "status" field.
func StatusNotIn(vs ...Status) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldStatus, vs...))
}
// PinnedEQ applies the EQ predicate on the "pinned" field.
func PinnedEQ(v bool) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldPinned, v))
}
// PinnedNEQ applies the NEQ predicate on the "pinned" field.
func PinnedNEQ(v bool) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldPinned, v))
}
// OrderEQ applies the EQ predicate on the "order" field.
func OrderEQ(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldOrder, v))
}
// OrderNEQ applies the NEQ predicate on the "order" field.
func OrderNEQ(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldOrder, v))
}
// OrderIn applies the In predicate on the "order" field.
func OrderIn(vs ...uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldOrder, vs...))
}
// OrderNotIn applies the NotIn predicate on the "order" field.
func OrderNotIn(vs ...uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldOrder, vs...))
}
// OrderGT applies the GT predicate on the "order" field.
func OrderGT(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGT(FieldOrder, v))
}
// OrderGTE applies the GTE predicate on the "order" field.
func OrderGTE(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldGTE(FieldOrder, v))
}
// OrderLT applies the LT predicate on the "order" field.
func OrderLT(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLT(FieldOrder, v))
}
// OrderLTE applies the LTE predicate on the "order" field.
func OrderLTE(v uint) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldLTE(FieldOrder, v))
}
// CreatorIDEQ applies the EQ predicate on the "creator_id" field.
func CreatorIDEQ(v int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldEQ(FieldCreatorID, v))
}
// CreatorIDNEQ applies the NEQ predicate on the "creator_id" field.
func CreatorIDNEQ(v int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNEQ(FieldCreatorID, v))
}
// CreatorIDIn applies the In predicate on the "creator_id" field.
func CreatorIDIn(vs ...int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldIn(FieldCreatorID, vs...))
}
// CreatorIDNotIn applies the NotIn predicate on the "creator_id" field.
func CreatorIDNotIn(vs ...int64) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.FieldNotIn(FieldCreatorID, vs...))
}
// HasCreator applies the HasEdge predicate on the "creator" edge.
func HasCreator() predicate.SysAnnouncement {
return predicate.SysAnnouncement(func(s *sql.Selector) {
step := sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, CreatorTable, CreatorColumn),
)
schemaConfig := internal.SchemaConfigFromContext(s.Context())
step.To.Schema = schemaConfig.SysUser
step.Edge.Schema = schemaConfig.SysAnnouncement
sqlgraph.HasNeighbors(s, step)
})
}
// HasCreatorWith applies the HasEdge predicate on the "creator" edge with a given conditions (other predicates).
func HasCreatorWith(preds ...predicate.SysUser) predicate.SysAnnouncement {
return predicate.SysAnnouncement(func(s *sql.Selector) {
step := newCreatorStep()
schemaConfig := internal.SchemaConfigFromContext(s.Context())
step.To.Schema = schemaConfig.SysUser
step.Edge.Schema = schemaConfig.SysAnnouncement
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
}
})
})
}
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.SysAnnouncement) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.SysAnnouncement) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.SysAnnouncement) predicate.SysAnnouncement {
return predicate.SysAnnouncement(sql.NotPredicates(p))
}
+16 -2
View File
@@ -1,18 +1,32 @@
package logger
import (
"go.uber.org/zap"
"log"
"time"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
var Logger *zap.Logger
func init() {
logger, err := zap.NewProduction()
// Create a production config and customize the time encoder
config := zap.NewProductionConfig()
config.EncoderConfig.EncodeTime = BeijingTimeEncoder
// Build the logger with the custom config
logger, err := config.Build()
if err != nil {
log.Fatalf("cannot init zap logger: %+v", err)
}
Logger = logger
}
// BeijingTimeEncoder formats time in Beijing timezone
func BeijingTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
// Set timezone to Beijing (UTC+8)
beijingLoc, _ := time.LoadLocation("Asia/Shanghai")
enc.AppendString(t.In(beijingLoc).Format("2006-01-02 15:04:05"))
}
+17 -12
View File
@@ -40,19 +40,15 @@ func (c *CpdailyTaskHandler) ProcessTask(ctx context.Context, task *asynq.Task)
e := gob.NewDecoder(bytes.NewReader(task.Payload())).Decode(&taskPayload)
utils.OkOrPanic(e, oops.WithContext(ctx).With("payload", task.Payload(), "type", task.Type()).In("CpdailyTask.DecodePayload").Wrap)
// 查询指定的任务和关联今日校园用户
targetTask, e := db.Global.CpTask.Query().Where(cptask.ID(taskPayload.CpTaskID)).
WithCpUser().
WithSysUser().
First(ctx)
if ent.IsNotFound(e) {
utils.OkOrPanic(oops.WithContext(ctx).With("task_id", taskPayload.CpTaskID).In("CpdailyTask.ProcessTask").Wrap(e))
}
utils.OkOrPanic(e, oops.WithContext(ctx).With("task_id", taskPayload.CpTaskID).In("CpdailyTask.ProcessTask").Wrap)
db.Global.CpTask.UpdateOneID(taskPayload.CpTaskID).SetTaskStatus(cptask.TaskStatusDoing).ExecX(ctx)
// 先注册错误处理,确保任何阶段的错误都能被捕获并重置状态
var targetTask *ent.CpTask
defer utils.HandleError(func(err error) {
// 如果 targetTask 还没查询到,只能重置状态为 not_start,让任务重新入队
if targetTask == nil {
db.Global.CpTask.UpdateOneID(taskPayload.CpTaskID).SetTaskStatus(cptask.TaskStatusNotStart).Exec(ctx)
panic(err)
}
// 执行失败应该更新下次执行时间
executeTime := utils.GetCpdailyNextExecuteTime(targetTask)
e := db.Global.CpTask.UpdateOneID(taskPayload.CpTaskID).SetNextExecuteTime(executeTime).SetTaskStatus(cptask.TaskStatusFail).Exec(ctx)
@@ -90,6 +86,15 @@ func (c *CpdailyTaskHandler) ProcessTask(ctx context.Context, task *asynq.Task)
panic(err)
})
// 查询指定的任务和关联今日校园用户
targetTask, e = db.Global.CpTask.Query().Where(cptask.ID(taskPayload.CpTaskID)).
WithCpUser().
WithSysUser().
First(ctx)
utils.OkOrPanic(e, oops.WithContext(ctx).With("task_id", taskPayload.CpTaskID).In("CpdailyTask.ProcessTask").Wrap)
db.Global.CpTask.UpdateOneID(taskPayload.CpTaskID).SetTaskStatus(cptask.TaskStatusDoing).ExecX(ctx)
// 查询学校详情
schoolDetail := school.GetSchoolDetail(ctx, targetTask.Edges.CpUser.SchoolID)
cookie := targetTask.Edges.CpUser.Cookie
+14 -3
View File
@@ -7,6 +7,7 @@ import (
"likedream-goframe/internal/framework/logger"
"likedream-goframe/internal/framework/model/email"
"likedream-goframe/internal/utils"
"time"
"github.com/hibiken/asynq"
"github.com/samber/oops"
@@ -19,11 +20,18 @@ type EmailTaskHandler struct {
func (h *EmailTaskHandler) ProcessTask(ctx context.Context, task *asynq.Task) (err error) {
defer utils.Pass(&err)
var payload email.SendPayload
e := gob.NewDecoder(bytes.NewReader(task.Payload())).Decode(&payload)
utils.OkOrPanic(e, oops.WithContext(ctx).Wrap)
logger.Logger.Info("开始处理邮件发送", zap.String("邮箱", payload.To))
defer func() {
if r := recover(); r != nil {
// 打印日志
logger.Logger.Error("邮件发送失败", zap.String("邮箱", payload.To), zap.Error(r.(error)))
// 重新抛出相同的 panic
panic(r)
}
}()
message := mail.NewMsg()
@@ -37,7 +45,10 @@ func (h *EmailTaskHandler) ProcessTask(ctx context.Context, task *asynq.Task) (e
message.SetBodyString(mail.TypeTextHTML, payload.Body)
client, e := mail.NewClient(payload.SMTPHost, mail.WithPort(payload.SMTPPort), mail.WithSMTPAuth(mail.SMTPAuthAutoDiscover),
client, e := mail.NewClient(payload.SMTPHost, mail.WithPort(payload.SMTPPort),
mail.WithSMTPAuth(mail.SMTPAuthLogin), // Outlook 使用 LOGIN 认证
mail.WithTLSPortPolicy(mail.TLSMandatory),
mail.WithTimeout(30*time.Second), // 连接超时 30 秒
mail.WithUsername(payload.SMTPUsername), mail.WithPassword(payload.SMTPPassword))
utils.OkOrPanic(e, oops.WithContext(ctx).Wrap)
+68 -1
View File
@@ -2,21 +2,85 @@ package schedule
import (
"context"
cst2 "likedream-goframe/internal/common/cst"
"likedream-goframe/internal/common/db"
"likedream-goframe/internal/ent/cptask"
"likedream-goframe/internal/framework/queue"
"likedream-goframe/internal/utils"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"github.com/hibiken/asynq"
)
func Init(ctx context.Context) {
queue.InitClient(ctx)
initServer(ctx)
initInspector(ctx)
cleanupStuckTasks(ctx) // 清理卡住的任务
initScanner()
initPeriodicTasks(ctx)
}
// cleanupStuckTasks 清理服务重启时卡在 queue 或 doing 状态的任务
// 检查 asynq 队列中是否有 archived 的任务,如果有则删除并重置数据库状态
func cleanupStuckTasks(ctx context.Context) {
// 获取所有状态为 queue 或 doing 的任务
stuckTasks, err := db.Global.CpTask.Query().
Where(
cptask.Or(
cptask.TaskStatusEQ(cptask.TaskStatusQueue),
cptask.TaskStatusEQ(cptask.TaskStatusDoing),
),
).
All(ctx)
if err != nil {
g.Log().Warningf(ctx, "查询卡住的任务失败: %v", err)
return
}
if len(stuckTasks) == 0 {
return
}
// 检查 archived 队列中的任务数量
archivedTasks, err := globalInspector.ListArchivedTasks(cst2.TaskQueueCpdaily, asynq.PageSize(10000))
if err != nil {
g.Log().Warningf(ctx, "获取 archived 任务列表失败: %v", err)
}
// 删除所有 archived 的任务,让它们可以重新入队
for _, task := range archivedTasks {
if err := globalInspector.DeleteTask(cst2.TaskQueueCpdaily, task.ID); err != nil {
g.Log().Debugf(ctx, "删除 archived 任务失败: %v", err)
}
}
if len(archivedTasks) > 0 {
g.Log().Infof(ctx, "已清理 %d 个 archived 状态的 asynq 任务", len(archivedTasks))
}
// 重置数据库中卡住的任务状态
affected, err := db.Global.CpTask.Update().
Where(
cptask.Or(
cptask.TaskStatusEQ(cptask.TaskStatusQueue),
),
).
SetTaskStatus(cptask.TaskStatusNotStart).
Save(ctx)
if err != nil {
g.Log().Warningf(ctx, "重置卡住的任务失败: %v", err)
return
}
if affected > 0 {
g.Log().Infof(ctx, "已重置 %d 个卡住的任务状态为 not_start", affected)
}
}
func Stop() {
globalScanner.StopScan()
g.Log().Info(gctx.GetInitCtx(), "task scanner stopped")
@@ -30,7 +94,10 @@ func Stop() {
g.Log().Info(gctx.GetInitCtx(), "asynq client closed")
globalServer.Shutdown()
g.Log().Info(gctx.GetInitCtx(), "asynq server stopped")
g.Log().Info(gctx.GetInitCtx(), "asynq main server stopped")
auxiliaryServer.Shutdown()
g.Log().Info(gctx.GetInitCtx(), "asynq auxiliary server stopped")
e = globalInspector.Close()
utils.OkOrPanic(e)
+83 -3
View File
@@ -8,6 +8,7 @@ import (
cst2 "likedream-goframe/internal/common/cst"
"likedream-goframe/internal/common/db"
"likedream-goframe/internal/ent"
"likedream-goframe/internal/ent/courseentity"
"likedream-goframe/internal/ent/cptask"
"likedream-goframe/internal/framework/queue"
"likedream-goframe/internal/utils"
@@ -65,6 +66,7 @@ func (ts *TaskScanner) StartScan() {
}
ts.scanCpdailyTask()
ts.scanXuexitongTask()
}
}
@@ -121,12 +123,16 @@ func (ts *TaskScanner) scanCpdailyTask() {
year, month, day := currentTime.Date()
execTime := time.Date(year, month, day, *task.ExecuteHour, *task.ExecuteMinute, 0, 0, cst2.TimeZoneShangHai)
// 添加随机延迟(0-30秒),分散同一时间点的任务执行,避免瞬间占满所有 worker
randomDelay := time.Duration(task.ID%30) * time.Second
execTime = execTime.Add(randomDelay)
e = utils.Catch(func() {
queue.AddTask(ts.ctx, asynq.NewTask(cst2.TaskCpdaily, payloadWriter.Bytes()),
asynq.Unique(5*time.Minute),
asynq.Unique(2*time.Minute),
asynq.MaxRetry(4),
asynq.ProcessAt(execTime),
asynq.Timeout(10*time.Minute),
asynq.Timeout(5*time.Minute),
asynq.Queue(cst2.TaskQueueCpdaily),
)
// 更新未开始的任务状态为队列中
@@ -134,7 +140,8 @@ func (ts *TaskScanner) scanCpdailyTask() {
})
if e != nil {
if errors.Is(e, asynq.ErrDuplicateTask) {
// 任务已在队列中,不更新下次执行时间,等任务执行完成后再处理
// 任务已在队列中,确保数据库状态也是 queue,然后跳过
db.Global.CpTask.Update().Where(cptask.ID(task.ID)).SetTaskStatus(cptask.TaskStatusQueue).Exec(ts.ctx)
g.Log().Debugf(ts.ctx, "任务ID %d 已在队列中,跳过本次扫描", task.ID)
failedIDS = append(failedIDS, task.ID)
continue
@@ -186,3 +193,76 @@ func (ts *TaskScanner) scanCpdailyTask() {
utils.LogError(ts.ctx, "重置过期任务下次执行时间失败", oops.With("task_id", task.ID, "next_execute_at", nextExecuteAt).Wrap(e))
}
}
// scanXuexitongTask 扫描学习通刷课任务
func (ts *TaskScanner) scanXuexitongTask() {
// 查询所有状态为not_start或waiting的课程
allCourses := db.Global.CourseEntity.Query().
Where(
courseentity.Or(
courseentity.StatusEQ(courseentity.StatusNotStart),
courseentity.StatusEQ(courseentity.StatusWaiting),
),
).
AllX(ts.ctx)
if len(allCourses) == 0 {
return
}
// 按暴力模式区分任务
for _, course := range allCourses {
// 检查是否暂停
if course.Status == courseentity.StatusPause {
continue
}
payload := &XuexitongTaskPayload{
CourseID: course.ID,
}
payloadWriter := bytes.NewBuffer(nil)
e := gob.NewEncoder(payloadWriter).Encode(payload)
utils.OkOrPanic(e, oops.WithContext(ts.ctx).With("payload", payload).In("XuexitongTaskScanner.scanXuexitongTask").Wrap)
// 根据violence字段选择队列和任务类型
var queueName string
var taskType string
if course.Violence == courseentity.ViolenceYes {
queueName = cst2.TaskQueueXuexitongVio
taskType = cst2.TaskXuexitongVio
} else {
queueName = cst2.TaskQueueXuexitong
taskType = cst2.TaskXuexitong
}
e = utils.Catch(func() {
queue.AddTask(ts.ctx, asynq.NewTask(taskType, payloadWriter.Bytes()),
//asynq.Unique(30*time.Minute), // 30分钟内去重
asynq.MaxRetry(3),
asynq.Timeout(2*time.Hour), // 刷课可能需要较长时间
asynq.Queue(queueName),
)
// 更新状态为等待中
db.Global.CourseEntity.Update().
Where(courseentity.ID(course.ID), courseentity.StatusEQ(courseentity.StatusNotStart)).
SetStatus(courseentity.StatusWaiting).
Exec(ts.ctx)
})
if e != nil {
if errors.Is(e, asynq.ErrDuplicateTask) {
// 任务已在队列中,跳过
g.Log().Debugf(ts.ctx, "学习通课程ID %d 已在队列中,跳过本次扫描", course.ID)
continue
} else if errors.Is(e, context.Canceled) {
return
} else {
utils.LogError(ts.ctx, "扫描学习通任务时,入列失败", oops.With("course_id", course.ID).Wrap(e))
}
} else {
g.Log().Debugf(ts.ctx, "学习通课程 %s (ID: %d) 已加入队列: %s", course.CourseName, course.ID, queueName)
}
}
}
+39 -12
View File
@@ -12,13 +12,19 @@ import (
"github.com/hibiken/asynq"
)
var globalServer *asynq.Server
var (
// 主任务服务器:处理 cpdaily、xuexitong 等业务任务
globalServer *asynq.Server
// 辅助任务服务器:处理 email、reset 等轻量级任务
auxiliaryServer *asynq.Server
)
func initServer(ctx context.Context) {
cfg := g.Cfg()
taskConcurrency := cfg.MustGetWithEnv(ctx, cst2.ConfigTaskConcurrency).Int()
// 主服务器:专门处理业务任务,使用大部分 worker
globalServer = asynq.NewServerFromRedisClient(redis.GetClient(), asynq.Config{
Concurrency: taskConcurrency,
BaseContext: gctx.GetInitCtx,
@@ -28,24 +34,45 @@ func initServer(ctx context.Context) {
},
DelayedTaskCheckInterval: 2 * time.Second,
ErrorHandler: taskErrorHandler{},
// 只处理业务队列,使用严格优先级模式
StrictPriority: true,
Queues: map[string]int{
cst2.TaskQueueEmail: 2,
cst2.TaskQueueCpdaily: 10,
cst2.TaskQueueXuexitong: 5,
cst2.TaskQueueCpdaily: 10, // 最高优先级
cst2.TaskQueueXuexitongVio: 8,
cst2.TaskQueueDefault: 1,
cst2.TaskQueueXuexitong: 5,
},
})
mux := asynq.NewServeMux()
// 辅助服务器:专门处理邮件等轻量级任务,独立的 worker 池
auxiliaryServer = asynq.NewServerFromRedisClient(redis.GetClient(), asynq.Config{
Concurrency: 5, // 邮件任务不需要太多并发
BaseContext: gctx.GetInitCtx,
TaskCheckInterval: 10 * time.Second,
RetryDelayFunc: func(n int, _ error, _ *asynq.Task) time.Duration {
return time.Duration(n) * 2 * time.Second
},
DelayedTaskCheckInterval: 2 * time.Second,
Queues: map[string]int{
cst2.TaskQueueEmail: 2,
cst2.TaskQueueDefault: 1,
},
})
mux.Handle(cst2.TaskCpdaily, &CpdailyTaskHandler{})
mux.Handle(cst2.TaskEmail, &EmailTaskHandler{})
mux.Handle(cst2.TaskResetDaily, &ResetTaskHandler{})
mux.Handle(cst2.TaskXuexitong, &XuexitongTaskHandler{})
mux.Handle(cst2.TaskXuexitongVio, &XuexitongTaskHandler{})
// 主服务器的任务处理器
mainMux := asynq.NewServeMux()
mainMux.Handle(cst2.TaskCpdaily, &CpdailyTaskHandler{})
mainMux.Handle(cst2.TaskXuexitong, &XuexitongTaskHandler{})
mainMux.Handle(cst2.TaskXuexitongVio, &XuexitongTaskHandler{})
e := globalServer.Start(mux)
// 辅助服务器的任务处理器
auxMux := asynq.NewServeMux()
auxMux.Handle(cst2.TaskEmail, &EmailTaskHandler{})
auxMux.Handle(cst2.TaskResetDaily, &ResetTaskHandler{})
e := globalServer.Start(mainMux)
utils.OkOrPanic(e)
e = auxiliaryServer.Start(auxMux)
utils.OkOrPanic(e)
}
@@ -97,9 +97,31 @@ func (h *XuexitongTaskHandler) ProcessTask(ctx context.Context, task *asynq.Task
// 创建课程服务
courseService := xuexitong.NewXuexitongCourse(client)
// 非暴力模式下,设置时间检查回调,每个任务点完成后都会检查时间
if targetCourse.Violence == courseentity.ViolenceNo {
courseService.SetTimeCheckFunc(func() bool {
currentTime := time.Now()
currentHour := currentTime.Hour()
currentMinute := currentTime.Minute()
startTime := 8*60 + 30 // 8:30
endTime := 17*60 + 30 // 17:30
currentMinutes := currentHour*60 + currentMinute
return currentMinutes >= startTime && currentMinutes < endTime
})
}
// 执行刷课
err = courseService.AutoStudyByCourseID(ctx, targetCourse.CourseID)
if err != nil {
// 如果是时间限制导致的停止,不算失败
if err == xuexitong.ErrTimeRestriction {
g.Log().Infof(ctx, "课程ID %d 因时间限制暂停刷课,等待下次执行", targetCourse.ID)
// 更新状态为等待中,等待下次定时任务
db.Global.CourseEntity.UpdateOneID(taskPayload.CourseID).SetStatus(courseentity.StatusWaiting).ExecX(ctx)
return nil
}
utils.OkOrPanic(errors.NewBusinessErrorWithDetail(503, "刷课失败", err))
}
+14 -11
View File
@@ -17,6 +17,7 @@ import (
"likedream-goframe/internal/service/balance"
"likedream-goframe/internal/utils"
"github.com/gogf/gf/v2/container/gvar"
"github.com/gogf/gf/v2/frame/g"
"github.com/shopspring/decimal"
)
@@ -110,15 +111,6 @@ func (v CpLeaveServiceV1) Report(ctx context.Context, req *v1.CpLeaveReportReq)
utils.OkOrPanic(errors2.NewBusinessError(400, "非法的今日校园账号"))
}
// 检查是否已经存在该销假记录
existLeave, _ := db2.Global.CpLeave.Query().
Where(cpleave.LeaveIDEQ(req.LeaveId), cpleave.CpUserIDEQ(req.CpUserId)).
First(ctx)
if existLeave != nil {
utils.OkOrPanic(errors2.NewBusinessError(400, fmt.Sprintf("该请假记录已处理,状态:%s", existLeave.Status)))
}
// 计算扣款金额
basePoint, err := decimal.NewFromString(g.Cfg().MustGet(ctx, cst2.ConfigBasePointCpdailyLeave).String())
utils.OkOrPanic(err)
@@ -178,8 +170,19 @@ func (v CpLeaveServiceV1) Report(ctx context.Context, req *v1.CpLeaveReportReq)
// 填充表单
form := reportApp.FillReportForm(detail)
// 获取位置信息
lon, lat := reportApp.GetLocation(detail)
// 获取位置信息,优先使用前端传入的
var lon, lat string
if req.Longitude != "" && req.Latitude != "" {
lon = req.Longitude
lat = req.Latitude
} else {
lon, lat = reportApp.GetLocation(detail)
}
// 如果前端传入了地址,使用前端的地址
if req.Address != "" {
form["reportLocation"] = gvar.New(req.Address)
}
// 提交销假
reportApp.SubmitReport(ctx, form, lon, lat, cpUser.Username, cpUser.MobileCode)
+1 -1
View File
@@ -265,7 +265,7 @@ func (v CpTaskServiceV1) ExecuteNow(ctx context.Context, req *v1.ExecuteNowReq)
queue.AddTask(ctx, asynq.NewTask(cst2.TaskCpdaily, payloadWriter.Bytes()),
asynq.Unique(2*time.Minute),
asynq.MaxRetry(0),
asynq.Timeout(10*time.Minute),
asynq.Timeout(5*time.Minute),
asynq.Deadline(time.Now().Add(10*time.Minute)),
asynq.Queue(cst2.TaskQueueCpdaily),
)
+1 -1
View File
@@ -144,7 +144,7 @@ func (s *EmailServiceV1) sendEmail(ctx context.Context, to, subject, body string
task := queue.AddTask(ctx, asynq.NewTask(cst2.TaskEmail, payload.Bytes()), asynq.Queue(cst2.TaskQueueEmail),
asynq.MaxRetry(3),
asynq.Timeout(10*time.Minute),
asynq.Timeout(5*time.Minute),
)
logger.Logger.Info("添加任务: ", zap.String("task_id", task.ID), zap.String("邮箱", to))
return nil