346 lines
6.4 KiB
Go
346 lines
6.4 KiB
Go
package controller
|
|
|
|
import (
|
|
"background/db"
|
|
"background/logs"
|
|
"background/model"
|
|
"fmt"
|
|
"github.com/gin-gonic/gin"
|
|
"qiniupkg.com/x/log.v7"
|
|
"strconv"
|
|
)
|
|
|
|
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 = 0
|
|
}else{
|
|
is_public = 1
|
|
}
|
|
sql = "select * from doc where doc.title like '%%%s%%' and is_public = %d limit %d offset %d "
|
|
sql = fmt.Sprintf(sql,is_public)
|
|
|
|
}else{
|
|
is_public := 0
|
|
if public == "true"{
|
|
is_public = 0
|
|
}else{
|
|
is_public = 1
|
|
}
|
|
sql = fmt.Sprintf("select * from doc where doc.title like '%%%s%%' and doc.type = %d and is_public = %d limit %d offset %d ",is_public,req.Name,req.Type,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 " +
|
|
"limit %d offset %d",is_public,limit,offset)
|
|
}else{
|
|
is_public := 0
|
|
if public == "true"{
|
|
is_public = 0
|
|
}else{
|
|
is_public = 1
|
|
}
|
|
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" +
|
|
"limit %d offset %d",is_public,req.Type,limit,offset)
|
|
|
|
}
|
|
}
|
|
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
|
|
}
|
|
e := model.UpdateDoc(
|
|
model.Doc{
|
|
Type:req.Type,
|
|
Title:req.Title,
|
|
Content:req.Content,
|
|
Author:req.author,
|
|
ID:req.Id,
|
|
IsPublic:req.IsPublic,
|
|
},
|
|
)
|
|
if nil != e{
|
|
logs.Error(e.Error())
|
|
return
|
|
}
|
|
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:req.Type,
|
|
Title:req.Title,
|
|
Content:req.Content,
|
|
Author:req.author,
|
|
IsPublic: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")
|
|
id := c.Query("id")
|
|
if id != ""{
|
|
if typeName == ""{
|
|
return
|
|
}
|
|
articleType := model.ArticleType{
|
|
Id: 0,
|
|
Name: typeName,
|
|
}
|
|
rsp.Data = model.UpdateArticleType(articleType)
|
|
rsp.Msg = "OK"
|
|
rsp.Status = 0
|
|
}else{
|
|
if typeName == ""{
|
|
return
|
|
}
|
|
articleType := model.ArticleType{
|
|
Id: 0,
|
|
Name: typeName,
|
|
}
|
|
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)
|
|
}()
|
|
type DocType struct {
|
|
Id int64 `sql:"id"`
|
|
TypeName string `sql:"type_name"`
|
|
}
|
|
docTypes := []DocType{}
|
|
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
|
|
} |