kenneth/projectx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v1

Browse Source
This commit is contained in:
kenneth
2025-04-14 15:42:22 +08:00
parent 371b89ee8d
commit 461531c308
133 changed files with 58 additions and 14400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
internal/erpserver/handler/budget/budget.go
View File

@@ -1,274 +0,0 @@
package budget
import (
"errors"
"net/http"
"strconv"
"strings"
"time"
"management/internal/db/model/form"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/pkg/convertor"
"management/internal/pkg/know"
"management/internal/pkg/middleware"
"management/internal/pkg/tpl"
"management/internal/pkg/tpl/html"
"github.com/jackc/pgx/v5/pgtype"
)
type BudgetHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
Data(w http.ResponseWriter, r *http.Request)
}
type budgetHandler struct {
render tpl.Renderer
biz biz.IBiz
mi middleware.Middleware
}
var _ BudgetHandler = (*budgetHandler)(nil)
func NewBudgetHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.Middleware) *budgetHandler {
return &budgetHandler{
render: render,
biz: biz,
mi: mi,
}
}
func (h *budgetHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
pp, _ := h.biz.ProjectV1().ListHtml(ctx)
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.BudgetCategory)
h.render.HTML(w, r, "budget/list.tmpl", map[string]any{
"Statuses": html.NewSelectControls(html.Statuses, "0"),
"Projects": html.NewSelectControls(pp, "0"),
"Categories": html.NewSelectControls(cc, "0"),
})
case http.MethodPost:
ctx := r.Context()
project := convertor.ConvertInt[int64](r.PostFormValue("project"), 9999)
if project == 0 {
project = 9999
}
budgetType := convertor.ConvertInt[int32](r.PostFormValue("budgetType"), 9999)
if budgetType == 0 {
budgetType = 9999
}
category := convertor.ConvertInt[int32](r.PostFormValue("category"), 9999)
if category == 0 {
category = 9999
}
title := strings.TrimSpace(r.PostFormValue("title"))
var search string
if len(title) > 0 {
search = "%" + title + "%"
if strings.HasSuffix(title, ":") {
search = title[:len(title)-1] + "%"
}
}
arg := &db.ListBudgetConditionParam{
ProjectID: project,
BudgetType: budgetType,
Category: category,
IsTitle: len(search) > 0,
Title: search,
Status: convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
PageID: convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
PageSize: convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
}
arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
res, total, err := h.biz.BudgetV1().List(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: total,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *budgetHandler) Add(w http.ResponseWriter, r *http.Request) {
h.render.HTML(w, r, "budget/edit.tmpl", map[string]any{
"Item": &form.BudgetForm{
BudgetType: 1,
},
"Statuses": html.NewSelectControls(html.Statuses, "0"),
})
}
func (h *budgetHandler) Edit(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
id := convertor.QueryInt[int64](vars, "id", 0)
budget := &form.BudgetForm{}
ctx := r.Context()
if id > 0 {
if cus, err := h.biz.BudgetV1().Get(ctx, id); err == nil {
budget = budget.ToForm(cus)
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.CreatedUserID); err == nil {
budget.CreatedName = u.Username
}
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.UpdatedUserID); err == nil {
budget.UpdatedName = u.Username
}
}
}
h.render.HTML(w, r, "budget/edit.tmpl", map[string]any{
"Item": budget,
"Statuses": html.NewSelectControls(html.Statuses, strconv.Itoa(int(budget.Status))),
})
}
func (h *budgetHandler) Save(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
data, err := validForm(r)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
authUser := h.mi.AuthUser(ctx)
if data.ID > 0 {
arg := &db.UpdateBudgetParams{
ID: data.ID,
ProjectID: pgtype.Int8{
Int64: data.ProjectID,
Valid: true,
},
Name: pgtype.Text{
String: data.Name,
Valid: true,
},
BudgetType: pgtype.Int4{
Int32: data.BudgetType,
Valid: true,
},
Category: pgtype.Int4{
Int32: data.Category,
Valid: true,
},
StartAt: pgtype.Timestamptz{
Time: data.StartAt,
Valid: true,
},
EndAt: pgtype.Timestamptz{
Time: data.EndAt,
Valid: true,
},
Amount: data.AmountF,
UsedAmount: data.UsedAmountF,
RemainingAmount: data.RemainingAmountF,
Remark: pgtype.Text{
String: data.Remark,
Valid: true,
},
Status: pgtype.Int2{
Int16: data.Status,
Valid: true,
},
UpdatedUserID: pgtype.Int4{
Int32: authUser.ID,
Valid: true,
},
}
_, err := h.biz.BudgetV1().Update(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
} else {
arg := &db.CreateBudgetParams{
ProjectID: data.ProjectID,
Name: data.Name,
BudgetType: data.BudgetType,
Category: data.Category,
StartAt: data.StartAt,
EndAt: data.EndAt,
Amount: data.AmountF,
UsedAmount: data.UsedAmountF,
RemainingAmount: data.RemainingAmountF,
Remark: data.Remark,
CreatedUserID: authUser.ID,
}
_, err := h.biz.BudgetV1().Create(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
}
}
func (h *budgetHandler) Data(w http.ResponseWriter, r *http.Request) {}
func validForm(r *http.Request) (form.BudgetForm, error) {
var err error
data := form.BudgetForm{}
data.ID = convertor.ConvertInt[int64](r.PostFormValue("ID"), 0)
data.ProjectID, err = strconv.ParseInt(r.PostFormValue("ProjectID"), 10, 64)
if err != nil || data.ProjectID == 0 {
return data, errors.New("项目不能为空")
}
data.Name = r.PostFormValue("Name")
if len(data.Name) == 0 {
return data, errors.New("预算名称不能为空")
}
budgetType, err := strconv.ParseInt(r.PostFormValue("BudgetType"), 10, 32)
if err != nil {
return data, errors.New("预算类型不能为空")
}
data.BudgetType = int32(budgetType)
category, err := strconv.ParseInt(r.PostFormValue("Category"), 10, 32)
if err != nil {
return data, errors.New("预算类别不能为空")
}
data.Category = int32(category)
data.StartAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("StartAt"), time.Local)
if err != nil {
return data, errors.New("开始时间格式错误")
}
data.EndAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("EndAt"), time.Local)
if err != nil {
return data, errors.New("结束时间格式错误")
}
if err := data.AmountF.Scan(r.PostFormValue("Amount")); err != nil {
return data, errors.New("预算金额格式错误")
}
if err := data.UsedAmountF.Scan(r.PostFormValue("UsedAmount")); err != nil {
return data, errors.New("已支付金额格式错误")
}
if err := data.RemainingAmountF.Scan(r.PostFormValue("RemainingAmount")); err != nil {
return data, errors.New("剩余金额格式错误")
}
data.Remark = r.PostFormValue("Remark")
data.Status = convertor.ConvertInt[int16](r.PostFormValue("Status"), 9999)
return data, nil
}

