812 lines
14 KiB
Go
812 lines
14 KiB
Go
package controller
|
|
|
|
import (
|
|
"background/db"
|
|
"background/logs"
|
|
"background/model"
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"qiniupkg.com/x/log.v7"
|
|
)
|
|
|
|
func GetPageParaFromQuery(c *gin.Context) (int, int) {
|
|
limit := c.Query("limit")
|
|
offset := c.Query("offset")
|
|
|
|
iLmit, e := strconv.Atoi(limit)
|
|
if nil != e {
|
|
return 0, 0
|
|
}
|
|
iOffset, e := strconv.Atoi(offset)
|
|
if nil != e {
|
|
return 0, 0
|
|
}
|
|
return iLmit, iOffset
|
|
}
|
|
|
|
func GetArticles(c *gin.Context) {
|
|
type ReqArticles struct {
|
|
Name string `json:"name"`
|
|
Type int32 `json:"types"`
|
|
}
|
|
var req ReqArticles
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
article := []model.Doc{}
|
|
limit, offset := GetPageParaFromQuery(c)
|
|
public := c.Query("is_public")
|
|
|
|
var sql string
|
|
if req.Name != "" {
|
|
if req.Type == 110 {
|
|
is_public := 0
|
|
if public == "true" {
|
|
is_public = 1
|
|
} else {
|
|
is_public = 0
|
|
}
|
|
sql = "select * from doc where doc.title like '%%%s%%' and is_public = %d limit %d offset %d "
|
|
sql = fmt.Sprintf(sql, req.Name, is_public, limit, offset*limit)
|
|
} else {
|
|
is_public := 0
|
|
if public == "true" {
|
|
is_public = 1
|
|
} else {
|
|
is_public = 0
|
|
}
|
|
sql = fmt.Sprintf("select * from doc where doc.title like '%%%s%%' and doc.type = %d and is_public = %d limit %d offset %d ",
|
|
req.Name, req.Type, is_public, limit, offset*limit)
|
|
}
|
|
} else {
|
|
if req.Type == 110 {
|
|
is_public := 0
|
|
if public == "true" {
|
|
is_public = 1
|
|
} else {
|
|
is_public = 0
|
|
}
|
|
sql = fmt.Sprintf("SELECT doc.id,doc.author,LEFT(doc.content,50) as content,doc.title from doc where is_public = %d "+
|
|
"order by id desc limit %d offset %d", is_public, limit, offset)
|
|
} else {
|
|
is_public := 0
|
|
if public == "true" {
|
|
is_public = 1
|
|
} else {
|
|
is_public = 0
|
|
}
|
|
sql = fmt.Sprintf("SELECT doc.id,doc.author,LEFT(doc.content,50) as content,doc.title,doc.type from doc where doc.type = %d and is_public = %d "+
|
|
" order by id desc limit %d offset %d", req.Type, is_public, limit, offset)
|
|
}
|
|
}
|
|
log.Print(sql)
|
|
e = db.GetMysqlClient().Query2(sql, &article)
|
|
if nil != e {
|
|
logs.Error(e.Error(), sql)
|
|
return
|
|
}
|
|
for k, _ := range article {
|
|
article[k].Content += "..."
|
|
}
|
|
rsp.Data = article
|
|
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
|
|
func GetArticleCount(c *gin.Context) {
|
|
resp := RespBase{Msg: "FAIL", Status: 211}
|
|
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
query := fmt.Sprintf("select count(*) as cnt from doc")
|
|
type Cnt struct {
|
|
Cnt int64 `sql:"cnt" json:"cnt"`
|
|
}
|
|
cnt := []Cnt{}
|
|
|
|
e := db.GetMysqlClient().Query2(query, &cnt)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = cnt[0]
|
|
resp.Status = 0
|
|
resp.Msg = "OK"
|
|
}
|
|
|
|
func GetArticle(c *gin.Context) {
|
|
resp := RespBase{Msg: "FAIL", Status: 211}
|
|
sid := c.Param("id")
|
|
var id int
|
|
var err error
|
|
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
if sid == "" {
|
|
return
|
|
} else {
|
|
id, err = strconv.Atoi(sid)
|
|
if nil != err {
|
|
return
|
|
}
|
|
}
|
|
query := fmt.Sprintf("select * from doc where doc.id = '%d'", id)
|
|
docs := []model.Doc{}
|
|
e := db.GetMysqlClient().Query2(query, &docs)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
if len(docs) > 0 {
|
|
resp.Data = docs[0]
|
|
resp.Status = 0
|
|
resp.Msg = "OK"
|
|
}
|
|
|
|
}
|
|
|
|
func UpdateArtilce(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
type ReqUpdateArticle struct {
|
|
ID int64 `json:"id"`
|
|
Title string `json:"title"`
|
|
Content string `json:"content"`
|
|
author string `json:"author"`
|
|
Type int64 `json:"type"`
|
|
IsPublic int `json:"is_public"`
|
|
}
|
|
var req ReqUpdateArticle
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
|
|
|
|
er := c.BindJSON(&req)
|
|
if nil != er {
|
|
logs.Error(er.Error())
|
|
return
|
|
}
|
|
if req.Title == "" {
|
|
rsp.Msg = "title required"
|
|
return
|
|
}
|
|
query := fmt.Sprintf("select * from doc where doc.id = '%d'", req.ID)
|
|
docs := []model.Doc{}
|
|
e := db.GetMysqlClient().Query2(query, &docs)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
if len(docs) == 0 {
|
|
rsp.Msg = "不存在该"
|
|
return
|
|
}
|
|
e = model.UpdateDoc(
|
|
model.Doc{
|
|
Type: int32(req.Type),
|
|
Title: req.Title,
|
|
Content: req.Content,
|
|
Author: req.author,
|
|
ID: req.ID,
|
|
IsPublic: int32(req.IsPublic),
|
|
Version: (docs[0].Version + 1),
|
|
},
|
|
)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
|
|
}
|
|
func SearchArticle(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
}
|
|
func AddArticle(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
type ReqAddArticle struct {
|
|
ID int64 `json:"id"`
|
|
Title string `json:"title"`
|
|
Content string `json:"content"`
|
|
Author string `json:"author"`
|
|
Type int64 `json:"type"`
|
|
Ispublic int `json:"is_public"`
|
|
}
|
|
var req ReqAddArticle
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
er := c.BindJSON(&req)
|
|
if nil != er {
|
|
logs.Error(er.Error())
|
|
return
|
|
}
|
|
if req.Title == "" {
|
|
rsp.Msg = "title required"
|
|
return
|
|
}
|
|
e := model.CreateDoc(
|
|
model.Doc{
|
|
Type: int32(req.Type),
|
|
Title: req.Title,
|
|
Content: req.Content,
|
|
Author: req.Author,
|
|
IsPublic: int32(req.Ispublic),
|
|
},
|
|
)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
|
|
func ArticlesType(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
rsp.Data = model.GetArticlesType()
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
func DeleteArticleType(c *gin.Context) {
|
|
rsp := RespBase{Msg: "Fail", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
sid := c.Query("id")
|
|
if sid == "" {
|
|
return
|
|
}
|
|
id, e := strconv.Atoi(sid)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
rsp.Data = model.DeleteArticleType(int32(id))
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
func AddArticleType(c *gin.Context) {
|
|
rsp := RespBase{Msg: "Fail", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
typeName := c.Query("name")
|
|
group := c.Query("group")
|
|
groupid, e := strconv.Atoi(group)
|
|
if nil != e {
|
|
return
|
|
}
|
|
id := c.Query("id")
|
|
if id != "" {
|
|
if typeName == "" {
|
|
return
|
|
}
|
|
articleType := model.ArticleType{
|
|
Id: 0,
|
|
Name: typeName,
|
|
Group: int32(groupid),
|
|
}
|
|
rsp.Data = model.UpdateArticleType(articleType)
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
} else {
|
|
if typeName == "" {
|
|
return
|
|
}
|
|
articleType := model.ArticleType{
|
|
Id: 0,
|
|
Name: typeName,
|
|
Group: int32(groupid),
|
|
}
|
|
rsp.Data = model.AddArticleType(articleType)
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
}
|
|
|
|
func DeleteArticle(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
sid := c.Param("id")
|
|
id, err := strconv.Atoi(sid)
|
|
if nil != err {
|
|
rsp.Status = -234
|
|
c.JSON(200, rsp)
|
|
}
|
|
err = model.DeleteDoc(int64(id))
|
|
if nil != err {
|
|
rsp.Status = -234
|
|
c.JSON(200, rsp)
|
|
}
|
|
rsp.Data = id
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
|
|
func ArticlesTypes(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
docTypes := []model.ArticleType{}
|
|
e := db.GetMysqlClient().Query2("select * from doc_type",
|
|
&docTypes)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = docTypes
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func CreateMemo(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.Memo
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
e = model.CreateMemo(req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func CreateBook(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.Book
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
req.ID = 0
|
|
e = db.GetOrm().Create(&req).Error
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = req
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
|
|
func BookCount(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
count := 0
|
|
db.GetOrm().Model(&model.Book{}).Count(&count)
|
|
resp.Data = count
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
|
|
func Delbook(c *gin.Context) {
|
|
type Req struct{
|
|
ID int32 `json:"id"`
|
|
}
|
|
var req Req
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
count := 0
|
|
e = db.GetOrm().Model(&model.Book{}).Delete(model.Book{ID: int64(req.ID)}).Error
|
|
if nil != e{
|
|
log.Printf(e.Error())
|
|
return
|
|
}
|
|
resp.Data = count
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func UpdateBook(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.Book
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
resp.Msg = "wrong input"
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
e = db.GetOrm().Model(&model.Book{}).Update(&req).Error
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func GetBook(c *gin.Context) {
|
|
type ReqGetBook struct {
|
|
ID int32 `json:"id"`
|
|
}
|
|
resp := RespBase{}
|
|
var req ReqGetBook
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
var book model.Book
|
|
book.ID = int64(req.ID)
|
|
e = db.GetOrm().First(&book, req.ID).Error
|
|
if e != nil {
|
|
logs.Error(e.Error)
|
|
return
|
|
}
|
|
resp.Data = book
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func GetPageBook(c *gin.Context) {
|
|
type ReqGetPageBook struct {
|
|
BookName string `json:"book_name"`
|
|
}
|
|
var req ReqGetPageBook
|
|
resp := RespBase{}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
limit := c.Query("limit")
|
|
offset := c.Query("offset")
|
|
|
|
iLmit, e := strconv.Atoi(limit)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
iOffset, e := strconv.Atoi(offset)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
e = c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
books := []model.Book{}
|
|
|
|
if req.BookName != ""{
|
|
e = db.GetOrm().Model(&model.Book{}).
|
|
Where(fmt.Sprintf("book_name like '%%%s%%' ",req.BookName)).
|
|
Limit(iLmit).Offset(iOffset).Find(&books).Error
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
}else{
|
|
e = db.GetOrm().Model(&model.Book{}).
|
|
Limit(iLmit).Offset(iOffset).Find(&books).Error
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
resp.Status = 0
|
|
resp.Msg = "OK"
|
|
resp.Data = books
|
|
}
|
|
|
|
func UpdateMemo(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.Memo
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
e = model.UpdateMemo(req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func GetDocTypeGroup(c *gin.Context) {
|
|
type DocType struct {
|
|
Id int32 `json:"id"`
|
|
}
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
var id DocType
|
|
e := c.BindJSON(&id)
|
|
if nil != e {
|
|
log.Print(e.Error)
|
|
return
|
|
}
|
|
group, e := model.GetTypeGroup(id.Id)
|
|
if nil != e {
|
|
log.Print(e.Error)
|
|
return
|
|
}
|
|
rsp.Data = group
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
func GetDoGroupcType(c *gin.Context) {
|
|
type DocType struct {
|
|
Id int32 `json:"id"`
|
|
}
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
var id DocType
|
|
e := c.BindJSON(&id)
|
|
if nil != e {
|
|
log.Print(e.Error)
|
|
return
|
|
}
|
|
group, e := model.GetGroupTypes(id.Id)
|
|
if nil != e {
|
|
log.Print(e.Error)
|
|
return
|
|
}
|
|
rsp.Data = group
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
func GetDocGroup(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
group, e := model.GetAllGroup()
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
rsp.Data = group
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
|
|
func GetTemplates(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
|
|
}
|
|
|
|
func GetMemos(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
type ReqMemos struct {
|
|
Title string `json:"title"`
|
|
}
|
|
req := ReqMemos{}
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
limit, offset := GetPageParaFromQuery(c)
|
|
if limit != 0 && offset != 0 {
|
|
dat, e := model.GetMemos(req.Title, 10, 0)
|
|
if nil != e {
|
|
return
|
|
}
|
|
rsp.Data = dat
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
} else {
|
|
dat, e := model.GetMemos(req.Title, 10, 0)
|
|
if nil != e {
|
|
return
|
|
}
|
|
rsp.Data = dat
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
|
|
}
|
|
|
|
|
|
func GetMemo(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
id := c.Query("id")
|
|
dat, e := model.ReadMemo(int32(db.Atoi(id)))
|
|
if nil != e {
|
|
return
|
|
}
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
rsp.Data = dat
|
|
}
|
|
|
|
|
|
func DeleteMemos(c *gin.Context) {
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
type DelReq struct {
|
|
Id int32 `json:"id"`
|
|
}
|
|
var req DelReq
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
e = model.DeleteMemo(req.Id)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
|
|
func CreateDocTemplate(c *gin.Context) {
|
|
resp := RespBase{}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.DocTemplate
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
e = model.CreateDocTemplate(req)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
|
|
func UpdateDocTemplate(c *gin.Context) {
|
|
resp := RespBase{}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
var req model.DocTemplate
|
|
e := c.BindJSON(&req)
|
|
if nil != e {
|
|
resp.Msg = "wrong input"
|
|
return
|
|
}
|
|
e = model.UpdateDocTemplate(req)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func GetDocTemplate(c *gin.Context) {
|
|
type ReqGet struct{
|
|
Title string `json:"title"`
|
|
}
|
|
req := ReqGet{}
|
|
resp := RespBase{}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
e := c.BindJSON(&req)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
ret,e := model.GetDocTemplate(req.Title,5,0)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = ret
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
}
|
|
|
|
func DeleteDocTemplate(c *gin.Context) {
|
|
resp := RespBase{}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
sid := c.Param("id")
|
|
id,e := strconv.Atoi(sid)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
e = model.DeleteDocTemplate(int32(id))
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = nil
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
} |