models

controllers/autoreply/autoreply.go

@@ -0,0 +1,59 @@
+package autoreply
+
+import (
+	"wechat-conf/controllers"
+	"wechat-conf/models/model"
+	"wechat-conf/service/autoreply"
+)
+
+// AutoreplyController 信息
+type AutoreplyController struct {
+	dao *autoreply.AutoreplyServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *AutoreplyController) Constructor() {
+	c.dao = autoreply.NewAutoreplyServ(c.Context)
+}
+
+func (c *AutoreplyController) GetAutoReplyList() {
+	user := c.Context.Get("user").(*model.SysUser)
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+	autoType := c.GetString("autoType")
+	list, err := c.dao.GetAutoReplyList(user.OrgId, autoType, page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(list)
+}
+func (c *AutoreplyController) GetAutoReplyById() {
+	autoreplyId := c.GetString(":autoreplyId")
+	autoreply, err := c.dao.GetAutoReplyById(autoreplyId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(autoreply)
+}
+func (c *AutoreplyController) SaveAutoreply() {
+	autoreply := model.TaAutoReply{}
+	if err := c.ParseForm(&autoreply); err != nil {
+		c.ResponseError(err)
+	}
+	newAuto, err := c.dao.SaveAutoReply(autoreply)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(newAuto)
+}
+func (c *AutoreplyController) DeleteAutoReply() {
+	autoreplyId := c.GetString(":autoreplyId")
+	err := c.dao.DeleteAutoReply(autoreplyId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("删除成功")
+}

controllers/menu/menu.go

@@ -0,0 +1,29 @@
+package menu
+
+import (
+	"wechat-conf/controllers"
+	"wechat-conf/models/model"
+	"wechat-conf/service/menu"
+)
+
+// MenuController 信息
+type MenuController struct {
+	dao *menu.MenuServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *MenuController) Constructor() {
+	c.dao = menu.NewMenuServ(c.Context)
+}
+
+func (c *MenuController) GetMenuList() {
+	user := c.Context.Get("user").(*model.SysUser)
+	menu, err := c.dao.GetUserMenu(user.UserType)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(menu)
+}

controllers/sysuser/sysuser.go

@@ -0,0 +1,58 @@
+package sysuser
+
+import (
+	"wechat-conf/controllers"
+	"wechat-conf/models/model"
+	"wechat-conf/service/sysuser"
+)
+
+// SysuserController 信息
+type SysuserController struct {
+	dao *sysuser.SysuserServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *SysuserController) Constructor() {
+	c.dao = sysuser.NewSysuserServ(c.Context)
+}
+
+func (c *SysuserController) GetUserList() {
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+	list, err := c.dao.GetSysuserList(page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(list)
+}
+
+func (c *SysuserController) GetUserById() {
+	userId := c.GetString(":userId")
+	user, err := c.dao.GetSysuserById(userId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(user)
+}
+func (c *SysuserController) SaveUser() {
+	user := model.SysUser{}
+	if err := c.ParseForm(&user); err != nil {
+		c.ResponseError(err)
+	}
+	newUser, err := c.dao.SaveUser(user)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(newUser)
+}
+func (c *SysuserController) DeleteUser() {
+	userId := c.GetString(":userId")
+	err := c.dao.DeleteUser(userId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("删除成功")
+}

models/autoreply/autoreply.go

@@ -0,0 +1,107 @@
+package autoreply
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// AutoreplyDAO 当前数据库操作对象
+type AutoreplyDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewAutoreplyDAO New Inst
+func NewAutoreplyDAO(ctx *utils.Context) *AutoreplyDAO {
+	return &AutoreplyDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+func (m *AutoreplyDAO) GetAutoReplyList(orgId, autoType string, page, pagesize int) ([]model.TaAutoReply, error) {
+	var autoreply []model.TaAutoReply
+	sql := `SELECT
+	* 
+FROM
+	ta_auto_reply 
+WHERE
+	org_id = '` + orgId + `'
+	AND auto_type = '` + autoType + `'
+	and status >`+ strconv.Itoa(models.STATUS_DEL)
+	sql += ` order by create_date desc limit ` + strconv.Itoa((page-1)*pagesize) + `, ` + strconv.Itoa(pagesize)
+	err := m.db.Sql(sql).Find(&autoreply)
+	return autoreply, err
+}
+func (m *AutoreplyDAO) GetAutoReplyListCount(orgId, autoType string) (int, error) {
+	var autoreply []model.TaAutoReply
+	sql := `SELECT
+	* 
+FROM
+	ta_auto_reply 
+WHERE
+	org_id = '` + orgId + `'
+	AND auto_type = '` + autoType + `'`
+	err := m.db.Sql(sql).Find(&autoreply)
+	return len(autoreply), err
+}
+func (m *AutoreplyDAO) AddAutoReply(auto model.TaAutoReply) (*model.TaAutoReply, error) {
+	auto.CreateDate = time.Now()
+	auto.Status = models.STATUS_NORMAL
+	auto.AutoReplyId = utils.GetGUID()
+	_, err := m.db.Insert(auto)
+	return &auto, err
+}
+func (m *AutoreplyDAO) AddKeyword(keyword model.TaAutoReplyKeywords) error {
+	keyword.KeywordsId = utils.GetGUID()
+	keyword.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(keyword)
+	return err
+}
+func (m *AutoreplyDAO) UpdateAutoRelpy(auto model.TaAutoReply) error {
+	var cols = []string{
+		"auto_type",
+		"rule_name",
+		"pair_type",
+		"message_type",
+		"message_paragraph",
+		"message_img",
+		"message_content",
+		"keywords",
+	}
+	_, err := m.db.Cols(cols...).Where("auto_reply_id = ?", auto.AutoReplyId).Update(auto)
+	return err
+}
+func (m *AutoreplyDAO) DeleteKeywords(autoReplyId string) error {
+	_, err := m.db.Delete(&model.TaAutoReplyKeywords{AutoReplyId: autoReplyId})
+	return err
+}
+func (m *AutoreplyDAO) DeleteAutoReply(autoReplyId string) error {
+	var auto = model.TaAutoReply{
+		AutoReplyId: autoReplyId,
+		Status:      models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("auto_reply_id = ?", auto.AutoReplyId).Update(auto)
+	return err
+}
+func (m *AutoreplyDAO) GetAutoReplyById(autoReplyId string) (*model.TaAutoReply, error) {
+	var autoReply []model.TaAutoReply
+	sql := `SELECT
+	* 
+FROM
+	ta_auto_reply 
+WHERE
+	auto_reply_id = '` + autoReplyId + `'`
+	err := m.db.Sql(sql).Find(&autoReply)
+	if len(autoReply) > 0 {
+		return &autoReply[0], err
+	}
+	return nil, err
+}

models/menu/menu.go

@@ -0,0 +1,35 @@
+package menu
+
+import (
+	"strconv"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// MenuDAO 当前数据库操作对象
+type MenuDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewMenuDAO New Inst
+func NewMenuDAO(ctx *utils.Context) *MenuDAO {
+	return &MenuDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+func (m *MenuDAO) GetUserMenu(userType string) ([]model.SysMenu, error) {
+	var menu []model.SysMenu
+	sql := `select * from sys_menu where status > ` + strconv.Itoa(models.STATUS_DEL)
+	if userType != models.USER_TYPE_ADMIN {
+		sql += ` and is_only_super_admin = 0`
+	}
+	sql += ` order by order_no asc`
+	err := m.db.Sql(sql).Find(&menu)
+	return menu, err
+}

models/sysorg/sysorg.go

@@ -0,0 +1,67 @@
+package sysorg
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// SysorgDAO 当前数据库操作对象
+type SysorgDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewSysorgDAO New Inst
+func NewSysorgDAO(ctx *utils.Context) *SysorgDAO {
+	return &SysorgDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+func (m *SysorgDAO) GetOrgList(page, pagesize int) ([]model.SysOrg, error) {
+	var org []model.SysOrg
+	sql := `select * from sys_org where status >` + strconv.Itoa(models.STATUS_DEL)
+	sql += ` order by create_date desc limit ` + strconv.Itoa((page-1)*pagesize) + `, ` + strconv.Itoa(pagesize)
+	err := m.db.Sql(sql).Find(&org)
+	return org, err
+}
+func (m *SysorgDAO) GetOrgListCount() (int, error) {
+	var org []model.SysOrg
+	sql := `select * from sys_org where status >` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&org)
+	return len(org), err
+}
+func (m *SysorgDAO) AddOrg(org model.SysOrg) (*model.SysOrg, error) {
+	org.OrgId = utils.GetGUID()
+	org.CreateDate = time.Now()
+	org.Status = models.STATUS_NORMAL
+	org.AuthStatus = models.AUTH_STATUS_NO
+	_, err := m.db.Insert(org)
+	return &org, err
+}
+func (m *SysorgDAO) AuthOrg(org model.SysOrg) error {
+	org.AuthStatus = models.AUTH_STATUS_YES
+	var cols = []string{
+		"auth_status",
+		"wechat_id",
+		"wechat_name",
+	}
+	_, err := m.db.Cols(cols...).Where("org_id = ?", org.OrgId).Update(org)
+	return err
+}
+func (m *SysorgDAO) DeleteOrg(orgId string) error {
+	var org = model.SysOrg{
+		OrgId:  orgId,
+		Status: models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("org_id = ?", org.OrgId).Update(org)
+	return err
+}

models/sysuser/sysuser.go

@@ -0,0 +1,91 @@
+package sysuser
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// SysuserDAO 当前数据库操作对象
+type SysuserDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewSysuserDAO New Inst
+func NewSysuserDAO(ctx *utils.Context) *SysuserDAO {
+	return &SysuserDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+func (m *SysuserDAO) GetSysuserList(page, pageSize int) ([]model.SysUser, error) {
+	var user []model.SysUser
+	sql := `SELECT * from sys_user WHERE status >` + strconv.Itoa(models.STATUS_DEL) + `
+	order by create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
+	err := m.db.Sql(sql).Find(&user)
+	return user, err
+
+}
+func (m *SysuserDAO) GetSysuserListCount() (int, error) {
+	var user []model.SysUser
+	sql := `SELECT * from sys_user WHERE status >` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&user)
+	return len(user), err
+
+}
+func (m *SysuserDAO) GetSysuserById(userId string) (*model.SysUser, error) {
+	var user []model.SysUser
+	sql := `SELECT * from sys_user WHERE status >` + strconv.Itoa(models.STATUS_DEL) + `
+	 and user_id = '` + userId + `'`
+	err := m.db.Sql(sql).Find(&user)
+	if len(user) > 0 {
+		return &user[0], err
+	}
+	return nil, err
+}
+func (m *SysuserDAO) AddUser(user model.SysUser) (*model.SysUser, error) {
+	user.CreateDate = time.Now()
+	user.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(user)
+	return &user, err
+}
+func (m *SysuserDAO) DeleteUser(userId string) error {
+	var user = model.SysUser{
+		UserId: userId,
+		Status: models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("user_id = ?", user.UserId).Update(user)
+	return err
+}
+func (m *SysuserDAO) EditUser(user model.SysUser) error {
+	var cols = []string{
+		"user_name",
+		"real_name",
+		"phone",
+		"email",
+		"head_imgurl",
+	}
+	_, err := m.db.Cols(cols...).Where("user_id = ?", user.UserId).Update(user)
+	return err
+}
+
+func (m *SysuserDAO) BindUserToOrg(userId, orgId string) error {
+	var user = model.SysUser{
+		UserId: userId,
+		OrgId:  orgId,
+	}
+	var cols = []string{
+		"org_id",
+	}
+	_, err := m.db.Cols(cols...).Where("user_id=?", user.UserId).Update(user)
+	return err
+}

models/wechatcontent/wechatcontent.go

@@ -0,0 +1,66 @@
+package wechatcontent
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// WechatContentDAO 当前数据库操作对象
+type WechatContentDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewWechatContentDAO New Inst
+func NewWechatContentDAO(ctx *utils.Context) *WechatContentDAO {
+	return &WechatContentDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+func (m *WechatContentDAO) GetWechatContentList(orgId string, page, pagesize int) ([]model.TaWechatContent, error) {
+	var content []model.TaWechatContent
+	sql := `SELECT * FROM ta_wechat_content where status > ` + strconv.Itoa(models.STATUS_DEL) + ` 
+	and org_id = '` + orgId + `'`
+	sql += ` order by create_date desc limit ` + strconv.Itoa((page-1)*pagesize) + `, ` + strconv.Itoa(pagesize)
+	err := m.db.Sql(sql).Find(&content)
+	return content, err
+}
+func (m *WechatContentDAO) GetWechatContentListCount(orgId string) (int, error) {
+	var content []model.TaWechatContent
+	sql := `SELECT * FROM ta_wechat_content where status > ` + strconv.Itoa(models.STATUS_DEL) + ` 
+	and org_id = '` + orgId + `'`
+	err := m.db.Sql(sql).Find(&content)
+	return len(content), err
+}
+func (m *WechatContentDAO) GetWechatContentByMediaId(mediaId string) (*model.TaWechatContent, error) {
+	var content []model.TaWechatContent
+	sql := `SELECT * FROM ta_wechat_content where media_id = '` + mediaId + `'`
+	err := m.db.Sql(sql).Find(&content)
+	if len(content) > 0 {
+		return &content[0], err
+	}
+	return nil, err
+}
+func (m *WechatContentDAO) AddWechatContent(content model.TaWechatContent) error {
+	content.CreateDate = time.Now()
+	content.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(content)
+	return err
+}
+func (m *WechatContentDAO) DeleteWechatContent(mediaId string) error {
+	var content = model.TaWechatContent{
+		MediaId: mediaId,
+		Status:  models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("media_id = ?", content.MediaId).Update(content)
+	return err
+}

models/wechatimg/wechatimg.go

@@ -0,0 +1,67 @@
+package wechatimg
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// WechatImgDAO 当前数据库操作对象
+type WechatImgDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewWechatImgDAO New Inst
+func NewWechatImgDAO(ctx *utils.Context) *WechatImgDAO {
+	return &WechatImgDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+func (m *WechatImgDAO) GetWechatImgList(orgId string, page, pagesize int) ([]model.TaWechatImg, error) {
+	var img []model.TaWechatImg
+	sql := `SELECT * FROM ta_wechat_img WHERE status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	and org_id = '` + orgId + `'`
+	sql += ` order by create_date desc limit ` + strconv.Itoa((page-1)*pagesize) + `, ` + strconv.Itoa(pagesize)
+	err := m.db.Sql(sql).Find(&img)
+	return img, err
+}
+func (m *WechatImgDAO) GetWechatImgListCount(orgId string, page, pagesize int) (int, error) {
+	var img []model.TaWechatImg
+	sql := `SELECT * FROM ta_wechat_img WHERE status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	and org_id = '` + orgId + `'`
+	err := m.db.Sql(sql).Find(&img)
+	return len(img), err
+}
+func (m *WechatImgDAO) GetWechatImgByMediaId(mediaId string) (*model.TaWechatImg, error) {
+	var img []model.TaWechatImg
+	sql := `SELECT * FROM ta_wechat_img WHERE status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	and media_id = '` + mediaId + `'`
+	err := m.db.Sql(sql).Find(&img)
+	if len(img) > 0 {
+		return &img[0], err
+	}
+	return nil, err
+}
+func (m *WechatImgDAO) AddWechatImg(img model.TaWechatImg) error {
+	img.CreateDate = time.Now()
+	img.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(img)
+	return err
+}
+func (m *WechatImgDAO) DeleteWechatImg(mediaId string) error {
+	var img = model.TaWechatImg{
+		MediaId: mediaId,
+		Status:  models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("media_id = ?", img.MediaId).Update(img)
+	return err
+}

models/wechatmenu/wechatmenu.go

@@ -0,0 +1,60 @@
+package wechatmenu
+
+import (
+	"strconv"
+	"time"
+	"wechat-conf/models"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+
+	"github.com/go-xorm/xorm"
+)
+
+// WechatMenuDAO 当前数据库操作对象
+type WechatMenuDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewWechatMenuDAO New Inst
+func NewWechatMenuDAO(ctx *utils.Context) *WechatMenuDAO {
+	return &WechatMenuDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+func (m *WechatMenuDAO) GetWechatMenuByOrgId(orgId string) (*model.TaWechatMenu, error) {
+	var menu []model.TaWechatMenu
+	sql := `SELECT * FROM ta_wechat_menu where status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	and org_id = '` + orgId + `'`
+	err := m.db.Sql(sql).Find(&menu)
+	if len(menu) > 0 {
+		return &menu[0], err
+	}
+	return nil, err
+}
+func (m *WechatMenuDAO) AddWechatMenu(menu model.TaWechatMenu) (*model.TaWechatMenu, error) {
+	menu.WechatConfigId = utils.GetGUID()
+	menu.Status = models.STATUS_NORMAL
+	menu.CreateDate = time.Now()
+	_, err := m.db.Insert(menu)
+	return &menu, err
+}
+func (m *WechatMenuDAO) UpdateWechatMenu(menu model.TaWechatMenu) error {
+	var cols = []string{
+		"wechat_config_json",
+	}
+	_, err := m.db.Cols(cols...).Where("wechat_config_id = ?", menu.WechatConfigId).Update(menu)
+	return err
+}
+func (m *WechatMenuDAO) DeleteWechatMenu(wechatConfigId string) error {
+	var menu = model.TaWechatMenu{
+		WechatConfigId: wechatConfigId,
+		Status:         models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("wechat_config_id = ?", menu.WechatConfigId).Update(menu)
+	return err
+}

service/autoreply/autoreply.go

@@ -0,0 +1,89 @@
+package autoreply
+
+import (
+	"errors"
+	"strings"
+	"wechat-conf/models/autoreply"
+	"wechat-conf/models/model"
+	"wechat-conf/service"
+	"wechat-conf/utils"
+)
+
+// AutoreplyServ 用户
+type AutoreplyServ struct {
+	ctx *utils.Context
+	dao *autoreply.AutoreplyDAO
+}
+
+// NewAutoreplyServ 初始化
+func NewAutoreplyServ(ctx *utils.Context) *AutoreplyServ {
+	return &AutoreplyServ{
+		ctx: ctx,
+		dao: autoreply.NewAutoreplyDAO(ctx),
+	}
+}
+func (s *AutoreplyServ) GetAutoReplyList(orgId, autoType string, page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	autoreply, err := s.dao.GetAutoReplyList(orgId, autoType, page, pageSize)
+	if err != nil {
+		utils.LogError("获取自动回复列表失败: " + err.Error())
+		return nil, errors.New("获取自动回复列表失败")
+	}
+	total, err := s.dao.GetAutoReplyListCount(orgId, autoType)
+	if err != nil {
+		utils.LogError("获取自动回复列表失败: " + err.Error())
+		return nil, errors.New("获取自动回复列表失败")
+	}
+	return map[string]interface{}{
+		"list":     autoreply,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+
+func (s *AutoreplyServ) GetAutoReplyById(autoReplyId string) (*model.TaAutoReply, error) {
+	autoreply, err := s.dao.GetAutoReplyById(autoReplyId)
+	if err != nil {
+		utils.LogError("获取自动回复详情失败: " + err.Error())
+		return nil, errors.New("获取自动回复详情失败")
+	}
+	return autoreply, nil
+}
+
+func (s *AutoreplyServ) SaveAutoReply(autoreply model.TaAutoReply) (*model.TaAutoReply, error) {
+	var newAutoreply *model.TaAutoReply
+	var err error
+	if autoreply.AutoReplyId == "" {
+		newAutoreply, err = s.dao.AddAutoReply(autoreply)
+	} else {
+		err = s.dao.DeleteKeywords(autoreply.AutoReplyId)
+		err = s.dao.UpdateAutoRelpy(autoreply)
+		newAutoreply = &autoreply
+	}
+	keywords := strings.Split(autoreply.KeyWords, ",")
+	for i := 0; i < len(keywords); i++ {
+		var keyword = model.TaAutoReplyKeywords{
+			AutoReplyId: newAutoreply.AutoReplyId,
+			Keywords:    keywords[i],
+		}
+		err = s.dao.AddKeyword(keyword)
+	}
+	if err != nil {
+		utils.LogError("保存自动回复失败: " + err.Error())
+		return nil, errors.New("保存自动回复失败")
+	}
+	return newAutoreply, nil
+}
+
+func (s *AutoreplyServ) DeleteAutoReply(autoreplyId string) error {
+	err := s.dao.DeleteAutoReply(autoreplyId)
+	err = s.dao.DeleteKeywords(autoreplyId)
+	if err != nil {
+		utils.LogError("删除自动回复失败: " + err.Error())
+		return errors.New("删除自动回复失败")
+	}
+	return nil
+}

service/menu/menu.go

@@ -0,0 +1,31 @@
+package menu
+
+import (
+	"errors"
+	"wechat-conf/models/menu"
+	"wechat-conf/models/model"
+	"wechat-conf/utils"
+)
+
+// MenuServ 用户
+type MenuServ struct {
+	ctx *utils.Context
+	dao *menu.MenuDAO
+}
+
+// NewMenuServ 初始化
+func NewMenuServ(ctx *utils.Context) *MenuServ {
+	return &MenuServ{
+		ctx: ctx,
+		dao: menu.NewMenuDAO(ctx),
+	}
+}
+
+func (s *MenuServ) GetUserMenu(userType string) ([]model.SysMenu, error) {
+	menu, err := s.dao.GetUserMenu(userType)
+	if err != nil {
+		utils.LogError("获取菜單失败: " + err.Error())
+		return nil, errors.New("获取菜單失败")
+	}
+	return menu, nil
+}

service/sysorg/sysorg.go

@@ -0,0 +1,53 @@
+package sysorg
+
+import (
+	"errors"
+	"wechat-conf/models/model"
+	"wechat-conf/models/sysorg"
+	"wechat-conf/service"
+	"wechat-conf/utils"
+)
+
+// SysorgServ 用户
+type SysorgServ struct {
+	ctx *utils.Context
+	dao *sysorg.SysorgDAO
+}
+
+// NewSysorgServ 初始化
+func NewSysorgServ(ctx *utils.Context) *SysorgServ {
+	return &SysorgServ{
+		ctx: ctx,
+		dao: sysorg.NewSysorgDAO(ctx),
+	}
+}
+func (s *SysorgServ) GetOrgList(page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	org, err := s.dao.GetOrgList(page, pageSize)
+	if err != nil {
+		utils.LogError("获取项目列表失败: " + err.Error())
+		return nil, errors.New("获取项目列表失败")
+	}
+	total, err := s.dao.GetOrgListCount()
+	if err != nil {
+		utils.LogError("获取项目列表失败: " + err.Error())
+		return nil, errors.New("获取项目列表失败")
+	}
+	return map[string]interface{}{
+		"list":     org,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+func (s *SysorgServ) AddOrg(org model.SysOrg) (*model.SysOrg, error) {
+	newOrg, err := s.dao.AddOrg(org)
+	if err != nil {
+		utils.LogError("新增项目失败: " + err.Error())
+		return nil, errors.New("新增项目失败")
+	}
+	return newOrg, nil
+}
+func (s *SysorgServ)AuthOrg()

service/sysuser/sysuser.go

@@ -0,0 +1,76 @@
+package sysuser
+
+import (
+	"errors"
+	"wechat-conf/models/model"
+	"wechat-conf/models/sysuser"
+	"wechat-conf/service"
+	"wechat-conf/utils"
+)
+
+// SysuserServ 用户
+type SysuserServ struct {
+	ctx *utils.Context
+	dao *sysuser.SysuserDAO
+}
+
+// NewSysuserServ 初始化
+func NewSysuserServ(ctx *utils.Context) *SysuserServ {
+	return &SysuserServ{
+		ctx: ctx,
+		dao: sysuser.NewSysuserDAO(ctx),
+	}
+}
+
+func (s *SysuserServ) GetSysuserList(page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	sysuser, err := s.dao.GetSysuserList(page, pageSize)
+	if err != nil {
+		utils.LogError("获取用户列表失败: " + err.Error())
+		return nil, errors.New("获取用户列表失败")
+	}
+	total, err := s.dao.GetSysuserListCount()
+	if err != nil {
+		utils.LogError("获取用户列表失败: " + err.Error())
+		return nil, errors.New("获取用户列表失败")
+	}
+	return map[string]interface{}{
+		"list":     sysuser,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+func (s *SysuserServ) GetSysuserById(userId string) (*model.SysUser, error) {
+	user, err := s.dao.GetSysuserById(userId)
+	if err != nil {
+		utils.LogError("获取用户详情失败: " + err.Error())
+		return nil, errors.New("获取用户详情失败")
+	}
+	return user, nil
+}
+func (s *SysuserServ) SaveUser(user model.SysUser) (*model.SysUser, error) {
+	var newUser *model.SysUser
+	var err error
+	if user.UserId == "" {
+		newUser, err = s.dao.AddUser(user)
+	} else {
+		err = s.dao.EditUser(user)
+		newUser = &user
+	}
+	if err != nil {
+		utils.LogError("保存用户详情失败: " + err.Error())
+		return nil, errors.New("保存用户详情失败")
+	}
+	return newUser, nil
+}
+func (s *SysuserServ) DeleteUser(userId string) error {
+	err := s.dao.DeleteUser(userId)
+	if err != nil {
+		utils.LogError("删除用户失败: " + err.Error())
+		return errors.New("删除用户失败")
+	}
+	return nil
+}

service/user/user.go

@@ -1,6 +1,7 @@
 package user
 
 import (
+	"cdkj-check/helper"
 	"net/http"
 	"strings"
 	"wechat-conf/models/model"