209
internal/erpserver/handler/customer/customer.go
View File

@@ -1,209 +0,0 @@
package customer
import (
"net/http"
"strconv"
"strings"
"management/internal/db/model/form"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/pkg/convertor"
"management/internal/pkg/know"
"management/internal/pkg/middleware"
"management/internal/pkg/snowflake"
"management/internal/pkg/tpl"
"management/internal/pkg/tpl/html"
"github.com/jackc/pgx/v5/pgtype"
)
type CustomerHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
}
type customerHandler struct {
render tpl.Renderer
biz biz.IBiz
mi middleware.Middleware
}
var _ CustomerHandler = (*customerHandler)(nil)
func NewCustomerHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.Middleware) *customerHandler {
return &customerHandler{
render: render,
biz: biz,
mi: mi,
}
}
func (h *customerHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerCategory)
ss, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerSource)
h.render.HTML(w, r, "customer/list.tmpl", map[string]any{
"Statuses": html.NewSelectControls(html.Statuses, "0"),
"Categories": html.NewSelectControls(cc, "0"),
"Sources": html.NewSelectControls(ss, "0"),
})
case http.MethodPost:
ctx := r.Context()
category := convertor.ConvertInt[int32](r.PostFormValue("category"), 9999)
if category == 0 {
category = 9999
}
source := convertor.ConvertInt[int32](r.PostFormValue("source"), 9999)
if source == 0 {
source = 9999
}
title := strings.TrimSpace(r.PostFormValue("title"))
var search string
if len(title) > 0 {
search = "%" + title + "%"
if strings.HasSuffix(title, ":") {
search = title[:len(title)-1] + "%"
}
}
arg := &db.ListCustomerConditionParam{
IsTitle: len(search) > 0,
Title: search,
Status: convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
Category: category,
Source: source,
PageID: convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
PageSize: convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
}
arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
res, total, err := h.biz.CustomerV1().List(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: total,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *customerHandler) Add(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerCategory)
ss, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerSource)
h.render.HTML(w, r, "customer/edit.tmpl", map[string]any{
"Item": &form.CustomerForm{},
"Statuses": html.NewSelectControls(html.Statuses, "0"),
"Categories": html.NewSelectControls(cc, "0"),
"Sources": html.NewSelectControls(ss, "0"),
})
}
func (h *customerHandler) Edit(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
id := convertor.ConvertInt[int64](vars.Get("id"), 0)
customer := &form.CustomerForm{}
ctx := r.Context()
if id > 0 {
if cus, err := h.biz.CustomerV1().Get(ctx, id); err == nil {
customer = customer.ToForm(cus)
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.CreatedBy); err == nil {
customer.CreatedBy = u.Username
}
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.UpdatedBy); err == nil {
customer.UpdatedBy = u.Username
}
}
}
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerCategory)
ss, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.CustomerSource)
h.render.HTML(w, r, "customer/edit.tmpl", map[string]any{
"Item": customer,
"Statuses": html.NewSelectControls(html.Statuses, strconv.Itoa(int(customer.Status))),
"Categories": html.NewSelectControls(cc, strconv.Itoa(int(customer.Category))),
"Sources": html.NewSelectControls(ss, strconv.Itoa(int(customer.Source))),
})
}
func (h *customerHandler) Save(w http.ResponseWriter, r *http.Request) {
data := &form.CustomerForm{}
if err := form.BindForm(r, data); err != nil {
h.render.JSONERR(w, err.Error())
return
}
ctx := r.Context()
authUser := h.mi.AuthUser(ctx)
if data.ID > 0 {
arg := &db.UpdateCustomerParams{
ID: data.ID,
Name: pgtype.Text{
String: data.Name,
Valid: true,
},
Category: pgtype.Int4{
Int32: data.Category,
Valid: true,
},
Source: pgtype.Int4{
Int32: data.Source,
Valid: true,
},
Address: pgtype.Text{
String: data.Address,
Valid: true,
},
ContactName: pgtype.Text{
String: data.ContactName,
Valid: true,
},
ContactPhone: pgtype.Text{
String: data.ContactPhone,
Valid: true,
},
Status: pgtype.Int2{
Int16: data.Status,
Valid: true,
},
UpdatedBy: pgtype.Int4{
Int32: authUser.ID,
Valid: true,
},
}
_, err := h.biz.CustomerV1().Update(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
} else {
arg := &db.CreateCustomerParams{
ID: snowflake.GetId(),
Name: data.Name,
Category: data.Category,
Source: data.Source,
Address: data.Address,
ContactName: data.ContactName,
ContactPhone: data.ContactPhone,
CreatedBy: authUser.ID,
}
_, err := h.biz.CustomerV1().Create(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
}
}

231
internal/erpserver/handler/expense/expense.go
View File

@@ -1,231 +0,0 @@
package expense
import (
"errors"
"net/http"
"strconv"
"strings"
"time"
"management/internal/db/model/form"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/pkg/convertor"
"management/internal/pkg/know"
"management/internal/pkg/middleware"
"management/internal/pkg/tpl"
"management/internal/pkg/tpl/html"
"github.com/jackc/pgx/v5/pgtype"
)
type ExpenseHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
}
type expenseHandler struct {
render tpl.Renderer
biz biz.IBiz
mi middleware.Middleware
}
var _ ExpenseHandler = (*expenseHandler)(nil)
func NewExpenseHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.Middleware) *expenseHandler {
return &expenseHandler{
render: render,
biz: biz,
mi: mi,
}
}
func (h *expenseHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
pp, _ := h.biz.ProjectV1().ListHtml(ctx)
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.ExpenseCategory)
h.render.HTML(w, r, "expense/list.tmpl", map[string]any{
"Statuses": html.NewSelectControls(html.Statuses, "0"),
"Projects": html.NewSelectControls(pp, "0"),
"Categories": html.NewSelectControls(cc, "0"),
})
case http.MethodPost:
ctx := r.Context()
project := convertor.ConvertInt[int64](r.PostFormValue("project"), 9999)
if project == 0 {
project = 9999
}
budget := convertor.ConvertInt[int64](r.PostFormValue("budget"), 9999)
if budget == 0 {
budget = 9999
}
category := convertor.ConvertInt[int32](r.PostFormValue("category"), 9999)
if category == 0 {
category = 9999
}
title := strings.TrimSpace(r.PostFormValue("title"))
var search string
if len(title) > 0 {
search = "%" + title + "%"
if strings.HasSuffix(title, ":") {
search = title[:len(title)-1] + "%"
}
}
arg := &db.ListExpenseConditionParam{
ProjectID: project,
BudgetID: budget,
ExpenseType: category,
IsTitle: len(search) > 0,
Title: search,
Status: convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
PageID: convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
PageSize: convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
}
arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
res, total, err := h.biz.ExpenseV1().List(ctx, arg)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: total,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *expenseHandler) Add(w http.ResponseWriter, r *http.Request) {
h.render.HTML(w, r, "expense/edit.tmpl", map[string]any{
"Item": &form.ExpenseForm{},
"Statuses": html.NewSelectControls(html.Statuses, "0"),
})
}
func (h *expenseHandler) Edit(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
id := convertor.QueryInt[int64](vars, "id", 0)
expense := &form.ExpenseForm{}
ctx := r.Context()
if id > 0 {
if cus, err := h.biz.ExpenseV1().Get(ctx, id); err == nil {
expense = expense.ToForm(cus)
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.CreatedUserID); err == nil {
expense.CreatedName = u.Username
}
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.UpdatedUserID); err == nil {
expense.UpdatedName = u.Username
}
}
}
h.render.HTML(w, r, "expense/edit.tmpl", map[string]any{
"Item": expense,
"Statuses": html.NewSelectControls(html.Statuses, strconv.Itoa(int(expense.Status))),
})
}
func (h *expenseHandler) Save(w http.ResponseWriter, r *http.Request) {
data, err := validForm(r)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
ctx := r.Context()
authUser := h.mi.AuthUser(ctx)
if data.ID > 0 {
arg := &db.UpdateExpenseParams{
ID: data.ID,
ProjectID: pgtype.Int8{
Int64: data.ProjectID,
Valid: true,
},
BudgetID: pgtype.Int8{
Int64: data.BudgetID,
Valid: true,
},
Amount: data.AmountF,
ExpensesAt: pgtype.Timestamptz{
Time: data.ExpensesAt,
Valid: true,
},
ExpensesType: pgtype.Int4{
Int32: data.ExpensesType,
Valid: true,
},
Remark: pgtype.Text{
String: data.Remark,
Valid: true,
},
Status: pgtype.Int2{
Int16: data.Status,
Valid: true,
},
UpdatedUserID: pgtype.Int4{
Int32: authUser.ID,
Valid: true,
},
}
_, err := h.biz.ExpenseV1().Update(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
} else {
arg := &db.CreateExpenseParams{
ProjectID: data.ProjectID,
BudgetID: data.BudgetID,
Amount: data.AmountF,
ExpensesAt: data.ExpensesAt,
ExpensesType: data.ExpensesType,
Remark: data.Remark,
Status: data.Status,
CreatedUserID: authUser.ID,
}
_, err := h.biz.ExpenseV1().Create(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
}
}
func validForm(r *http.Request) (form.ExpenseForm, error) {
var err error
data := form.ExpenseForm{}
data.ID = convertor.ConvertInt[int64](r.PostFormValue("ID"), 0)
data.ProjectID, err = strconv.ParseInt(r.PostFormValue("ProjectID"), 10, 64)
if err != nil || data.ProjectID == 0 {
return data, errors.New("项目不能为空")
}
data.BudgetID, err = strconv.ParseInt(r.PostFormValue("BudgetID"), 10, 64)
if err := data.AmountF.Scan(r.PostFormValue("Amount")); err != nil {
return data, errors.New("报销金额格式错误")
}
data.ExpensesAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("ExpensesAt"), time.Local)
if err != nil {
return data, errors.New("报销时间格式错误")
}
expensesType, err := strconv.ParseInt(r.PostFormValue("ExpensesType"), 10, 64)
if err != nil || expensesType == 0 {
return data, errors.New("报销类型不能为空")
}
data.ExpensesType = int32(expensesType)
data.Status = convertor.ConvertInt[int16](r.PostFormValue("Status"), 9999)
return data, nil
}

249
internal/erpserver/handler/income/income.go
View File

@@ -1,249 +0,0 @@
package income
import (
"errors"
"net/http"
"strconv"
"strings"
"time"
"management/internal/db/model/form"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/pkg/convertor"
"management/internal/pkg/know"
"management/internal/pkg/middleware"
"management/internal/pkg/tpl"
"management/internal/pkg/tpl/html"
"github.com/jackc/pgx/v5/pgtype"
)
type IncomeHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
}
type incomeHandler struct {
render tpl.Renderer
biz biz.IBiz
mi middleware.Middleware
}
var _ IncomeHandler = (*incomeHandler)(nil)
func NewIncomeHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.Middleware) *incomeHandler {
return &incomeHandler{
render: render,
biz: biz,
mi: mi,
}
}
func (h *incomeHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
ctx := r.Context()
pp, _ := h.biz.ProjectV1().ListHtml(ctx)
cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.IncomeCategory)
h.render.HTML(w, r, "income/list.tmpl", map[string]any{
"Statuses": html.NewSelectControls(html.Statuses, "0"),
"Projects": html.NewSelectControls(pp, "0"),
"Categories": html.NewSelectControls(cc, "0"),
})
case http.MethodPost:
ctx := r.Context()
project := convertor.ConvertInt[int64](r.PostFormValue("project"), 9999)
if project == 0 {
project = 9999
}
budget := convertor.ConvertInt[int64](r.PostFormValue("budget"), 9999)
if budget == 0 {
budget = 9999
}
category := convertor.ConvertInt[int32](r.PostFormValue("category"), 9999)
if category == 0 {
category = 9999
}
title := strings.TrimSpace(r.PostFormValue("title"))
var search string
if len(title) > 0 {
search = "%" + title + "%"
if strings.HasSuffix(title, ":") {
search = title[:len(title)-1] + "%"
}
}
arg := &db.ListIncomeConditionParam{
ProjectID: project,
BudgetID: budget,
IncomeType: category,
IsTitle: len(search) > 0,
Title: search,
Status: convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
PageID: convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
PageSize: convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
}
arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
res, total, err := h.biz.IncomeV1().List(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: total,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *incomeHandler) Add(w http.ResponseWriter, r *http.Request) {
h.render.HTML(w, r, "income/edit.tmpl", map[string]any{
"Item": &form.IncomeForm{},
"Statuses": html.NewSelectControls(html.Statuses, "0"),
})
}
func (h *incomeHandler) Edit(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
id := convertor.ConvertInt[int64](vars.Get("id"), 0)
income := &form.IncomeForm{}
ctx := r.Context()
if id > 0 {
if cus, err := h.biz.IncomeV1().Get(ctx, id); err == nil {
income = income.ToForm(cus)
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.CreatedUserID); err == nil {
income.CreatedName = u.Username
}
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.UpdatedUserID); err == nil {
income.UpdatedName = u.Username
}
}
}
h.render.HTML(w, r, "income/edit.tmpl", map[string]any{
"Item": income,
"Statuses": html.NewSelectControls(html.Statuses, strconv.Itoa(int(income.Status))),
})
}
func (h *incomeHandler) Save(w http.ResponseWriter, r *http.Request) {
data, err := validForm(r)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
ctx := r.Context()
authUser := h.mi.AuthUser(ctx)
if data.ID > 0 {
arg := &db.UpdateIncomeParams{
ID: data.ID,
ProjectID: pgtype.Int8{
Int64: data.ProjectID,
Valid: true,
},
BudgetID: pgtype.Int8{
Int64: data.BudgetID,
Valid: true,
},
Amount: data.AmountF,
IncomeAt: pgtype.Timestamptz{
Time: data.IncomeAt,
Valid: true,
},
IncomeType: pgtype.Int4{
Int32: data.IncomeType,
Valid: true,
},
IncomeBank: pgtype.Int4{
Int32: data.IncomeBank,
Valid: true,
},
Remark: pgtype.Text{
String: data.Remark,
Valid: true,
},
Status: pgtype.Int2{
Int16: data.Status,
Valid: true,
},
UpdatedUserID: pgtype.Int4{
Int32: authUser.ID,
Valid: true,
},
}
_, err := h.biz.IncomeV1().Update(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
} else {
arg := &db.CreateIncomeParams{
ProjectID: data.ProjectID,
BudgetID: data.BudgetID,
Amount: data.AmountF,
IncomeAt: data.IncomeAt,
IncomeType: data.IncomeType,
IncomeBank: data.IncomeBank,
Remark: data.Remark,
Status: data.Status,
CreatedUserID: authUser.ID,
}
_, err := h.biz.IncomeV1().Create(ctx, arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
}
}
func validForm(r *http.Request) (form.IncomeForm, error) {
var err error
data := form.IncomeForm{}
data.ID = convertor.ConvertInt[int64](r.PostFormValue("ID"), 0)
data.ProjectID, err = strconv.ParseInt(r.PostFormValue("ProjectID"), 10, 64)
if err != nil || data.ProjectID == 0 {
return data, errors.New("项目不能为空")
}
data.BudgetID, err = strconv.ParseInt(r.PostFormValue("BudgetID"), 10, 64)
if err != nil {
data.BudgetID = 0
}
if err := data.AmountF.Scan(r.PostFormValue("Amount")); err != nil {
return data, errors.New("报销金额格式错误")
}
data.IncomeAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("IncomeAt"), time.Local)
if err != nil {
return data, errors.New("回款时间格式错误")
}
incomeType, err := strconv.ParseInt(r.PostFormValue("IncomeType"), 10, 64)
if err != nil {
return data, errors.New("收入类型数据错误")
}
data.IncomeType = int32(incomeType)
incomeBank, err := strconv.ParseInt(r.PostFormValue("IncomeBank"), 10, 64)
if err != nil {
return data, errors.New("收入银行数据错误")
}
data.IncomeBank = int32(incomeBank)
data.Remark = r.PostFormValue("Remark")
data.Status = convertor.ConvertInt[int16](r.PostFormValue("Status"), 9999)
return data, nil
}

369
internal/erpserver/handler/project/dashboard.go
View File

@@ -1,369 +0,0 @@
package project
import (
"context"
"fmt"
"net/http"
"management/internal/db/model/view"
"management/internal/pkg/convertor"
"management/internal/pkg/tpl"
)
func (h *projectHandler) Dashboard(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
pp, _ := h.biz.ProjectV1().ListHtml(r.Context())
h.render.HTML(w, r, "project/dashboard.tmpl", map[string]any{
"Projects": pp,
})
case http.MethodPost:
ctx := r.Context()
t := r.PostFormValue("type")
if t == "project" {
var projectIncome float64
var projectExpense float64
projectID := convertor.ConvertInt[int64](r.PostFormValue("projectID"), 0)
if projectID == 0 {
si, _ := h.biz.IncomeV1().Sum(ctx)
projectIncome = convertor.NumericToFloat64(si)
se, _ := h.biz.ExpenseV1().Sum(ctx)
projectExpense = convertor.NumericToFloat64(se)
} else {
pi, _ := h.biz.IncomeV1().SumByProjectID(ctx, projectID)
projectIncome = convertor.NumericToFloat64(pi)
pe, _ := h.biz.ExpenseV1().SumByProjectID(ctx, projectID)
projectExpense = convertor.NumericToFloat64(pe)
}
projectProfit := projectIncome - projectExpense
var projectProfitRate float64 = 0
if projectExpense > 0 {
projectProfitRate = projectProfit / projectExpense
}
res := &view.DashboardProject{
ProjectIncome: projectIncome,
ProjectExpense: projectExpense,
ProjectProfit: projectProfit,
ProjectProfitRate: fmt.Sprintf("%0.2f%%", projectProfitRate*100),
IncomeExpenseEcharts: h.incomeExpenseEcharts(ctx, projectID),
IncomeEcharts: h.incomeEcharts(ctx, projectID),
ExpenseEcharts: h.expenseEcharts(ctx, projectID),
}
h.render.JSON(w, tpl.Response{Success: true, Message: "ok", Data: res})
return
} else if t == "budget" {
}
h.render.JSONERR(w, "failed to valid type")
default:
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
}
}
func (h *projectHandler) incomeExpenseEcharts(ctx context.Context, projectId int64) view.EchartsOption {
var name []string
var income []float64
var expense []float64
if projectId == 0 {
rows, err := h.biz.ProjectV1().Statistics(ctx)
if err != nil || len(rows) == 0 {
return view.EchartsOption{}
}
for _, row := range rows {
name = append(name, row.Name)
income = append(income, convertor.NumericToFloat64(row.Income))
expense = append(expense, convertor.NumericToFloat64(row.Expense))
}
} else {
row, err := h.biz.ProjectV1().StatisticsItem(ctx, projectId)
if err != nil || row == nil {
return view.EchartsOption{}
}
name = append(name, row.Name)
income = append(income, convertor.NumericToFloat64(row.Income))
expense = append(expense, convertor.NumericToFloat64(row.Expense))
}
return view.EchartsOption{
Title: view.Title{
Text: "项目收支情况",
Left: "center",
Top: 2,
FontSize: 15,
TextStyle: view.TextStyle{
Color: "#666666",
FontWeight: "normal",
},
},
Color: []string{"#fed46b", "#2194ff"},
ToolTip: view.ToolTip{
Trigger: "axis",
AxisPointer: view.AxisPointer{
Type: "shadow",
},
},
Grid: view.Grid{
Left: "3%",
Right: "4%",
Bottom: "10%",
ContainLabel: true,
},
Legend: view.Legend{
Left: "center",
Top: "bottom",
Data: []string{"支出金额", "收入金额"},
},
XAxis: []view.XAxis{
{
Type: "category",
Data: name,
AxisTick: view.AxisTick{
AlignWithLabel: true,
},
},
},
YAxis: []view.YAxis{
{
Type: "value",
Name: "单位：元",
},
},
BarMaxWidth: "30",
Label: view.Label{
Show: true,
Position: "top",
},
Series: []view.Series{
{
Name: "支出金额",
Type: "bar",
Data: expense,
ItemStyle: view.ItemStyle{
Normal: view.Normal{
Color: "#f89588",
},
},
},
{
Name: "收入金额",
Type: "bar",
Data: income,
ItemStyle: view.ItemStyle{
Normal: view.Normal{
Color: "#76da91",
},
},
},
},
}
}
func (h *projectHandler) incomeEcharts(ctx context.Context, projectId int64) view.EchartsOption {
var name []string
data := []view.DataItem{}
if projectId == 0 {
rows, err := h.biz.IncomeV1().Statistics(ctx)
if err != nil || len(rows) == 0 {
return view.EchartsOption{}
}
for _, row := range rows {
name = append(name, row.IncomeTypeName)
data = append(data, view.DataItem{
Name: row.IncomeTypeName,
Value: convertor.NumericToFloat64(row.TotalAmount),
})
}
} else {
rows, err := h.biz.IncomeV1().StatisticsByProjectID(ctx, projectId)
if err != nil || len(rows) == 0 {
return view.EchartsOption{}
}
for _, row := range rows {
name = append(name, row.IncomeTypeName)
data = append(data, view.DataItem{
Name: row.IncomeTypeName,
Value: convertor.NumericToFloat64(row.TotalAmount),
})
}
}
return view.EchartsOption{
Title: view.Title{
Text: "收入分布",
Left: "center",
Orient: "vertical",
FontSize: 15,
TextStyle: view.TextStyle{
Color: "#666666",
FontWeight: "normal",
},
},
ToolTip: view.ToolTip{
Trigger: "item",
},
Legend: view.Legend{
Left: "center",
Top: "bottom",
Data: name,
},
Color: []string{"#63b2ee", "#76da91", "#f8cb7f", "#f89588", "#7cd6cf", "#9192ab", "#7898e1", "#efa666", "#eddd86", "#9987ce", "#63b2ee", "#76da91"},
Series: []view.Series{
{
Type: "pie",
Radius: "50%",
Data: data,
Label: view.Label{
Show: true,
TextStyle: view.TextStyle{
Color: "#666666",
},
Normal: view.LableNormal{
Formatter: "{c} ({d}%)",
TextStyle: view.TextStyle{
Color: "#666666",
FontWeight: "normal",
},
},
},
},
},
}
}
func (h *projectHandler) expenseEcharts(ctx context.Context, projectId int64) view.EchartsOption {
var name []string
data := []view.DataItem{}
if projectId == 0 {
rows, err := h.biz.ExpenseV1().Statistics(ctx)
if err != nil || len(rows) == 0 {
return view.EchartsOption{}
}
for _, row := range rows {
name = append(name, row.ExpensesTypeName)
data = append(data, view.DataItem{
Name: row.ExpensesTypeName,
Value: convertor.NumericToFloat64(row.TotalAmount),
})
}
} else {
rows, err := h.biz.ExpenseV1().StatisticsByProjectID(ctx, projectId)
if err != nil || len(rows) == 0 {
return view.EchartsOption{}
}
for _, row := range rows {
name = append(name, row.ExpensesTypeName)
data = append(data, view.DataItem{
Name: row.ExpensesTypeName,
Value: convertor.NumericToFloat64(row.TotalAmount),
})
}
}
return view.EchartsOption{
Title: view.Title{
Text: "支出分布",
Left: "center",
Orient: "vertical",
FontSize: 15,
TextStyle: view.TextStyle{
Color: "#666666",
FontWeight: "normal",
},
},
ToolTip: view.ToolTip{
Trigger: "item",
},
Legend: view.Legend{
Left: "center",
Top: "bottom",
Data: name,
},
Color: []string{"#63b2ee", "#76da91", "#f8cb7f", "#f89588", "#7cd6cf", "#9192ab", "#7898e1", "#efa666", "#eddd86", "#9987ce", "#63b2ee", "#76da91"},
Series: []view.Series{
{
Type: "pie",
Radius: "50%",
Data: data,
Label: view.Label{
Show: true,
TextStyle: view.TextStyle{
Color: "#666666",
},
Normal: view.LableNormal{
Formatter: "{c} ({d}%)",
TextStyle: view.TextStyle{
Color: "#666666",
FontWeight: "normal",
},
},
},
},
},
}
// return view.EchartsOption{
// Title: view.Title{
// Text: "支出分布",
// Left: "center",
// Top: 2,
// FontSize: 15,
// TextStyle: view.TextStyle{
// Color: "#666666",
// FontWeight: "normal",
// },
// },
// Color: []string{"#fed46b", "#2194ff"},
// ToolTip: view.ToolTip{
// Trigger: "axis",
// AxisPointer: view.AxisPointer{
// Type: "shadow",
// },
// },
// Grid: view.Grid{
// Left: "3%",
// Right: "4%",
// Bottom: "10%",
// ContainLabel: true,
// },
// XAxis: []view.XAxis{
// {
// Type: "category",
// Data: name,
// AxisTick: view.AxisTick{
// AlignWithLabel: true,
// },
// },
// },
// YAxis: []view.YAxis{
// {
// Type: "value",
// Name: "单位：元",
// },
// },
// BarMaxWidth: "30",
// Label: view.Label{
// Show: true,
// Position: "top",
// },
// Series: []view.Series{
// {
// Type: "bar",
// Data: expense,
// ItemStyle: view.ItemStyle{
// Normal: view.Normal{
// Color: "#f89588",
// },
// },
// },
// },
// }
}

