scrm-go/controllers/article/article_controller.go

package article

import (
	"github.com/astaxie/beego"
	"fmt"
	"SCRM/controllers"
	"SCRM/service/article_service"
	"SCRM/enums"
	"SCRM/models"
	"time"
	"SCRM/utils"
	"encoding/json"
	"strconv"
)

func ArticleRouters() {

	beego.Router("/api/acticle/createacticle",&ArticleManage{},"Post:CreateArticle")
	beego.Router("/api/acticle/getArticleType",&ArticleManage{},"Get:GetArticleType")
	beego.Router("/api/acticle/getAllArticles",&ArticleManage{},"Get:GetAllArticles")
	beego.Router("/api/article/addCategory",&ArticleManage{},"Post:AddCategory")
	beego.Router("/api/acticle/getCategorys",&ArticleManage{},"Get:GetCategorys")
	beego.Router("/api/acticle/edit",&ArticleManage{},"Post:EditCategorys")
	beego.Router("/api/acticle/delete",&ArticleManage{},"Delete:DeleteCategorys")
	beego.Router("/api/acticle/addvido",&ArticleManage{},"Post:Addvido")
	beego.Router("/api/acticle/savedraft",&ArticleManage{},"Post:SaveDraft")
}

type ArticleManage struct {

	controllers.BaseAuthAPIController
}

func (this *ArticleManage) CreateArticle(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("视频发布是什么呢",err)

	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	actname := dataBody["act_name"].(string)
	if len(actname) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}

	actcontent := dataBody["act_content"].(string)
	if len(actcontent) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章内容不能为空")
		return
	}

	orglogo := dataBody["org_logo"].(string)
	if len(orglogo) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "封面图片不能为空")
		return
	}

	acttype := int64(dataBody["act_type"].(float64))
	if  acttype <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分类号不能为空")
		return
	}

	timenow := time.Now().Unix()
	fmt.Println("姓名:",actname,"文章内容",actcontent,"图片",orglogo,"文章类型",acttype,userOrgID)
	articles := models.Articles{
				Title: actname,
				Content: actcontent,
				Imgs: orglogo,
				ClassId: acttype,
				UserOrgId:userOrgID,
				Ctime:timenow,
				Status:1,
				Type:1,
				ArticleStatus:1,
		}
		err = article_service.AddAritcle(articles)
		if err !=nil{
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "插入文章失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
		"articles":articles,
		})
}

func (this *ArticleManage) GetArticleType(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	category, err := article_service.FindArticleCategoryType(userOrgID)
	fmt.Println("文章分类列表",category,err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"category":category,
	})
	return
}

func (this *ArticleManage) GetAllArticles()  {
	page, _ := this.GetInt64("page", 1)
	limit, _ := this.GetInt64("limit", 10)
	searchKey := this.GetString("search", "")
	classId,_ := this.GetInt64("classid",0)
    fmt.Println("页面",page,"限制",limit,"关键字",searchKey,"分类号",classId)

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId

	articles, total, err := article_service.FindAllArticle(userOrgID, page,limit, searchKey, classId)
	fmt.Println("文章内容是是么",articles)
	fmt.Println("total",total)
	fmt.Println("err",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章列表失败")
		return
	}
	category, err := article_service.FindCategoryList(userOrgID)
	fmt.Println("category是傻",category,err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles":articles,
		"total":total,
		"category":category,
	})
	return
}

func (this *ArticleManage) AddCategory(){

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("err是什么呢",err)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	name:= dataBody["name"].(string)
	fmt.Println("name是谁?",name)
	if len(name) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "姓名不能为空")
		return
	}

	content := dataBody["summary"].(string)
	fmt.Println("content是谁?",content)
	if len(content) == 0 {
    	this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"内容不能为空")
    	return
	}

	sort := dataBody["order"].(string)
	sors, _ := strconv.ParseInt(sort, 10, 64)
	if sors  <=0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序不能为空")
		return
	}
	fmt.Println("soert是谁？",sort)
	fmt.Println("姓名:",name,"内容",content,"排序",sort)
	timenow := time.Now().Unix()
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	category := models.ArticleCategory{
		Name:    name,
		Summary: content,
		Order:   sors,
		UserOrgId:userOrgID,
		Status: 1,
		Ctime: timenow,
	}
   fmt.Println(category)
	err = article_service.AddCategory(category)
	fmt.Println(err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加分类失败")
		return
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"category":category,
	})
}

func  (this *ArticleManage) GetCategorys()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	page, _ := this.GetInt64("page", 1)
	limit, _ := this.GetInt64("limit", 10)
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	fmt.Println("机构ID",userOrgID)
	categorys, total, err := article_service.GetCategorys(page, limit, userOrgID)
	fmt.Println("hhe",categorys,total,err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"category":categorys,
		"total":total,
	})
	return
}

