scrm/controllers/article/article_controller.go

package article

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

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/article/getAritcleCount", &ArticleManage{}, "Post:GetArticleCount")
	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")
	beego.Router("/api/acticle/prviewArticle", &ArticleManage{}, "Post:PrviewArticle")
	beego.Router("/api/acticle/getarticlePreview", &ArticleManage{}, "Get:GetArtilcePreview")
	beego.Router("/api/acticle/save", &ArticleManage{}, "Post:AddDraft")
	beego.Router("/api/acticle/getEditArticle", &ArticleManage{}, "Post:GetArticleInfo")
	beego.Router("/api/article/Delete", &ArticleManage{}, "Delete:DeleteArticle")
	beego.Router("/api/acticle/getMenus", &ArticleManage{}, "Get:GetMenus")
	beego.Router("/api/acticle/updateArticlesInfo", &ArticleManage{}, "Post:UpdataArticleInfo")
	beego.Router("/api/acticle/saveArticleDraft", &ArticleManage{}, "Post:SaveArticleDraft")
	beego.Router("/api/acticle/updateVidoInfo", &ArticleManage{}, "Post:UpdateVidoInfo")
	beego.Router("/api/acticle/previewEditArticle", &ArticleManage{}, "Post:PreviewEditArticle")
	beego.Router("/api/acticle/getPreviewInfo", &ArticleManage{}, "Get:GetPreviewInfoTwo")
	beego.Router("/api/acticle/getAllComment", &ArticleManage{}, "Get:GetAllComment")
	beego.Router("/api/acticle/getArticleCommentDetail", &ArticleManage{}, "Get:GetArticleCommentDetail")
	beego.Router("/api/article/deleteArticle", &ArticleManage{}, "Get:DeleteArticles")
	beego.Router("/api/acticle/send", &ArticleManage{}, "Get:SendReplycontent")
	beego.Router("/api/acticle/getReplyAllComents", &ArticleManage{}, "Get:GetReplyAllComents")
	beego.Router("/api/article/sendInformation", &ArticleManage{}, "Get:GetSendInformation")
	beego.Router("/api/article/spreadReplay", &ArticleManage{}, "Get:GetSpreadReplay")
	beego.Router("/api/article/clearRelyInfo", &ArticleManage{}, "Delete:ClearReplyInfo")
	beego.Router("/api/article/deleteReply", &ArticleManage{}, "Delete:DeleteReply")
	beego.Router("/api/article/spread", &ArticleManage{}, "Get:GetSpreadInfo")
	beego.Router("/api/article/clear", &ArticleManage{}, "Delete:ClearReply")
	beego.Router("/api/article/deleteComments", &ArticleManage{}, "Delete:DeleteComments")
	beego.Router("/api/acticle/getEditVidoInfo", &ArticleManage{}, "Get:GetVidoInfo")
	beego.Router("/api/acticle/savevidodraft", &ArticleManage{}, "Post:SaveVidoDraft")
	beego.Router("/api/article/openDeleteReply", &ArticleManage{}, "Delete:DeleteAllReply")
	beego.Router("/api/article/deleteAllArticles", &ArticleManage{}, "Delete:DeleteAllArticles")
	beego.Router("/api/aritcle/getallcategory", &ArticleManage{}, "Get:GetAllCategory")
	beego.Router("/api/article/getarticledetail", &ArticleManage{}, "Get:GetArticleDetail")
	beego.Router("/api/article/getvidodetail", &ArticleManage{}, "Get:GetVidoDetail")
	beego.Router("/api/article/geteditarticlecontent", &ArticleManage{}, "Get:GetEditArticleContent")

}

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)
	fmt.Println("文章标题", actname)
	if len(actname) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}

	actcontent := dataBody["act_content"].(string)
	fmt.Println("文章内容", actcontent)
	if len(actcontent) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章内容不能为空")
		return
	}
	orglogo := dataBody["org_logo"].(string)
	fmt.Println("封面图片", orglogo)
	//if len(orglogo) == 0 {
	//	this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "封面图片不能为空")
	//	return
	//}
	acttype := int64(dataBody["act_type"].(float64))
	fmt.Println("文章分类", acttype)
	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)
	fmt.Println("错误是什么", err)
	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)
	fmt.Println("页面", page)
	limit, _ := this.GetInt64("limit", 10)
	fmt.Println("限制", limit)
	searchKey := this.GetString("keyword", "")
	fmt.Println("搜索字", searchKey)
	classId, _ := this.GetInt64("id", 0)
	status, _ := this.GetInt64("status")
	fmt.Println("页面", page, "限制", limit, "关键字", searchKey, "分类号", classId, "状态值:", status)

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	//org := adminUserInfo.Orgs[adminUserInfo.CurrentOrgId]
	//OrgName := org.OrgName
	//fmt.Println("机构姓名:",OrgName)
	if status == 1 {
		articles, total, err := article_service.GetPublished(userOrgID, page, limit, searchKey)
		category, err := article_service.FindCategoryList(userOrgID)
		fmt.Println("分类号", category)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"articles": articles,
			"total":    total,
			"category": category,
		})
	}
	if status == 2 {
		articles, total, err := article_service.GetDraftbox(userOrgID, page, limit, searchKey)
		category, err := article_service.FindCategoryList(userOrgID)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"articles": articles,
			"total":    total,
			"category": category,
		})
	}

	if status == 3 {
		articles, total, err := article_service.GetNoPass(userOrgID, page, limit, searchKey)
		category, err := article_service.FindCategoryList(userOrgID)
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"articles": articles,
			"total":    total,
			"category": category,
		})
	}

	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) GetAllartic()  {
//	page, _ := this.GetInt64("page", 1)
//	fmt.Println("页面2",page)
//	limit, _ := this.GetInt64("limit", 10)
//	fmt.Println("限制3",limit)
//	adminUserInfo := this.GetAdminUserInfo()
//	userOrgID := adminUserInfo.CurrentOrgId
//	if page <= 0 {
//		page = 1
//	}
//	if limit <= 0 {
//		limit = 10
//	}
//	articles, total, err := article_service.GetAllartic(page, limit, userOrgID)
//	fmt.Println("articles",articles)
//	fmt.Println("total",total)
//	fmt.Println("err",err)
//	if err !=nil{
//		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取文章分类列表失败")
//		return
//	}
//	//org := adminUserInfo.Orgs[adminUserInfo.CurrentOrgId]
//	//OrgName := org.OrgName
//	//fmt.Println("OrgName",OrgName)
//	this.ServeSuccessJSON(map[string]interface{}{
//		"articles":articles,
//		"total":total,
//	})
//}

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)
	articleCategory, errcod := article_service.AddCategory(name)
	fmt.Println(articleCategory)
	fmt.Println("errecod是什么", errcod)
	if errcod == gorm.ErrRecordNotFound {
		fmt.Println("aaaaa")
		err := article_service.SaveCategory(category)
		fmt.Println("报错", err)
		this.ServeSuccessJSON(map[string]interface{}{
			"category": category,
		})
		fmt.Println(err)
	} else if errcod == nil {
		fmt.Println("bbbbbbb")
		this.ServeFailJsonSend(enums.ErrorCodeDBCreate, "添加标签失败:（已经存在同名的标签）")
		return
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"category": category,
		})
	}

	return
}