337
internal/erpserver/handler/project/project.go
View File

@@ -1,337 +0,0 @@
package project
import (
"errors"
"net/http"
"strconv"
"strings"
"time"
formDto "management/internal/db/model/form"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/pkg/convertor"
"management/internal/pkg/middleware"
"management/internal/pkg/snowflake"
"management/internal/pkg/tpl"
"management/internal/pkg/tpl/html"
"github.com/jackc/pgx/v5/pgtype"
)
type ProjectHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
Data(w http.ResponseWriter, r *http.Request)
Dashboard(w http.ResponseWriter, r *http.Request)
}
type projectHandler struct {
render tpl.Renderer
biz biz.IBiz
mi middleware.Middleware
}
var _ ProjectHandler = (*projectHandler)(nil)
func NewProjectHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.Middleware) *projectHandler {
return &projectHandler{
render: render,
biz: biz,
mi: mi,
}
}
func (h *projectHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
h.render.HTML(w, r, "project/list.tmpl", map[string]any{
"Statuses": html.NewSelectControls(html.ProjectStatuses, "0"),
})
case http.MethodPost:
title := strings.TrimSpace(r.PostFormValue("title"))
var search string
if len(title) > 0 {
search = "%" + title + "%"
if strings.HasSuffix(title, ":") {
search = title[:len(title)-1] + "%"
}
}
arg := &db.ListProjectConditionParam{
IsTitle: len(search) > 0,
Title: search,
Status: convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
PageID: convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
PageSize: convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
}
arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
res, total, err := h.biz.ProjectV1().List(r.Context(), arg)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: total,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *projectHandler) Add(w http.ResponseWriter, r *http.Request) {
authUser := h.mi.AuthUser(r.Context())
h.render.HTML(w, r, "project/edit.tmpl", map[string]any{
"Item": &formDto.ProjectForm{
ApplyUserID: authUser.ID,
ProjectFiles: &formDto.ProjectFileForm{
ProjectFileItems: []*formDto.ProjectFileItemForm{},
},
},
"Statuses": html.NewSelectControls(html.ProjectStatuses, "0"),
})
}
func (h *projectHandler) Edit(w http.ResponseWriter, r *http.Request) {
form := &formDto.ProjectForm{}
id := convertor.ConvertInt[int64](r.URL.Query().Get("id"), 0)
if id > 0 {
ctx := r.Context()
if po, err := h.biz.ProjectV1().Get(ctx, id); err == nil {
pfs, err := h.biz.ProjectV1().ListProjectFiles(ctx, po.ID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
form = form.ToForm(po, pfs)
if form.ApplyUserID == 0 {
authUser := h.mi.AuthUser(ctx)
form.ApplyUserID = authUser.ID
}
// if c, err := db.Engine.GetCustomer(ctx, po.CustomerID); err == nil {
// form.CustomerName = c.Name
// }
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, po.CreatedUserID); err == nil {
form.CreatedName = u.Username
}
if u, err := h.biz.SystemV1().UserBiz().Get(ctx, po.UpdatedUserID); err == nil {
form.UpdatedName = u.Username
}
}
}
h.render.HTML(w, r, "project/edit.tmpl", map[string]any{
"Item": form,
"Statuses": html.NewSelectControls(html.ProjectStatuses, strconv.Itoa(int(form.Status))),
})
}
func (h *projectHandler) Save(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
form, err := validForm(r)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
authUser := h.mi.AuthUser(ctx)
if form.ID > 0 {
p := &db.UpdateProjectParams{
ID: form.ID,
Name: pgtype.Text{
String: form.Name,
Valid: true,
},
StartAt: pgtype.Timestamptz{
Time: form.StartAt,
Valid: true,
},
EndAt: pgtype.Timestamptz{
Time: form.EndAt,
Valid: true,
},
CustomerID: pgtype.Int8{
Int64: form.CustomerID,
Valid: true,
},
TotalMoney: form.TotalMoneyF,
Description: pgtype.Text{
String: form.Description,
Valid: true,
},
ApplyAt: pgtype.Timestamptz{
Time: form.ApplyAt,
Valid: true,
},
ApplyUserID: pgtype.Int4{
Int32: form.ApplyUserID,
Valid: true,
},
ManagerID: pgtype.Int4{
Int32: form.ManagerID,
Valid: true,
},
Members: pgtype.Text{
String: form.Members,
Valid: true,
},
Status: pgtype.Int2{
Int16: form.Status,
Valid: true,
},
UpdatedUserID: pgtype.Int4{
Int32: authUser.ID,
Valid: true,
},
}
cpfs := []*db.CreateProjectFileParams{}
for _, pfile := range form.ProjectFiles.ProjectFileItems {
cpfs = append(cpfs, &db.CreateProjectFileParams{
ID: snowflake.GetId(),
Name: pfile.Name,
Path: pfile.Path,
ProjectID: form.ID,
CreatedUserID: authUser.ID,
})
}
err := h.biz.ProjectV1().Update(ctx, p, cpfs)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
} else {
p := &db.CreateProjectParams{
ID: snowflake.GetId(),
Name: form.Name,
StartAt: form.StartAt,
EndAt: form.EndAt,
CustomerID: form.CustomerID,
TotalMoney: form.TotalMoneyF,
Description: form.Description,
ApplyAt: form.ApplyAt,
ApplyUserID: form.ApplyUserID,
ManagerID: form.ManagerID,
Members: form.Members,
Status: form.Status,
CreatedUserID: authUser.ID,
}
cpfs := []*db.CreateProjectFileParams{}
for _, pfile := range form.ProjectFiles.ProjectFileItems {
cpfs = append(cpfs, &db.CreateProjectFileParams{
ID: snowflake.GetId(),
Name: pfile.Name,
Path: pfile.Path,
ProjectID: p.ID,
CreatedUserID: authUser.ID,
})
}
err := h.biz.ProjectV1().Create(ctx, p, cpfs)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
}
}
func (h *projectHandler) Data(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
t := vars.Get("type")
if t == "xmselect" {
res, err := h.biz.ProjectV1().XmSelect(r.Context())
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSON(w, res)
return
}
h.render.JSON(w, nil)
}
func validForm(r *http.Request) (formDto.ProjectForm, error) {
var err error
form := formDto.ProjectForm{}
form.ID = convertor.ConvertInt[int64](r.PostFormValue("ID"), 0)
form.CustomerID, err = strconv.ParseInt(r.PostFormValue("CustomerID"), 10, 64)
if err != nil || form.CustomerID == 0 {
return form, errors.New("客户不能为空")
}
form.Name = r.PostFormValue("Name")
if len(form.Name) == 0 {
return form, errors.New("名称不能为空")
}
form.StartAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("StartAt"), time.Local)
if err != nil {
return form, errors.New("开始时间格式错误")
}
form.EndAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("EndAt"), time.Local)
if err != nil {
return form, errors.New("结束时间格式错误")
}
if err := form.TotalMoneyF.Scan(r.PostFormValue("TotalMoney")); err != nil {
return form, errors.New("总金额格式错误")
}
form.Description = r.PostFormValue("Description")
form.ApplyAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("ApplyAt"), time.Local)
if err != nil {
return form, errors.New("申请时间格式错误")
}
form.ApplyUserID = convertor.ConvertInt[int32](r.PostFormValue("ApplyUserID"), 0)
if form.ApplyUserID == 0 {
return form, errors.New("申请人不能为空")
}
form.ManagerID = convertor.ConvertInt[int32](r.PostFormValue("ManagerID"), 0)
if form.ManagerID == 0 {
return form, errors.New("项目经理不能为空")
}
form.Members = r.PostFormValue("Members")
if len(form.Members) > 0 {
membersSplit := strings.SplitSeq(form.Members, ",")
for v := range membersSplit {
m := convertor.ConvertInt[int32](v, 0)
if m == 0 {
return form, errors.New("项目成员数据错误")
}
}
}
form.Status = convertor.ConvertInt[int16](r.PostFormValue("Status"), 9999)
form.ProjectFiles = &formDto.ProjectFileForm{
ProjectFileItems: []*formDto.ProjectFileItemForm{},
}
fns := r.PostFormValue("Paths")
if len(fns) > 0 {
fnsSplit := strings.SplitSeq(fns, ",")
for v := range fnsSplit {
if len(v) > 0 {
read := strings.Split(v, "|")
if len(read) != 2 {
return form, errors.New("文件路径数据错误")
}
pff := &formDto.ProjectFileItemForm{
Name: read[0],
Path: read[1],
Combination: v,
}
form.ProjectFiles.ProjectFileItems = append(form.ProjectFiles.ProjectFileItems, pff)
}
}
}
return form, nil
}

