669 lines
19 KiB
Go
669 lines
19 KiB
Go
package controllers
|
|
|
|
import (
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
"server/pkg/identity"
|
|
"server/pkg/jwtutil"
|
|
"server/services"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
type AppOaController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
func (c *AppOaController) oaClaims() (*jwtutil.Claims, error) {
|
|
return identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndApp, identity.EndBackend)
|
|
}
|
|
|
|
func (c *AppOaController) oaErr(httpStatus, bizCode int, msg string) {
|
|
c.Ctx.Output.SetStatus(httpStatus)
|
|
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *AppOaController) oaOk(data interface{}) {
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *AppOaController) oaMyEmployee(claims *jwtutil.Claims) (*models.BackendEmployee, bool) {
|
|
uid := services.ResolveTenantUID(uint64(claims.TenantId), uint64(claims.UserID))
|
|
account := strings.TrimSpace(claims.Username)
|
|
var tu models.SystemTenantUser
|
|
if models.Orm.QueryTable(new(models.SystemTenantUser)).
|
|
Filter("uid", uid).Filter("tid", claims.TenantId).
|
|
Filter("delete_time__isnull", true).One(&tu) == nil {
|
|
if tu.Account != nil && strings.TrimSpace(*tu.Account) != "" {
|
|
account = strings.TrimSpace(*tu.Account)
|
|
}
|
|
}
|
|
if account == "" {
|
|
return nil, false
|
|
}
|
|
var emp models.BackendEmployee
|
|
if models.Orm.QueryTable(new(models.BackendEmployee)).
|
|
Filter("tid", claims.TenantId).Filter("account", account).
|
|
Filter("delete_time__isnull", true).One(&emp) != nil {
|
|
return nil, false
|
|
}
|
|
return &emp, true
|
|
}
|
|
|
|
func noticeItem(n models.OaNotice) map[string]interface{} {
|
|
publishTime := ""
|
|
if n.PublishTime != nil {
|
|
publishTime = n.PublishTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
return map[string]interface{}{
|
|
"id": n.ID,
|
|
"title": n.Title,
|
|
"notice_type": n.NoticeType,
|
|
"level": n.Level,
|
|
"is_top": n.IsTop,
|
|
"publisher_name": n.PublisherName,
|
|
"publish_time": publishTime,
|
|
"read_count": n.ReadCount,
|
|
"summary": oaTextSummary(n.Content, 60),
|
|
}
|
|
}
|
|
|
|
func oaTextSummary(content string, limit int) string {
|
|
text := strings.Join(strings.Fields(content), " ")
|
|
runes := []rune(text)
|
|
if limit > 0 && len(runes) > limit {
|
|
return string(runes[:limit]) + "…"
|
|
}
|
|
return text
|
|
}
|
|
|
|
func (c *AppOaController) NoticeList() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 20)
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
|
|
qs := models.Orm.QueryTable(new(models.OaNotice)).
|
|
Filter("is_deleted", 0).
|
|
Filter("tid", claims.TenantId).
|
|
Filter("status", 1)
|
|
if keyword != "" {
|
|
qs = qs.Filter("title__icontains", keyword)
|
|
}
|
|
|
|
total, _ := qs.Count()
|
|
|
|
var rows []models.OaNotice
|
|
_, err = qs.OrderBy("-is_top", "-publish_time", "-id").
|
|
Limit(pageSize).Offset((page - 1) * pageSize).All(&rows)
|
|
if err != nil && err != orm.ErrNoRows {
|
|
c.oaErr(500, 500, "查询失败")
|
|
return
|
|
}
|
|
list := make([]map[string]interface{}, 0, len(rows))
|
|
for _, n := range rows {
|
|
list = append(list, noticeItem(n))
|
|
}
|
|
|
|
c.oaOk(map[string]interface{}{"list": list, "total": total, "page": page, "pageSize": pageSize})
|
|
}
|
|
|
|
func (c *AppOaController) NoticeDetail() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
c.oaErr(400, 400, "无效的公告ID")
|
|
return
|
|
}
|
|
|
|
var n models.OaNotice
|
|
if err := models.Orm.QueryTable(new(models.OaNotice)).
|
|
Filter("id", id).Filter("tid", claims.TenantId).
|
|
Filter("is_deleted", 0).Filter("status", 1).One(&n); err != nil {
|
|
c.oaErr(404, 404, "公告不存在")
|
|
return
|
|
}
|
|
|
|
_, _ = models.Orm.Raw(
|
|
"UPDATE yz_backend_oa_notice SET read_count = read_count + 1 WHERE id = ?", id).Exec()
|
|
n.ReadCount++
|
|
|
|
item := noticeItem(n)
|
|
item["content"] = n.Content
|
|
c.oaOk(item)
|
|
}
|
|
|
|
func (c *AppOaController) oaDocActor(claims *jwtutil.Claims) services.OaDocActor {
|
|
return services.NewOaDocActor(claims.TenantId, uint64(claims.UserID))
|
|
}
|
|
|
|
func docItem(d models.OaDoc) map[string]interface{} {
|
|
updateTime := ""
|
|
if d.UpdateTime != nil {
|
|
updateTime = d.UpdateTime.Format("2006-01-02 15:04:05")
|
|
}
|
|
return map[string]interface{}{
|
|
"id": d.ID,
|
|
"title": d.Title,
|
|
"category_id": d.CategoryID,
|
|
"file_url": d.FileURL,
|
|
"file_name": d.FileName,
|
|
"ext": d.Ext,
|
|
"size": d.Size,
|
|
"doc_type": d.DocType,
|
|
"tags": d.Tags,
|
|
"summary": d.Summary,
|
|
"is_online": d.IsOnline,
|
|
"status": d.Status,
|
|
"version": d.Version,
|
|
"is_star": d.IsStar,
|
|
"owner_name": d.OwnerName,
|
|
"creator_name": d.CreatorName,
|
|
"view_count": d.ViewCount,
|
|
"download_count": d.DownCount,
|
|
"visibility": d.Visibility,
|
|
"create_time": d.CreateTime.Format("2006-01-02 15:04:05"),
|
|
"update_time": updateTime,
|
|
}
|
|
}
|
|
|
|
func (c *AppOaController) DocCategories() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
tree, err := services.OaDocCategoryTree(c.oaDocActor(claims), strings.TrimSpace(c.GetString("scope")))
|
|
if err != nil {
|
|
c.oaErr(400, 400, err.Error())
|
|
return
|
|
}
|
|
c.oaOk(tree)
|
|
}
|
|
|
|
func (c *AppOaController) DocList() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 20)
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
status, _ := c.GetInt("status", -1)
|
|
docType, _ := c.GetInt("doc_type", -1)
|
|
star, _ := c.GetInt("star", -1)
|
|
categoryID, _ := c.GetUint64("category_id")
|
|
|
|
actor := c.oaDocActor(claims)
|
|
list, total, err := services.OaDocList(actor, services.OaDocListParams{
|
|
Actor: actor,
|
|
Scope: strings.TrimSpace(c.GetString("scope")),
|
|
Keyword: strings.TrimSpace(c.GetString("keyword")),
|
|
CategoryID: categoryID,
|
|
Uncategorized: strings.TrimSpace(c.GetString("uncategorized")) == "1",
|
|
Visibility: -1,
|
|
Mine: strings.TrimSpace(c.GetString("mine")) == "1",
|
|
Status: status,
|
|
DocType: docType,
|
|
Star: star,
|
|
Page: page,
|
|
PageSize: pageSize,
|
|
})
|
|
if err != nil {
|
|
c.oaErr(400, 400, err.Error())
|
|
return
|
|
}
|
|
|
|
items := make([]map[string]interface{}, 0, len(list))
|
|
for _, d := range list {
|
|
items = append(items, docItem(d))
|
|
}
|
|
c.oaOk(map[string]interface{}{"list": items, "total": total, "page": page, "pageSize": pageSize})
|
|
}
|
|
|
|
func (c *AppOaController) DocDetail() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
c.oaErr(400, 400, "无效的文档ID")
|
|
return
|
|
}
|
|
doc, err := services.OaDocView(c.oaDocActor(claims), id)
|
|
if err != nil {
|
|
c.oaErr(404, 404, err.Error())
|
|
return
|
|
}
|
|
if strings.TrimSpace(doc.Content) != "" {
|
|
doc.IsOnline = 1
|
|
}
|
|
c.oaOk(docItem(*doc))
|
|
}
|
|
|
|
func (c *AppOaController) DocDownload() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
c.oaErr(400, 400, "无效的文档ID")
|
|
return
|
|
}
|
|
doc, err := services.OaDocDownload(c.oaDocActor(claims), id)
|
|
if err != nil {
|
|
c.oaErr(404, 404, err.Error())
|
|
return
|
|
}
|
|
c.oaOk(map[string]interface{}{
|
|
"id": doc.ID,
|
|
"title": doc.Title,
|
|
"file_url": doc.FileURL,
|
|
"file_name": doc.FileName,
|
|
"download_count": doc.DownCount,
|
|
})
|
|
}
|
|
|
|
func (c *AppOaController) DocStar() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
c.oaErr(400, 400, "无效的文档ID")
|
|
return
|
|
}
|
|
isStar, err := services.OaDocToggleStar(c.oaDocActor(claims), id)
|
|
if err != nil {
|
|
c.oaErr(400, 400, err.Error())
|
|
return
|
|
}
|
|
c.oaOk(map[string]interface{}{"is_star": isStar})
|
|
}
|
|
|
|
func (c *AppOaController) PayrollList() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 20)
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 20
|
|
}
|
|
|
|
emp, ok := c.oaMyEmployee(claims)
|
|
if !ok {
|
|
c.oaOk(map[string]interface{}{"list": []map[string]interface{}{}, "total": 0})
|
|
return
|
|
}
|
|
|
|
qs := models.Orm.QueryTable(new(models.BackendOaPayroll)).
|
|
Filter("tid", claims.TenantId).
|
|
Filter("employee_id", emp.ID).
|
|
Filter("is_deleted", 0)
|
|
if month := strings.TrimSpace(c.GetString("payroll_month")); compensationMonthPattern.MatchString(month) {
|
|
qs = qs.Filter("payroll_month", month)
|
|
}
|
|
|
|
total, _ := qs.Count()
|
|
|
|
var rows []models.BackendOaPayroll
|
|
if _, err := qs.OrderBy("-payroll_month", "-id").
|
|
Limit(pageSize).Offset((page - 1) * pageSize).All(&rows); err != nil && err != orm.ErrNoRows {
|
|
c.oaErr(500, 500, "查询失败")
|
|
return
|
|
}
|
|
list := make([]map[string]interface{}, 0, len(rows))
|
|
for _, row := range rows {
|
|
list = append(list, payrollMap(row))
|
|
}
|
|
|
|
c.oaOk(map[string]interface{}{"list": list, "total": total, "page": page, "pageSize": pageSize})
|
|
}
|
|
|
|
func (c *AppOaController) PayrollDetail() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
id, _ := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if id == 0 {
|
|
c.oaErr(400, 400, "无效的薪资单ID")
|
|
return
|
|
}
|
|
|
|
emp, ok := c.oaMyEmployee(claims)
|
|
if !ok {
|
|
c.oaErr(404, 404, "未找到您的员工信息")
|
|
return
|
|
}
|
|
|
|
var row models.BackendOaPayroll
|
|
if models.Orm.QueryTable(new(models.BackendOaPayroll)).
|
|
Filter("id", id).Filter("tid", claims.TenantId).
|
|
Filter("employee_id", emp.ID).Filter("is_deleted", 0).One(&row) != nil {
|
|
c.oaErr(404, 404, "薪资单不存在")
|
|
return
|
|
}
|
|
|
|
var items []models.BackendOaPayrollItem
|
|
_, _ = models.Orm.QueryTable(new(models.BackendOaPayrollItem)).
|
|
Filter("tid", claims.TenantId).Filter("payroll_id", id).
|
|
Filter("is_deleted", 0).OrderBy("sort_order", "id").All(&items)
|
|
if items == nil {
|
|
items = []models.BackendOaPayrollItem{}
|
|
}
|
|
|
|
data := payrollMap(row)
|
|
data["items"] = items
|
|
c.oaOk(data)
|
|
}
|
|
|
|
func (c *AppOaController) MyEmployeeFile() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
|
|
emp, ok := c.oaMyEmployee(claims)
|
|
if !ok {
|
|
c.oaErr(404, 404, "未找到您的员工信息")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
var file models.BackendEmployeeFile
|
|
if models.Orm.QueryTable(new(models.BackendEmployeeFile)).
|
|
Filter("tid", tid).Filter("is_deleted", 0).
|
|
Filter("employee_id", emp.ID).One(&file) != nil {
|
|
c.oaErr(404, 404, "您暂无员工档案")
|
|
return
|
|
}
|
|
|
|
var records []models.BackendEmployeeFileRecord
|
|
_, _ = models.Orm.QueryTable(new(models.BackendEmployeeFileRecord)).
|
|
Filter("tid", tid).Filter("is_deleted", 0).
|
|
Filter("employee_id", emp.ID).OrderBy("sort", "id").All(&records)
|
|
if records == nil {
|
|
records = []models.BackendEmployeeFileRecord{}
|
|
}
|
|
|
|
dtos := (&BackendEmployeeFileController{}).efAssembleDTOList(tid, []models.BackendEmployeeFile{file})
|
|
|
|
c.oaOk(map[string]interface{}{"file": dtos[0], "records": records})
|
|
}
|
|
|
|
func (c *AppOaController) Dashboard() {
|
|
claims, err := c.oaClaims()
|
|
if err != nil {
|
|
c.oaErr(identity.Status(err), identity.Status(err), err.Error())
|
|
return
|
|
}
|
|
uid := uint64(claims.UserID)
|
|
|
|
c.oaOk(map[string]interface{}{
|
|
"schedule_stats": c.oaDashboardScheduleStats(claims.TenantId, uid),
|
|
"reimburse": c.oaDashboardReimburse(uint64(claims.TenantId), uid),
|
|
"notices": c.oaDashboardNotices(claims.TenantId),
|
|
"today_schedules": c.oaDashboardTodaySchedules(claims.TenantId, uid),
|
|
})
|
|
}
|
|
|
|
func (c *AppOaController) oaDashboardScheduleStats(tid int, uid uint64) map[string]interface{} {
|
|
now := time.Now()
|
|
today := now.Format("2006-01-02")
|
|
weekday := int(now.Weekday())
|
|
if weekday == 0 {
|
|
weekday = 7
|
|
}
|
|
weekStart := now.AddDate(0, 0, -(weekday - 1)).Format("2006-01-02")
|
|
weekEnd := now.AddDate(0, 0, 7-weekday).Format("2006-01-02")
|
|
monthStart := now.Format("2006-01") + "-01"
|
|
|
|
base := func() orm.QuerySeter {
|
|
return models.Orm.QueryTable(new(models.OaSchedule)).
|
|
Filter("is_deleted", 0).
|
|
Filter("tid", tid).
|
|
Filter("user_id", uid)
|
|
}
|
|
|
|
todayTotal, _ := base().Filter("schedule_date", today).Count()
|
|
todayDone, _ := base().Filter("schedule_date", today).Filter("status", 1).Count()
|
|
weekTotal, _ := base().Filter("schedule_date__gte", weekStart).Filter("schedule_date__lte", weekEnd).Count()
|
|
weekDone, _ := base().Filter("schedule_date__gte", weekStart).Filter("schedule_date__lte", weekEnd).Filter("status", 1).Count()
|
|
monthTotal, _ := base().Filter("schedule_date__gte", monthStart).Count()
|
|
monthDone, _ := base().Filter("schedule_date__gte", monthStart).Filter("status", 1).Count()
|
|
overdue, _ := base().Filter("schedule_date__lt", today).Filter("status", 0).Count()
|
|
|
|
return map[string]interface{}{
|
|
"today_total": todayTotal,
|
|
"today_done": todayDone,
|
|
"week_total": weekTotal,
|
|
"week_done": weekDone,
|
|
"month_total": monthTotal,
|
|
"month_done": monthDone,
|
|
"overdue": overdue,
|
|
}
|
|
}
|
|
|
|
func (c *AppOaController) oaDashboardTodaySchedules(tid int, uid uint64) []map[string]interface{} {
|
|
today := time.Now().Format("2006-01-02")
|
|
var rows []models.OaSchedule
|
|
_, _ = models.Orm.QueryTable(new(models.OaSchedule)).
|
|
Filter("is_deleted", 0).Filter("tid", tid).Filter("user_id", uid).
|
|
Filter("schedule_date", today).
|
|
OrderBy("status", "start_time", "id").Limit(50).All(&rows)
|
|
out := make([]map[string]interface{}, 0, len(rows))
|
|
for _, s := range rows {
|
|
out = append(out, map[string]interface{}{
|
|
"id": s.ID,
|
|
"title": s.Title,
|
|
"schedule_date": s.ScheduleDate,
|
|
"start_time": s.StartTime,
|
|
"end_time": s.EndTime,
|
|
"all_day": s.AllDay,
|
|
"color": s.Color,
|
|
"priority": s.Priority,
|
|
"status": s.Status,
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *AppOaController) oaDashboardNotices(tid int) []map[string]interface{} {
|
|
var rows []models.OaNotice
|
|
_, _ = models.Orm.QueryTable(new(models.OaNotice)).
|
|
Filter("is_deleted", 0).Filter("tid", tid).Filter("status", 1).
|
|
OrderBy("-is_top", "-publish_time", "-id").Limit(5).All(&rows)
|
|
out := make([]map[string]interface{}, 0, len(rows))
|
|
for _, n := range rows {
|
|
out = append(out, noticeItem(n))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *AppOaController) oaDashboardReimburse(tid, uid uint64) map[string]interface{} {
|
|
now := time.Now()
|
|
y, m, _ := now.Date()
|
|
today := time.Date(y, m, now.Day(), 0, 0, 0, 0, now.Location())
|
|
tomorrow := today.AddDate(0, 0, 1)
|
|
weekday := int(today.Weekday())
|
|
if weekday == 0 {
|
|
weekday = 7
|
|
}
|
|
weekStart := today.AddDate(0, 0, -(weekday - 1))
|
|
monthStart := time.Date(y, m, 1, 0, 0, 0, 0, now.Location())
|
|
yearStart := time.Date(y, 1, 1, 0, 0, 0, 0, now.Location())
|
|
|
|
newStat := func() map[string]interface{} {
|
|
return map[string]interface{}{"total": 0.0, "paid": 0.0, "unpaid": 0.0, "count": 0}
|
|
}
|
|
addTo := func(stat map[string]interface{}, row *models.BackendReimbursement) {
|
|
stat["total"] = stat["total"].(float64) + row.TotalAmount
|
|
stat["count"] = stat["count"].(int) + 1
|
|
if row.Status == 5 {
|
|
stat["paid"] = stat["paid"].(float64) + row.TotalAmount
|
|
} else {
|
|
stat["unpaid"] = stat["unpaid"].(float64) + row.TotalAmount
|
|
}
|
|
}
|
|
inRange := func(t, start, end time.Time) bool {
|
|
return !t.Before(start) && t.Before(end)
|
|
}
|
|
|
|
weekStat, monthStat, yearStat := newStat(), newStat(), newStat()
|
|
monthKeys := make([]string, 0, 6)
|
|
monthStats := map[string]map[string]interface{}{}
|
|
for i := 5; i >= 0; i-- {
|
|
key := time.Date(y, m-time.Month(i), 1, 0, 0, 0, 0, now.Location()).Format("2006-01")
|
|
monthKeys = append(monthKeys, key)
|
|
monthStats[key] = newStat()
|
|
}
|
|
statusNames := map[int8]string{0: "草稿", 1: "审批中", 2: "已通过", 3: "已驳回", 4: "已撤回", 5: "已打款"}
|
|
statusDist := map[string]interface{}{}
|
|
|
|
var rows []models.BackendReimbursement
|
|
if _, err := models.Orm.QueryTable(new(models.BackendReimbursement)).
|
|
Filter("tid", tid).Filter("user_id", uid).Filter("is_deleted", 0).
|
|
All(&rows); err != nil {
|
|
return map[string]interface{}{
|
|
"week": weekStat, "month": monthStat, "year": yearStat,
|
|
"trend": []map[string]interface{}{}, "status_dist": statusDist, "expense_types": []map[string]interface{}{},
|
|
}
|
|
}
|
|
|
|
for i := range rows {
|
|
row := &rows[i]
|
|
created := row.CreateTime
|
|
if inRange(created, weekStart, tomorrow) {
|
|
addTo(weekStat, row)
|
|
}
|
|
if inRange(created, monthStart, tomorrow) {
|
|
addTo(monthStat, row)
|
|
}
|
|
if inRange(created, yearStart, tomorrow) {
|
|
addTo(yearStat, row)
|
|
}
|
|
if st, ok := monthStats[created.Format("2006-01")]; ok {
|
|
addTo(st, row)
|
|
}
|
|
sk := strconv.Itoa(int(row.Status))
|
|
dist, ok := statusDist[sk].(map[string]interface{})
|
|
if !ok {
|
|
dist = map[string]interface{}{"name": statusNames[row.Status], "count": 0, "amount": 0.0}
|
|
statusDist[sk] = dist
|
|
}
|
|
dist["count"] = dist["count"].(int) + 1
|
|
dist["amount"] = dist["amount"].(float64) + row.TotalAmount
|
|
}
|
|
|
|
trend := make([]map[string]interface{}, 0, len(monthKeys))
|
|
for _, key := range monthKeys {
|
|
st := monthStats[key]
|
|
trend = append(trend, map[string]interface{}{
|
|
"month": key, "total": st["total"], "paid": st["paid"],
|
|
"unpaid": st["unpaid"], "count": st["count"],
|
|
})
|
|
}
|
|
|
|
paidIDs := map[uint64]bool{}
|
|
for i := range rows {
|
|
if rows[i].Status == 5 {
|
|
paidIDs[rows[i].ID] = true
|
|
}
|
|
}
|
|
expenseTypes := []map[string]interface{}{}
|
|
paidIDList := make([]uint64, 0, len(paidIDs))
|
|
for id := range paidIDs {
|
|
paidIDList = append(paidIDList, id)
|
|
}
|
|
var items []models.BackendReimbursementItem
|
|
if len(paidIDList) > 0 {
|
|
if _, err := models.Orm.QueryTable(new(models.BackendReimbursementItem)).
|
|
Filter("reimbursement_id__in", paidIDList).Filter("is_deleted", 0).
|
|
All(&items); err == nil {
|
|
typeAgg := map[string]*struct {
|
|
count int
|
|
amount float64
|
|
}{}
|
|
for i := range items {
|
|
if !paidIDs[items[i].ReimbursementID] {
|
|
continue
|
|
}
|
|
name := strings.TrimSpace(items[i].ExpenseType)
|
|
if name == "" {
|
|
name = "未分类"
|
|
}
|
|
agg, ok := typeAgg[name]
|
|
if !ok {
|
|
agg = &struct {
|
|
count int
|
|
amount float64
|
|
}{}
|
|
typeAgg[name] = agg
|
|
}
|
|
agg.count++
|
|
agg.amount += items[i].Amount
|
|
}
|
|
for name, agg := range typeAgg {
|
|
expenseTypes = append(expenseTypes, map[string]interface{}{
|
|
"name": name, "count": agg.count, "amount": agg.amount,
|
|
})
|
|
}
|
|
sort.Slice(expenseTypes, func(i, j int) bool {
|
|
return expenseTypes[i]["amount"].(float64) > expenseTypes[j]["amount"].(float64)
|
|
})
|
|
}
|
|
}
|
|
|
|
return map[string]interface{}{
|
|
"week": weekStat, "month": monthStat, "year": yearStat,
|
|
"trend": trend, "status_dist": statusDist, "expense_types": expenseTypes,
|
|
}
|
|
}
|