func (this *ArticleManage) GetArticleCount() {
	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
	}
}

func (this *ArticleManage) GetCategorys() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	page, _ := this.GetInt64("page", 1)
	fmt.Println("页面", page)
	limit, _ := this.GetInt64("limit", 10)
	fmt.Println("限制", limit)
	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))
	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,
		Status:        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,
		Status:        1,
	}

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

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

func (this *ArticleManage) PrviewArticle() {
	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
	}

	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: 3,
	}
	err = article_service.AddPrviewArticle(articles)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加预览失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"art": articles,
	})
	fmt.Println("art是谁", articles)
}

func (this *ArticleManage) GetArtilcePreview() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	articles, err := article_service.GetArtilcePreview(userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取预览失败")
		return
	}
	fmt.Println("文章内容", articles)
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})

}

func (this *ArticleManage) AddDraft() {
	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
	}
	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: 2,
	}
	err = article_service.AddDraft(articles)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "保存草稿失败")
		return
	}
	fmt.Println("文章内容", articles)
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}

func (this *ArticleManage) GetArticleInfo() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是啥", id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	articles, err := article_service.GetArticleInfo(userOrgID, id)
	fmt.Println("错误是什么", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询文章信息失败")
		return
	}
	fmt.Println("编辑文章内容是啥什么", articles)
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}