2
internal/erpserver/handler/system/audit.go
View File

@@ -3,7 +3,7 @@ package system
import (
"net/http"
"management/internal/db/model/dto"
"management/internal/erpserver/model/dto"
v1 "management/internal/erpserver/service/v1"
"management/internal/pkg/convertor"
"management/internal/pkg/tpl"

173
internal/erpserver/handler/system/category.go
View File

@@ -1,173 +0,0 @@
package system
import (
"net/http"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/erpserver/biz"
"management/internal/erpserver/model/form"
"management/internal/pkg/binding"
"management/internal/pkg/convertor"
"management/internal/pkg/tpl"
)
type CategoryHandler interface {
List(w http.ResponseWriter, r *http.Request)
Add(w http.ResponseWriter, r *http.Request)
AddChildren(w http.ResponseWriter, r *http.Request)
Edit(w http.ResponseWriter, r *http.Request)
Save(w http.ResponseWriter, r *http.Request)
Data(w http.ResponseWriter, r *http.Request)
Refresh(w http.ResponseWriter, r *http.Request)
RebuildParentPath(w http.ResponseWriter, r *http.Request)
}
type categoryHandler struct {
render tpl.Renderer
biz biz.IBiz
}
var _ CategoryHandler = (*categoryHandler)(nil)
func NewCategoryHandler(render tpl.Renderer, biz biz.IBiz) *categoryHandler {
return &categoryHandler{
render: render,
biz: biz,
}
}
func (h *categoryHandler) List(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
h.render.HTML(w, r, "category/list.tmpl", nil)
case http.MethodPost:
var q dto.SearchDto
q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
q.SearchParentID = convertor.ConvertInt(r.PostFormValue("parentId"), 0)
q.SearchName = r.PostFormValue("name")
q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
res, count, err := h.biz.SystemV1().CategoryBiz().List(r.Context(), q)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
data := tpl.ResponseList{
Code: 0,
Message: "ok",
Count: count,
Data: res,
}
h.render.JSON(w, data)
default:
http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
}
}
func (h *categoryHandler) Add(w http.ResponseWriter, r *http.Request) {
h.render.HTML(w, r, "category/edit.tmpl", map[string]any{
"Item": &db.Category{Sort: 6666},
})
}
func (h *categoryHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
parentID := convertor.QueryInt[int32](vars, "parentID", 0)
vm := &db.Category{ParentID: parentID, Sort: 6666}
h.render.HTML(w, r, "category/edit.tmpl", map[string]any{
"Item": vm,
})
}
func (h *categoryHandler) Edit(w http.ResponseWriter, r *http.Request) {
vars := r.URL.Query()
id := convertor.QueryInt[int32](vars, "id", 0)
vm := &db.Category{Sort: 6666}
if id > 0 {
vm, _ = h.biz.SystemV1().CategoryBiz().Get(r.Context(), id)
}
h.render.HTML(w, r, "category/edit.tmpl", map[string]any{
"Item": vm,
})
}
func (h *categoryHandler) Save(w http.ResponseWriter, r *http.Request) {
var req form.Category
if err := binding.Form.Bind(r, &req); err != nil {
h.render.JSONERR(w, binding.ValidatorErrors(err))
return
}
if *req.ID == 0 {
err := h.biz.SystemV1().CategoryBiz().Create(r.Context(), &req)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "添加成功")
} else {
err := h.biz.SystemV1().CategoryBiz().Update(r.Context(), &req)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "更新成功")
}
}
func (h *categoryHandler) Data(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
vars := r.URL.Query()
t := vars.Get("type")
if t == "tree" {
res, err := h.biz.SystemV1().CategoryBiz().Tree(ctx, 0)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSON(w, res)
return
} else if t == "xmselect_tree" {
res, err := h.biz.SystemV1().CategoryBiz().XmSelectTree(ctx, 0)
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSON(w, res)
return
} else if t == "xmselect" {
res, err := h.biz.SystemV1().CategoryBiz().XmSelect(ctx, vars.Get("letter"))
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSON(w, res)
return
}
}
func (h *categoryHandler) Refresh(w http.ResponseWriter, r *http.Request) {
_, err := h.biz.SystemV1().CategoryBiz().Refresh(r.Context())
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "刷新成功")
}
func (h *categoryHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
err := h.biz.SystemV1().CategoryBiz().RebuildParentPath(r.Context())
if err != nil {
h.render.JSONERR(w, err.Error())
return
}
h.render.JSONOK(w, "重建成功")
}

