1171 lines
21 KiB
Go
1171 lines
21 KiB
Go
package controller
|
|
|
|
import (
|
|
"background/config"
|
|
"background/db"
|
|
"background/logs"
|
|
"background/model"
|
|
"fmt"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"gopkg.in/olivere/elastic.v7"
|
|
"qiniupkg.com/x/log.v7"
|
|
)
|
|
|
|
type DocTree struct{
|
|
ID int64 `json:"id"`
|
|
Label string `json:"label"`
|
|
Level int `json:"level"`
|
|
Children []*DocTree `json:"children"`
|
|
}
|
|
|
|
var gDocMapCache map[int]*DocTree = nil
|
|
var gLock sync.Mutex
|
|
|
|
func init(){
|
|
if nil == gDocMapCache{
|
|
gDocMapCache = make(map[int]*DocTree)
|
|
}
|
|
}
|
|
|
|
func InitDocCache(){
|
|
gLock.Lock()
|
|
for k := range gDocMapCache {
|
|
delete(gDocMapCache, k)
|
|
}
|
|
|
|
articles := []model.Doc{}
|
|
e := db.GetMysqlClient().Query2("select id,title,father,level from doc_copy1", &articles)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
for _,v := range articles{
|
|
tmp := new (DocTree)
|
|
tmp.ID = v.ID
|
|
tmp.Level = int(v.Level)
|
|
tmp.Label = v.Title
|
|
tmp.Children = make([]*DocTree,0)
|
|
gDocMapCache[int(v.ID)] = tmp
|
|
}
|
|
for _,v := range articles{
|
|
tmp := new (DocTree)
|
|
tmp.ID = v.ID
|
|
tmp.Label = v.Title
|
|
tmp.Level = int(v.Level)
|
|
tmp.Children = make([]*DocTree,0)
|
|
gDocMapCache[int(v.ID)] = tmp
|
|
}
|
|
for _,v := range articles{
|
|
if v.Father != 0{
|
|
gDocMapCache[int(v.Father)].Children = append(gDocMapCache[int(v.Father)].Children, gDocMapCache[int(v.ID)])
|
|
}
|
|
}
|
|
|
|
gLock.Unlock()
|
|
log.Print(gDocMapCache)
|
|
|
|
}
|
|
|
|
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 GetArticlesTree(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
articles := []model.Doc{}
|
|
e := db.GetMysqlClient().Query2("select id,title,father,level from doc_copy1", &articles)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
|
|
InitDocCache()
|
|
ret := []*DocTree{}
|
|
for _, v := range articles {
|
|
if v.Level == 0{
|
|
ret = append(ret, gDocMapCache[int(v.ID)])
|
|
}
|
|
}
|
|
|
|
rsp.Data = ret
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
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,doc.type 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 GetArticleHistory(c *gin.Context) {
|
|
resp := RespBase{Msg: "FAIL", Status: 211}
|
|
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
query := fmt.Sprintf("select *
|
|
from doc_history where doc_history.id = %d",req.id)
|
|
|
|
doc_history := []model.DocHistory{}
|
|
|
|
e := db.GetMysqlClient().Query2(query, &doc_history)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
resp.Data = doc_history
|
|
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_copy1 where doc_copy1.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 UpdateArtilceTree(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"`
|
|
Father int `json:"father"`
|
|
Level int `json:"level"`
|
|
}
|
|
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_copy1 where doc_copy1.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.UpdateDocTree(
|
|
model.DocTree{
|
|
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),
|
|
Father: int32(req.Father),
|
|
Level: int32(req.Level),
|
|
},
|
|
)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
config.RedisOne().Del("artilcetree")
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
|
|
func SearchArticleESHightLight(c *gin.Context) {
|
|
type RetHighlight struct{
|
|
ID int64 `json:"id" gorm:"column:id" sql:"id"`
|
|
Title string `json:"title" gorm:"column:title" sql:"title"`
|
|
Type int32 `json:"type" gorm:"column:type" sql:"type"`
|
|
Highlight []string `json:"highlight" gorm:"column:highlight" sql:"highlight"`
|
|
}
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
type Req struct{
|
|
Term string `json:"term"`
|
|
}
|
|
var req Req
|
|
e := c.BindJSON(&req)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
|
|
query := elastic.NewMatchQuery("content", req.Term)
|
|
highlight := elastic.NewHighlight()
|
|
highlight = highlight.Fields(elastic.NewHighlighterField("content"))
|
|
highlight = highlight.PreTags("<span>").PostTags("</span>")
|
|
x := []RetHighlight{}
|
|
_, e = db.GetElastic().
|
|
QueryHighlight("doc", query, &x,highlight, 10, 0)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
|
|
rsp.Data = x
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
|
|
func SearchArticleES(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
type Req struct{
|
|
Term string `json:"term"`
|
|
}
|
|
var req Req
|
|
e := c.BindJSON(&req)
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
|
|
query := elastic.NewTermQuery("content", req.Term)
|
|
x := []model.Doc{}
|
|
_, e = db.GetElastic().Query("doc", query, &x, 10, 0)
|
|
if nil != e {
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
rsp.Data = x
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}
|
|
|
|
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 AddArticleTree(c *gin.Context) {
|
|
rsp := RespBase{Msg: "FAIL", Status: 210}
|
|
type ReqAddArticle struct {
|
|
Title string `json:"title"`
|
|
Content string `json:"content"`
|
|
Author string `json:"author"`
|
|
Type int64 `json:"type"`
|
|
Ispublic int `json:"is_public"`
|
|
Father int `json:"father"`
|
|
Level int `json:"level"`
|
|
}
|
|
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
|
|
}
|
|
log.Print(req.Level)
|
|
|
|
e := model.CreateDocTree(
|
|
model.DocTree{
|
|
Type: int32(req.Type),
|
|
Title: req.Title,
|
|
Content: req.Content,
|
|
Author: req.Author,
|
|
IsPublic: int32(req.Ispublic),
|
|
Father: int32(req.Father),
|
|
Level: int32(req.Level),
|
|
},
|
|
)
|
|
if nil != e {
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
config.RedisOne().Del("artilcetree")
|
|
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 DeleteArticleTree(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.DeleteDocTree(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 SearchArticles(c *gin.Context) {
|
|
type ReqSearch struct{
|
|
Term string `json:"term"`
|
|
}
|
|
resp := RespBase{"unkown error", -231, nil}
|
|
defer func() {
|
|
c.JSON(200, resp)
|
|
}()
|
|
|
|
docTypes := []model.Doc{}
|
|
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, limit, offset)
|
|
if nil != e {
|
|
return
|
|
}
|
|
rsp.Data = dat
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
} else {
|
|
dat, e := model.GetMemos(req.Title, limit, offset)
|
|
if nil != e {
|
|
return
|
|
}
|
|
rsp.Data = dat
|
|
rsp.Status = 0
|
|
rsp.Msg = "OK"
|
|
}
|
|
|
|
}
|
|
|
|
|
|
func GetMemoCnt(c *gin.Context) {
|
|
rsp := RespBase{"ERR", -1, nil}
|
|
defer func() {
|
|
c.JSON(200, rsp)
|
|
}()
|
|
count := model.MemoCnt()
|
|
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
rsp.Data = count
|
|
|
|
}
|
|
|
|
|
|
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
|
|
}
|
|
|
|
func GetDocTemplateId(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
|
|
}
|
|
ret,e := model.ReadDocTemplate(int32(id))
|
|
if nil != e{
|
|
log.Print(e.Error())
|
|
return
|
|
}
|
|
if len(ret) > 0{
|
|
resp.Data = ret[0]
|
|
}else{
|
|
resp.Data = nil
|
|
}
|
|
resp.Msg = "OK"
|
|
resp.Status = 0
|
|
} |