func (this *ArticleManage) GetVidoInfo() {
	id, _ := this.GetInt64("id")
	fmt.Println("视频id是多少?", id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	vidos, err := article_service.GetArticleInfo(userOrgID, id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询文章信息失败")
		return
	}
	fmt.Println("内容是啥什么", vidos)
	this.ServeSuccessJSON(map[string]interface{}{
		"vidos": vidos,
	})
}
func (this *ArticleManage) DeleteArticle() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId

	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.DeleteArticle(ids, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) DeleteArticles() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少呢", id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	err := article_service.DeleteArticles(id, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) GetMenus() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	categorys, err := article_service.GetMenus(userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"categorys": categorys,
	})
}

func (this *ArticleManage) UpdataArticleInfo() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	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
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	fmt.Println("title", title)
	content := dataBody["content"].(string)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "内容不能为空")
		return
	}
	fmt.Println("content", content)
	images := dataBody["imgs"].(string)
	fmt.Println("images", images)
	classid := int64(dataBody["class_id"].(float64))
	if classid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分类号不能为空")
		return
	}
	//classid, _ := strconv.ParseInt(class_id, 10, 64)
	fmt.Println("分类号", classid)
	fmt.Println("标题", title, "内容", content, "图片", images, "分类号", classid, "机构ID", userOrgID)

	articles := models.Articles{
		Title:         title,
		Content:       content,
		Imgs:          images,
		ClassId:       classid,
		Status:        1,
		Mtime:         time.Now().Unix(),
		ArticleStatus: 1,
	}
	fmt.Println("为什么", articles)
	article_service.UpdataArticleInfo(&articles, userOrgID, id)
	this.ServeSuccessJSON(map[string]interface{}{
		"articls": articles,
	})
}

func (this *ArticleManage) SaveArticleDraft() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	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
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	fmt.Println("title", title)
	content := dataBody["content"].(string)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "内容不能为空")
		return
	}
	fmt.Println("content", content)
	images := dataBody["imgs"].(string)
	fmt.Println("images", images)
	classid := int64(dataBody["class_id"].(float64))
	if classid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分类号不能为空")
		return
	}
	//classid, _ := strconv.ParseInt(class_id, 10, 64)
	fmt.Println("分类号", classid)
	fmt.Println("标题", title, "保存文章草稿内容", content, "图片", images, "分类号", classid, "机构ID", userOrgID)

	articles := models.Articles{
		Title:         title,
		Content:       content,
		Imgs:          images,
		ClassId:       classid,
		Status:        1,
		Mtime:         time.Now().Unix(),
		ArticleStatus: 2,
	}
	fmt.Println("为什么", articles)
	article_service.UpdataArticleInfo(&articles, userOrgID, id)
	this.ServeSuccessJSON(map[string]interface{}{
		"articls": articles,
	})
}

func (this *ArticleManage) UpdateVidoInfo() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	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
	}

	vidname := dataBody["vid_name"].(string)
	fmt.Println("视频名称", vidname)
	if len(vidname) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	vioupload := dataBody["vio_upload"].(string)
	fmt.Println("视频上传路径", vioupload)
	vidpic := dataBody["vid_pic"].(string)
	fmt.Println("视频封面", vidpic)
	if len(vidpic) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}

	vidtype := int64(dataBody["vid_type"].(float64))
	fmt.Println("视频封面", vidtype)
	if vidtype <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	articles := models.Articles{
		Title:         vidname,
		Imgs:          vidpic,
		VideoUrl:      vioupload,
		ClassId:       vidtype,
		Status:        1,
		Mtime:         time.Now().Unix(),
		ArticleStatus: 1,
	}
	article_service.UpdataArticleInfo(&articles, userOrgID, id)
	this.ServeSuccessJSON(map[string]interface{}{
		"articls": articles,
	})
}

