blog_backend_api/controller/blog.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,req.Name,is_public,limit,offset*limit)
		}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 ",
				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
	}
	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 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: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
}

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 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 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
}