793 lines
20 KiB
Go
793 lines
20 KiB
Go
package controllers
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"server/middleware"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
"server/pkg/identity"
|
|
"server/pkg/jwtutil"
|
|
"server/services/gueststore"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
type AppReminderController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
// 放行移动端、租户端与游客令牌：游客调用时不进业务表，分流到 gueststore。
|
|
func (c *AppReminderController) appClaims() (*jwtutil.Claims, error) {
|
|
return identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndApp, identity.EndBackend, identity.EndGuest)
|
|
}
|
|
|
|
func (c *AppReminderController) jsonErr(httpStatus, bizCode int, msg string) {
|
|
c.Ctx.Output.SetStatus(httpStatus)
|
|
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *AppReminderController) ok(data interface{}) {
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func appGenerateToken() string {
|
|
b := make([]byte, 16)
|
|
_, _ = rand.Read(b)
|
|
b[6] = (b[6] & 0x0f) | 0x40
|
|
b[8] = (b[8] & 0x3f) | 0x80
|
|
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
|
|
}
|
|
|
|
type appSchedulePayload struct {
|
|
Content string `json:"content"`
|
|
ScheduleTime string `json:"schedule_time"`
|
|
RemindChannels []string `json:"remind_channels"`
|
|
AdvanceMinutes int `json:"advance_minutes"`
|
|
RepeatIntervalMinutes int `json:"repeat_interval_minutes"`
|
|
MaxSendCount int `json:"max_send_count"`
|
|
}
|
|
|
|
// GetList GET /app/schedule/list
|
|
func (c *AppReminderController) GetList() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 20)
|
|
keyword := c.GetString("keyword", "")
|
|
status := c.GetString("status", "")
|
|
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestList(claims, page, pageSize, keyword, status)
|
|
return
|
|
}
|
|
|
|
qs := models.Orm.QueryTable(new(models.BackendSchedule)).
|
|
Filter("user_id", claims.UserID).
|
|
Filter("tid", claims.TenantId)
|
|
|
|
if keyword != "" {
|
|
qs = qs.Filter("content__contains", keyword)
|
|
}
|
|
|
|
total, _ := qs.Count()
|
|
|
|
var schedules []models.BackendSchedule
|
|
_, err = qs.OrderBy("-id").Limit(pageSize, (page-1)*pageSize).All(&schedules)
|
|
if err != nil && err != orm.ErrNoRows {
|
|
c.jsonErr(500, 500, "查询失败: "+err.Error())
|
|
return
|
|
}
|
|
if schedules == nil {
|
|
schedules = []models.BackendSchedule{}
|
|
}
|
|
|
|
list := make([]map[string]interface{}, 0, len(schedules))
|
|
for _, s := range schedules {
|
|
var reminders []models.BackendScheduleReminder
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", s.ID).
|
|
Filter("is_deleted", 0).
|
|
All(&reminders)
|
|
|
|
channels := make([]string, 0, len(reminders))
|
|
isFinished := true
|
|
if len(reminders) == 0 {
|
|
isFinished = false
|
|
} else {
|
|
for _, r := range reminders {
|
|
channels = append(channels, r.RemindChannel)
|
|
if r.RemindStatus != 2 {
|
|
isFinished = false
|
|
}
|
|
}
|
|
}
|
|
|
|
// status filter
|
|
if status == "pending" && isFinished {
|
|
continue
|
|
}
|
|
if status == "done" && !isFinished {
|
|
continue
|
|
}
|
|
|
|
item := map[string]interface{}{
|
|
"id": s.ID,
|
|
"content": s.Content,
|
|
"schedule_time": s.ScheduleTime.Format("2006-01-02 15:04:05"),
|
|
"remind_channels": channels,
|
|
"is_finished": isFinished,
|
|
"created_at": s.ScheduleTime.Format("2006-01-02 15:04:05"),
|
|
"updated_at": s.ScheduleTime.Format("2006-01-02 15:04:05"),
|
|
}
|
|
if len(reminders) > 0 {
|
|
first := reminders[0]
|
|
item["advance_minutes"] = first.AdvanceMinutes
|
|
item["repeat_interval_minutes"] = first.RepeatIntervalMinutes
|
|
item["max_send_count"] = first.MaxSendCount
|
|
if !first.CreateTime.IsZero() {
|
|
item["created_at"] = first.CreateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
if !first.UpdateTime.IsZero() {
|
|
item["updated_at"] = first.UpdateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
}
|
|
list = append(list, item)
|
|
}
|
|
|
|
c.ok(map[string]interface{}{
|
|
"list": list,
|
|
"total": total,
|
|
"page": page,
|
|
"pageSize": pageSize,
|
|
})
|
|
}
|
|
|
|
// GetDetail GET /app/schedule/:id
|
|
func (c *AppReminderController) GetDetail() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
if id == 0 {
|
|
c.jsonErr(400, 400, "无效的ID")
|
|
return
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestDetail(claims, id)
|
|
return
|
|
}
|
|
|
|
var schedule models.BackendSchedule
|
|
err = models.Orm.QueryTable(new(models.BackendSchedule)).
|
|
Filter("id", id).
|
|
Filter("user_id", claims.UserID).
|
|
Filter("tid", claims.TenantId).
|
|
One(&schedule)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
|
|
var reminders []models.BackendScheduleReminder
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", schedule.ID).
|
|
Filter("is_deleted", 0).
|
|
All(&reminders)
|
|
|
|
channels := make([]string, 0, len(reminders))
|
|
var first models.BackendScheduleReminder
|
|
for _, r := range reminders {
|
|
channels = append(channels, r.RemindChannel)
|
|
first = r
|
|
}
|
|
|
|
isFinished := true
|
|
if len(reminders) == 0 {
|
|
isFinished = false
|
|
} else {
|
|
for _, r := range reminders {
|
|
if r.RemindStatus != 2 {
|
|
isFinished = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
data := map[string]interface{}{
|
|
"id": schedule.ID,
|
|
"content": schedule.Content,
|
|
"schedule_time": schedule.ScheduleTime.Format("2006-01-02 15:04:05"),
|
|
"remind_channels": channels,
|
|
"is_finished": isFinished,
|
|
}
|
|
if first.ID > 0 {
|
|
data["advance_minutes"] = first.AdvanceMinutes
|
|
data["repeat_interval_minutes"] = first.RepeatIntervalMinutes
|
|
data["max_send_count"] = first.MaxSendCount
|
|
if !first.CreateTime.IsZero() {
|
|
data["created_at"] = first.CreateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
if !first.UpdateTime.IsZero() {
|
|
data["updated_at"] = first.UpdateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
}
|
|
|
|
c.ok(data)
|
|
}
|
|
|
|
// Create POST /app/schedule
|
|
func (c *AppReminderController) Create() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
c.jsonErr(400, 400, "参数错误")
|
|
return
|
|
}
|
|
var p appSchedulePayload
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
c.jsonErr(400, 400, "参数错误")
|
|
return
|
|
}
|
|
|
|
if strings.TrimSpace(p.Content) == "" {
|
|
c.jsonErr(400, 400, "日程内容不能为空")
|
|
return
|
|
}
|
|
if strings.TrimSpace(p.ScheduleTime) == "" {
|
|
c.jsonErr(400, 400, "日程发生时间不能为空")
|
|
return
|
|
}
|
|
|
|
schedTime, err := time.ParseInLocation("2006-01-02 15:04:05", p.ScheduleTime, time.Local)
|
|
if err != nil {
|
|
c.jsonErr(400, 400, "日程时间格式不合法，支持 YYYY-MM-DD HH:mm:ss")
|
|
return
|
|
}
|
|
|
|
content := strings.TrimSpace(p.Content)
|
|
title := strings.SplitN(content, "\n", 2)[0]
|
|
if len(title) > 60 {
|
|
title = title[:60]
|
|
}
|
|
if title == "" {
|
|
title = "日程提醒"
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestCreate(claims, p, content, schedTime)
|
|
return
|
|
}
|
|
|
|
schedule := models.BackendSchedule{
|
|
Tid: claims.TenantId,
|
|
Title: title,
|
|
Content: content,
|
|
ScheduleTime: schedTime,
|
|
UserID: uint64(claims.UserID),
|
|
}
|
|
schedID, err := models.Orm.Insert(&schedule)
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "保存日程失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
for _, ch := range p.RemindChannels {
|
|
ch = strings.ToUpper(strings.TrimSpace(ch))
|
|
if ch != "SMS" && ch != "EMAIL" && ch != "BARK" && ch != "SITE_MSG" && ch != "APP" {
|
|
continue
|
|
}
|
|
if ch == "APP" {
|
|
ch = "SITE_MSG"
|
|
}
|
|
|
|
firstSendTime := schedTime.Add(-time.Duration(p.AdvanceMinutes) * time.Minute)
|
|
|
|
reminder := models.BackendScheduleReminder{
|
|
Tid: claims.TenantId,
|
|
ScheduleID: uint64(schedID),
|
|
RemindChannel: ch,
|
|
AdvanceMinutes: p.AdvanceMinutes,
|
|
NextRemindTime: firstSendTime,
|
|
ReceiverUserID: uint64(claims.UserID),
|
|
RemindStatus: 0,
|
|
CreateTime: time.Now(),
|
|
UpdateTime: time.Now(),
|
|
}
|
|
|
|
if ch == "EMAIL" || ch == "BARK" {
|
|
token := appGenerateToken()
|
|
reminder.AckToken = &token
|
|
reminder.RepeatIntervalMinutes = p.RepeatIntervalMinutes
|
|
reminder.MaxSendCount = p.MaxSendCount
|
|
if reminder.MaxSendCount <= 0 {
|
|
reminder.MaxSendCount = 1
|
|
}
|
|
} else {
|
|
reminder.RepeatIntervalMinutes = 0
|
|
reminder.MaxSendCount = 1
|
|
}
|
|
|
|
_, err = models.Orm.Insert(&reminder)
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "创建提醒失败: "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
c.ok(map[string]interface{}{"id": schedID})
|
|
}
|
|
|
|
// Update PUT /app/schedule/:id
|
|
func (c *AppReminderController) Update() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
if id == 0 {
|
|
c.jsonErr(400, 400, "无效的ID")
|
|
return
|
|
}
|
|
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil {
|
|
c.jsonErr(400, 400, "参数错误")
|
|
return
|
|
}
|
|
var p appSchedulePayload
|
|
if err := json.Unmarshal(raw, &p); err != nil {
|
|
c.jsonErr(400, 400, "参数错误")
|
|
return
|
|
}
|
|
|
|
schedTime, err := time.ParseInLocation("2006-01-02 15:04:05", p.ScheduleTime, time.Local)
|
|
if err != nil {
|
|
c.jsonErr(400, 400, "日程时间格式不合法")
|
|
return
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestUpdate(claims, id, p)
|
|
return
|
|
}
|
|
|
|
var schedule models.BackendSchedule
|
|
err = models.Orm.QueryTable(new(models.BackendSchedule)).
|
|
Filter("id", id).
|
|
Filter("user_id", claims.UserID).
|
|
Filter("tid", claims.TenantId).
|
|
One(&schedule)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
|
|
var reminders []models.BackendScheduleReminder
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", id).
|
|
Filter("is_deleted", 0).
|
|
All(&reminders)
|
|
isFinished := true
|
|
if len(reminders) == 0 {
|
|
isFinished = false
|
|
} else {
|
|
for _, r := range reminders {
|
|
if r.RemindStatus != 2 {
|
|
isFinished = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if isFinished {
|
|
c.jsonErr(400, 400, "该日程提醒已全部结束，无法编辑")
|
|
return
|
|
}
|
|
|
|
content := strings.TrimSpace(p.Content)
|
|
if content == "" {
|
|
content = schedule.Content
|
|
}
|
|
title := strings.SplitN(content, "\n", 2)[0]
|
|
if len(title) > 60 {
|
|
title = title[:60]
|
|
}
|
|
|
|
schedule.Title = title
|
|
schedule.Content = content
|
|
schedule.ScheduleTime = schedTime
|
|
_, err = models.Orm.Update(&schedule, "Title", "Content", "ScheduleTime")
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "更新失败")
|
|
return
|
|
}
|
|
|
|
// 软删除旧提醒，重建
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", id).
|
|
Update(map[string]interface{}{
|
|
"IsDeleted": 1,
|
|
"UpdateTime": time.Now(),
|
|
})
|
|
|
|
for _, ch := range p.RemindChannels {
|
|
ch = strings.ToUpper(strings.TrimSpace(ch))
|
|
if ch != "SMS" && ch != "EMAIL" && ch != "BARK" && ch != "SITE_MSG" && ch != "APP" {
|
|
continue
|
|
}
|
|
if ch == "APP" {
|
|
ch = "SITE_MSG"
|
|
}
|
|
|
|
firstSendTime := schedTime.Add(-time.Duration(p.AdvanceMinutes) * time.Minute)
|
|
|
|
reminder := models.BackendScheduleReminder{
|
|
Tid: claims.TenantId,
|
|
ScheduleID: id,
|
|
RemindChannel: ch,
|
|
AdvanceMinutes: p.AdvanceMinutes,
|
|
NextRemindTime: firstSendTime,
|
|
ReceiverUserID: schedule.UserID,
|
|
RemindStatus: 0,
|
|
CreateTime: time.Now(),
|
|
UpdateTime: time.Now(),
|
|
}
|
|
|
|
if ch == "EMAIL" || ch == "BARK" {
|
|
token := appGenerateToken()
|
|
reminder.AckToken = &token
|
|
reminder.RepeatIntervalMinutes = p.RepeatIntervalMinutes
|
|
reminder.MaxSendCount = p.MaxSendCount
|
|
if reminder.MaxSendCount <= 0 {
|
|
reminder.MaxSendCount = 1
|
|
}
|
|
} else {
|
|
reminder.RepeatIntervalMinutes = 0
|
|
reminder.MaxSendCount = 1
|
|
}
|
|
|
|
_, err = models.Orm.Insert(&reminder)
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "重新创建提醒失败")
|
|
return
|
|
}
|
|
}
|
|
|
|
c.ok(nil)
|
|
}
|
|
|
|
// Delete DELETE /app/schedule/:id
|
|
func (c *AppReminderController) Delete() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
if id == 0 {
|
|
c.jsonErr(400, 400, "无效的ID")
|
|
return
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestDelete(claims, id)
|
|
return
|
|
}
|
|
|
|
var schedule models.BackendSchedule
|
|
err = models.Orm.QueryTable(new(models.BackendSchedule)).
|
|
Filter("id", id).
|
|
Filter("user_id", claims.UserID).
|
|
Filter("tid", claims.TenantId).
|
|
One(&schedule)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
|
|
var reminders []models.BackendScheduleReminder
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", id).
|
|
Filter("is_deleted", 0).
|
|
All(&reminders)
|
|
isFinished := true
|
|
if len(reminders) == 0 {
|
|
isFinished = false
|
|
} else {
|
|
for _, r := range reminders {
|
|
if r.RemindStatus != 2 {
|
|
isFinished = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if isFinished {
|
|
c.jsonErr(400, 400, "该日程提醒已全部结束，无法删除")
|
|
return
|
|
}
|
|
|
|
_, err = models.Orm.QueryTable(new(models.BackendSchedule)).Filter("id", id).Delete()
|
|
if err == nil {
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", id).
|
|
Update(map[string]interface{}{
|
|
"IsDeleted": 1,
|
|
"UpdateTime": time.Now(),
|
|
})
|
|
}
|
|
|
|
middleware.WriteDeleteLog(uint64(claims.UserID), claims.TenantId, "schedule", schedule.Content)
|
|
c.ok(nil)
|
|
}
|
|
|
|
// ToggleComplete POST /app/schedule/:id/toggle
|
|
func (c *AppReminderController) ToggleComplete() {
|
|
claims, err := c.appClaims()
|
|
if err != nil {
|
|
c.jsonErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
idStr := c.Ctx.Input.Param(":id")
|
|
id, _ := strconv.ParseUint(idStr, 10, 64)
|
|
if id == 0 {
|
|
c.jsonErr(400, 400, "无效的ID")
|
|
return
|
|
}
|
|
|
|
if identity.IsGuest(claims) {
|
|
c.guestToggle(claims, id)
|
|
return
|
|
}
|
|
|
|
var schedule models.BackendSchedule
|
|
err = models.Orm.QueryTable(new(models.BackendSchedule)).
|
|
Filter("id", id).
|
|
Filter("user_id", claims.UserID).
|
|
Filter("tid", claims.TenantId).
|
|
One(&schedule)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
|
|
var reminders []models.BackendScheduleReminder
|
|
_, _ = models.Orm.QueryTable(new(models.BackendScheduleReminder)).
|
|
Filter("schedule_id", id).
|
|
Filter("is_deleted", 0).
|
|
All(&reminders)
|
|
|
|
// Toggle: if all finished -> set to pending; else -> set to finished
|
|
allFinished := len(reminders) > 0
|
|
for _, r := range reminders {
|
|
if r.RemindStatus != 2 {
|
|
allFinished = false
|
|
break
|
|
}
|
|
}
|
|
|
|
var newStatus int8
|
|
if allFinished {
|
|
newStatus = 0 // reopen
|
|
} else {
|
|
newStatus = 2 // mark done
|
|
}
|
|
|
|
now := time.Now()
|
|
for _, r := range reminders {
|
|
r.RemindStatus = newStatus
|
|
r.UpdateTime = now
|
|
models.Orm.Update(&r, "RemindStatus", "UpdateTime")
|
|
}
|
|
|
|
c.ok(map[string]interface{}{
|
|
"is_finished": newStatus == 2,
|
|
})
|
|
}
|
|
|
|
// ---------- 游客分支（免登录态）：数据存 yz_guest_data，响应结构与登录态一致。
|
|
// 游客日程不接提醒发送链路（无短信/邮件推送），仅作待办记录；转正合并时重建提醒。 ----------
|
|
|
|
func guestScheduleItemMap(it guestScheduleItem) map[string]interface{} {
|
|
return map[string]interface{}{
|
|
"id": it.ID,
|
|
"content": it.Content,
|
|
"schedule_time": it.ScheduleTime,
|
|
"remind_channels": it.RemindChannels,
|
|
"is_finished": it.IsFinished,
|
|
"advance_minutes": it.AdvanceMinutes,
|
|
"repeat_interval_minutes": it.RepeatIntervalMinutes,
|
|
"max_send_count": it.MaxSendCount,
|
|
"created_at": it.CreatedAt,
|
|
"updated_at": it.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func guestScheduleFull(r gueststore.Row) guestScheduleItem {
|
|
var it guestScheduleItem
|
|
if json.Unmarshal(r.Payload, &it) != nil {
|
|
it = guestScheduleItem{Content: "(数据异常)"}
|
|
}
|
|
it.ID = r.ID
|
|
it.CreatedAt = r.CreateTime.Format("2006-01-02 15:04:05")
|
|
it.UpdatedAt = it.CreatedAt
|
|
if r.UpdateTime != nil {
|
|
it.UpdatedAt = r.UpdateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
if it.RemindChannels == nil {
|
|
it.RemindChannels = []string{}
|
|
}
|
|
return it
|
|
}
|
|
|
|
func (c *AppReminderController) guestList(claims *jwtutil.Claims, page, pageSize int, keyword, status string) {
|
|
rows, err := gueststore.List(uint64(claims.UserID), guestModuleSchedule)
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "查询失败")
|
|
return
|
|
}
|
|
items := make([]map[string]interface{}, 0, len(rows))
|
|
for _, r := range rows {
|
|
it := guestScheduleFull(r)
|
|
if keyword != "" && !strings.Contains(it.Content, keyword) {
|
|
continue
|
|
}
|
|
if status == "pending" && it.IsFinished {
|
|
continue
|
|
}
|
|
if status == "done" && !it.IsFinished {
|
|
continue
|
|
}
|
|
items = append(items, guestScheduleItemMap(it))
|
|
}
|
|
total := len(items)
|
|
start := (page - 1) * pageSize
|
|
if start > total {
|
|
start = total
|
|
}
|
|
end := start + pageSize
|
|
if end > total {
|
|
end = total
|
|
}
|
|
c.ok(map[string]interface{}{
|
|
"list": items[start:end], "total": total, "page": page, "pageSize": pageSize,
|
|
})
|
|
}
|
|
|
|
func (c *AppReminderController) guestDetail(claims *jwtutil.Claims, id uint64) {
|
|
r, err := gueststore.Get(uint64(claims.UserID), guestModuleSchedule, id)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
c.ok(guestScheduleItemMap(guestScheduleFull(r)))
|
|
}
|
|
|
|
func (c *AppReminderController) guestCreate(claims *jwtutil.Claims, p appSchedulePayload, content string, schedTime time.Time) {
|
|
_ = schedTime
|
|
now := time.Now().Format("2006-01-02 15:04:05")
|
|
channels := p.RemindChannels
|
|
if channels == nil {
|
|
channels = []string{}
|
|
}
|
|
it := guestScheduleItem{
|
|
Content: content,
|
|
ScheduleTime: p.ScheduleTime,
|
|
RemindChannels: channels,
|
|
AdvanceMinutes: p.AdvanceMinutes,
|
|
RepeatIntervalMinutes: p.RepeatIntervalMinutes,
|
|
MaxSendCount: p.MaxSendCount,
|
|
IsFinished: false,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
newID, err := gueststore.Insert(uint64(claims.UserID), guestModuleSchedule, it)
|
|
if err != nil {
|
|
c.jsonErr(500, 500, "保存日程失败")
|
|
return
|
|
}
|
|
c.ok(map[string]interface{}{"id": newID})
|
|
}
|
|
|
|
func (c *AppReminderController) guestUpdate(claims *jwtutil.Claims, id uint64, p appSchedulePayload) {
|
|
r, err := gueststore.Get(uint64(claims.UserID), guestModuleSchedule, id)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
it := guestScheduleFull(r)
|
|
if it.IsFinished {
|
|
c.jsonErr(400, 400, "该日程提醒已全部结束，无法编辑")
|
|
return
|
|
}
|
|
if content := strings.TrimSpace(p.Content); content != "" {
|
|
it.Content = content
|
|
}
|
|
if strings.TrimSpace(p.ScheduleTime) != "" {
|
|
if _, perr := time.ParseInLocation("2006-01-02 15:04:05", p.ScheduleTime, time.Local); perr != nil {
|
|
c.jsonErr(400, 400, "日程时间格式不合法")
|
|
return
|
|
}
|
|
it.ScheduleTime = p.ScheduleTime
|
|
}
|
|
if p.RemindChannels != nil {
|
|
it.RemindChannels = p.RemindChannels
|
|
}
|
|
it.AdvanceMinutes = p.AdvanceMinutes
|
|
it.RepeatIntervalMinutes = p.RepeatIntervalMinutes
|
|
it.MaxSendCount = p.MaxSendCount
|
|
it.UpdatedAt = time.Now().Format("2006-01-02 15:04:05")
|
|
if err = gueststore.Update(uint64(claims.UserID), guestModuleSchedule, id, it); err != nil {
|
|
c.jsonErr(500, 500, "更新失败")
|
|
return
|
|
}
|
|
c.ok(nil)
|
|
}
|
|
|
|
func (c *AppReminderController) guestDelete(claims *jwtutil.Claims, id uint64) {
|
|
r, err := gueststore.Get(uint64(claims.UserID), guestModuleSchedule, id)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
if guestScheduleFull(r).IsFinished {
|
|
c.jsonErr(400, 400, "该日程提醒已全部结束，无法删除")
|
|
return
|
|
}
|
|
if err = gueststore.Delete(uint64(claims.UserID), guestModuleSchedule, id); err != nil {
|
|
c.jsonErr(500, 500, "删除失败")
|
|
return
|
|
}
|
|
c.ok(nil)
|
|
}
|
|
|
|
func (c *AppReminderController) guestToggle(claims *jwtutil.Claims, id uint64) {
|
|
r, err := gueststore.Get(uint64(claims.UserID), guestModuleSchedule, id)
|
|
if err != nil {
|
|
c.jsonErr(404, 404, "日程未找到")
|
|
return
|
|
}
|
|
it := guestScheduleFull(r)
|
|
it.IsFinished = !it.IsFinished
|
|
it.UpdatedAt = time.Now().Format("2006-01-02 15:04:05")
|
|
if err = gueststore.Update(uint64(claims.UserID), guestModuleSchedule, id, it); err != nil {
|
|
c.jsonErr(500, 500, "操作失败")
|
|
return
|
|
}
|
|
c.ok(map[string]interface{}{"is_finished": it.IsFinished})
|
|
}
|