6
internal/erpserver/handler/system/config.go
View File

@@ -4,11 +4,11 @@ import (
"net/http"
"strings"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/erpserver/model/dto"
systemmodel "management/internal/erpserver/model/system"
systemsvc "management/internal/erpserver/service/v1"
"management/internal/pkg/convertor"
"management/internal/pkg/database"
"management/internal/pkg/redis"
"management/internal/pkg/tpl"
)
@@ -76,7 +76,7 @@ func (h *configHandler) Save(w http.ResponseWriter, r *http.Request) {
}
err := h.configsvc.Create(ctx, arg)
if err != nil {
if db.IsUniqueViolation(err) {
if database.IsUniqueViolation(err) {
h.render.JSONERR(w, "数据已存在")
return
}

2
internal/erpserver/handler/system/department.go
View File

@@ -3,7 +3,7 @@ package system
import (
"net/http"
"management/internal/db/model/dto"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
systemmodel "management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"

2
internal/erpserver/handler/system/login_log.go
View File

@@ -3,7 +3,7 @@ package system
import (
"net/http"
"management/internal/db/model/dto"
"management/internal/erpserver/model/dto"
v1 "management/internal/erpserver/service/v1"
"management/internal/pkg/convertor"
"management/internal/pkg/tpl"

4
internal/erpserver/handler/system/menu.go
View File

@@ -6,10 +6,10 @@ import (
"strings"
"time"
db "management/internal/db/sqlc"
systemmodel "management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"
"management/internal/pkg/convertor"
"management/internal/pkg/database"
"management/internal/pkg/middleware"
"management/internal/pkg/tpl"
@@ -155,7 +155,7 @@ func (h *menuHandler) Save(w http.ResponseWriter, r *http.Request) {
}
err := h.svc.Create(ctx, arg)
if err != nil {
if db.IsUniqueViolation(err) {
if database.IsUniqueViolation(err) {
h.render.JSONERR(w, "菜单已存在")
return
}

2
internal/erpserver/handler/system/role.go
View File

@@ -4,7 +4,7 @@ import (
"net/http"
"strings"
"management/internal/db/model/dto"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
"management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"

5
internal/erpserver/handler/system/user.go
View File

@@ -4,8 +4,7 @@ import (
"log"
"net/http"
"management/internal/db/model/dto"
db "management/internal/db/sqlc"
"management/internal/erpserver/model/dto"
"management/internal/erpserver/model/form"
systemmodel "management/internal/erpserver/model/system"
v1 "management/internal/erpserver/service/v1"
@@ -47,7 +46,7 @@ func NewUserHandler(
func (h *userHandler) Add(w http.ResponseWriter, r *http.Request) {
h.render.HTML(w, r, "user/edit.tmpl", map[string]any{
"Item": &db.SysUser{
"Item": &systemmodel.User{
HashedPassword: nil,
},
})