func (this *ArticleManage) PreviewEditArticle() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	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
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	fmt.Println("title", title)
	content := dataBody["content"].(string)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "内容不能为空")
		return
	}
	fmt.Println("content", content)
	images := dataBody["imgs"].(string)
	fmt.Println("images", images)
	classid := int64(dataBody["class_id"].(float64))
	if classid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分类号不能为空")
		return
	}
	//classid, _ := strconv.ParseInt(class_id, 10, 64)
	fmt.Println("分类号", classid)
	fmt.Println("标题", title, "内容", content, "图片", images, "分类号", classid, "机构ID", userOrgID)

	articles := models.Articles{
		Title:         title,
		Content:       content,
		Imgs:          images,
		ClassId:       classid,
		Status:        1,
		Mtime:         time.Now().Unix(),
		ArticleStatus: 1,
	}

	article_service.PreviewEditArticle(articles, userOrgID, id)
	this.ServeSuccessJSON(map[string]interface{}{
		"articls": articles,
	})
}

func (this *ArticleManage) GetPreviewInfoTwo() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	articles, err := article_service.GetPreviewInfoById(id, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取预览失败")
		return
	}
	fmt.Println("错误", err)
	fmt.Println("预览文章内容", articles)
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}

func (this *ArticleManage) GetAllComment() {
	page, _ := this.GetInt64("page", 1)
	fmt.Println("页面", page)
	limit, _ := this.GetInt64("limit", 10)
	fmt.Println("限制", limit)
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("文章评论机构id", userOrgID)
	articles, total, err := article_service.GetAllComment(page, limit, userOrgID)
	fmt.Println("文章内容", articles)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取预览失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total":    total,
		"articles": articles,
	})
}

func (this *ArticleManage) GetArticleCommentDetail() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	page, _ := this.GetInt64("page", 1)
	fmt.Println("页面", page)
	limit, _ := this.GetInt64("limit", 10)
	fmt.Println("限制", limit)
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	articles, err := article_service.GetArticleCommentDetail(id, userOrgID)
	comment, total, err := article_service.FindAllComments(page, limit, 20142)
	org := adminUserInfo.Orgs[adminUserInfo.CurrentOrgId]
	fmt.Println("err是什么", err)
	fmt.Println("total", total)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取预览失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
		"comment":  comment,
		"total":    total,
		"orgName":  org.OrgName,
		"orgID":    userOrgID,
	})
}

func (this *ArticleManage) SendReplycontent() {
	replycontent := this.GetString("replycontent")
	actilcid, _ := this.GetInt64("acticlid")
	parentid, _ := this.GetInt64("parentid")
	fmt.Println("回复的内容", replycontent)
	fmt.Println("文章ID", actilcid)
	fmt.Println("父类ID", parentid)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	org := adminUserInfo.Orgs[adminUserInfo.CurrentOrgId]
	orgName := org.OrgName
	orgLogo := org.OrgLogo
	fmt.Println("logo", orgLogo)
	comment := models.Comment{
		Content:           replycontent,
		ParentId:          parentid,
		ArticleId:         actilcid,
		Ctime:             time.Now().Unix(),
		CommentUserId:     userOrgID,
		Status:            1,
		CommentUserAvater: orgLogo,
		CommentUserName:   orgName,
	}
	err := article_service.AddComment(&comment)
	fmt.Println("错误是什么", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"comment": comment,
	})
}

func (this *ArticleManage) GetReplyAllComents() {
	page, _ := this.GetInt64("page", 1)
	fmt.Println("页面", page)
	limit, _ := this.GetInt64("limit", 10)
	fmt.Println("限制", limit)
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID", userOrgID)
	comment, total, err := article_service.GetReplyAllComents(userOrgID, page, limit)
	fmt.Println("comment", comment)
	fmt.Println("total", total)
	fmt.Println("错误", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取评论列表失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"comments": comment,
		"total":    total,
	})
}