func (this *ArticleManage) EditCategorys()  {
	id, _ := this.GetInt64("id", 0)
	fmt.Println("ID是多少",id)
	if id <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误:id")
		return
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	categorys, err := article_service.GetCategorysByID(userOrgID, id)
	fmt.Println("categorys是?",categorys,err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBUpdate, "编辑会员失败：（"+err.Error()+"）")
		return
	}
	if categorys == nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBUpdate, "编辑会员失败：（会员记录不存在）")
		return
	}
	timenow := time.Now().Unix()


	dataBody := make(map[string]interface{}, 0)
	err = json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	name:= dataBody["name"].(string)
	fmt.Println("name是谁?",name)

	content := dataBody["summary"].(string)
	fmt.Println("content是谁?",content)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"内容不能为空")
		return
	}

	sors :=int64(dataBody["order"].(float64))
	//sors, _ := strconv.ParseInt(sort, 10, 64)
	fmt.Println("sort0",sors)
	if sors  <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序不能为空")
		return
	}
	fmt.Println("soert是谁？",sors)
	fmt.Println("姓名:",name,"内容",content,"排序",sors)

	category := models.ArticleCategory{
		Name:    name,
		Summary: content,
		Order:   sors,
		UserOrgId:userOrgID,
		Status: 1,
		Mtime: timenow,
	}
	fmt.Println("category是?",category)
	article_service.EditCategory(&category,userOrgID,id)
	this.ServeSuccessJSON(map[string]interface{}{
		"category":category,
	})
}

func (this *ArticleManage) DeleteCategorys()  {
	adminUserInfo := this.GetAdminUserInfo()

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	idsInters := dataBody["ids"].([]interface{})
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}

	err = article_service.DeleteCategorys(adminUserInfo.CurrentOrgId, ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除分类失败:（"+err.Error()+"）")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) Addvido(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("视频发布是什么呢",err)

	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	vidupload := dataBody["vio_upload"].(string)
     if len(vidupload) == 0 {
		 this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频不能为空")
		 return
	 }
     fmt.Println("视频",vidupload)
	vidname := dataBody["vid_name"].(string)
	if len(vidname)==0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频标题不能为空")
		return
	}
    fmt.Println("视频名称",vidname)
	vidpic := dataBody["vid_pic"].(string)
	if(vidpic == ""){
		vidpic = vidupload + "?vframe/jpg/offset/1/w/300/h/200"
	}
	if len(vidpic)==0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频封面不能为空")
		return
	}
    fmt.Println("视频图片",vidpic)
	vidtype := int64(dataBody["vid_type"].(float64))
	if vidtype <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "所属分类不能为空")
		return
	}
    fmt.Println("视频类型",vidtype)
	fmt.Println("视频",vidupload,"视频标题",vidname,"视频封面",vidpic,"视频类型",vidtype)
	timenow := time.Now().Unix()
	articles := models.Articles{
       UserOrgId:userOrgID,
       Ctime:timenow,
       Type:2,
       VideoUrl:vidupload,
       Title:vidname,
       Imgs:vidpic,
       ClassId:vidtype,
       ArticleStatus:1,
	}

	err = article_service.AddVido(articles)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加分类失败")
		return
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"vido":articles,
	})
}

func (this *ArticleManage) SaveDraft()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("视频发布是什么呢",err)

	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	vidupload := dataBody["vio_upload"].(string)
	if len(vidupload) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频不能为空")
		return
	}
	fmt.Println("视频",vidupload)
	vidname := dataBody["vid_name"].(string)
	if len(vidname)==0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频标题不能为空")
		return
	}
	fmt.Println("视频名称",vidname)
	vidpic := dataBody["vid_pic"].(string)
	if(vidpic == ""){
		vidpic = vidupload + "?vframe/jpg/offset/1/w/300/h/200"
	}
	if len(vidpic)==0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "视频封面不能为空")
		return
	}
	fmt.Println("视频图片",vidpic)
	vidtype := int64(dataBody["vid_type"].(float64))
	if vidtype <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "所属分类不能为空")
		return
	}
	fmt.Println("视频类型",vidtype)
	fmt.Println("视频",vidupload,"视频标题",vidname,"视频封面",vidpic,"视频类型",vidtype)
	timenow := time.Now().Unix()
	articles := models.Articles{
		UserOrgId:userOrgID,
		Ctime:timenow,
		Type:2,
		VideoUrl:vidupload,
		Title:vidname,
		Imgs:vidpic,
		ClassId:vidtype,
		ArticleStatus:2,
	}

	err = article_service.AddVido(articles)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加分类失败")
		return
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"savedraft":articles,
	})
}