func (this *ArticleManage) GetSendInformation() {
	artilcid, _ := this.GetInt64("artilcid")
	fmt.Println("文章id", artilcid)
	parentid, _ := this.GetInt64("parentid")
	fmt.Println("父类id", parentid)
	content := this.GetString("content")
	fmt.Println("文章内容", content)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	org := adminUserInfo.Orgs[adminUserInfo.CurrentOrgId]
	orgName := org.OrgName
	orgLogo := org.OrgLogo
	fmt.Println("logo", orgLogo)
	comment := models.Comment{
		Content:           content,
		ParentId:          parentid,
		ArticleId:         artilcid,
		Ctime:             time.Now().Unix(),
		CommentUserId:     userOrgID,
		Status:            1,
		CommentUserAvater: orgLogo,
		CommentUserName:   orgName,
	}
	err := article_service.AddComment(&comment)
	fmt.Println("错误是什么", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"comment": comment,
	})
}

func (this *ArticleManage) GetSpreadReplay() {
	artilcid, _ := this.GetInt64("artilcid")
	fmt.Println("文章id", artilcid)
	parentid, _ := this.GetInt64("parentid")
	fmt.Println("父类id", parentid)

	comments, err := article_service.GetAllReplyFormId(artilcid, parentid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"comments": comments,
	})
}

func (this *ArticleManage) ClearReplyInfo() {
	id, _ := this.GetInt64("id")
	fmt.Println("id为", id)
	err := article_service.ClearReplyInfo(id)
	fmt.Println("错误为", err)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) DeleteReply() {
	id, _ := this.GetInt64("id")
	fmt.Println("id为", id)
	err := article_service.DeleteReply(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) GetSpreadInfo() {
	parentid, _ := this.GetInt64("parentid")
	acticlid, _ := this.GetInt64("acticlid")
	fmt.Println("父类id", parentid)
	fmt.Println("文章id", acticlid)
	comments, err := article_service.GetQueryReplyInfo(parentid, acticlid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"comments": comments,
	})
}

func (this *ArticleManage) ClearReply() {
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少?", id)
	err := article_service.DeleteReply(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) DeleteComments() {
	id, _ := this.GetInt64("id")
	fmt.Println("id事多少", id)
	err := article_service.DeleteReply(id)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) SaveVidoDraft() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	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
	}

	vidname := dataBody["vid_name"].(string)
	fmt.Println("视频名称", vidname)
	if len(vidname) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}

	vidpic := dataBody["vid_pic"].(string) + "?vframe/jpg/offset/1/w/300/h/200"
	fmt.Println("视频封面", vidpic)
	if len(vidpic) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}

	vidtype := int64(dataBody["vid_type"].(float64))
	fmt.Println("视频类型", vidtype)
	if vidtype <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "文章标题不能为空")
		return
	}
	articles := models.Articles{
		Title:         vidname,
		Imgs:          vidpic,
		ClassId:       vidtype,
		Status:        1,
		Mtime:         time.Now().Unix(),
		ArticleStatus: 2,
	}
	article_service.SaveVidoDraft(&articles, userOrgID, id)
	this.ServeSuccessJSON(map[string]interface{}{
		"articls": articles,
	})
}

func (this *ArticleManage) DeleteAllReply() {
	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)
	}
	fmt.Println("ids是什么", ids)
	err = article_service.DeleteAllReply(ids)

	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) DeleteAllArticles() {
	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)
	}
	fmt.Println("ids是什么", ids)
	err = article_service.DeleteAllArticles(ids)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除失败")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *ArticleManage) GetAllCategory() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	categorys, err := article_service.GetMenus(userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"categorys": categorys,
	})
}

func (this *ArticleManage) GetArticleDetail() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("机构id", userOrgID)
	fmt.Println("id", id)
	articles, err := article_service.GetArticleDetailById(id, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}

func (this *ArticleManage) GetVidoDetail() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("机构id", userOrgID)
	fmt.Println("id", id)
	articles, err := article_service.GetArticleDetailById(id, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}

func (this *ArticleManage) GetEditArticleContent() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _ := this.GetInt64("id")
	fmt.Println("机构id", userOrgID)
	fmt.Println("预览返回id", id)
	articles, err := article_service.GetArticleDetailById(id, userOrgID)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "查询回复内容失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles": articles,
	})
}