Merge branch 'dev' of http://git.ycjcjy.com/SpaceOfCheng/services into dev

controllers/cases/caseuser.go

 // GetCaseUserByCase 根据案场获取用户信息
 func (c *CaseController) GetCaseUserByCase() {
 	caseid := c.GetString("caseid")
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
 
-	list, err := c.dao.GetCaseUserByCase(caseid)
+	list, err := c.dao.GetCaseUserByCase(caseid, page, pageSize)
 
 	if err != nil {
 		c.ResponseError(err)

controllers/channel/channel.go

+package channel
+
+import (
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/channel"
+)
+
+// CaseController 信息
+type ChannelController struct {
+	dao *channel.ChannelServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *ChannelController) Constructor() {
+	c.dao = channel.NewChannelServ(c.Context)
+}
+
+// GetChannelList获取渠道列表
+func (c *ChannelController) GetChannelList() {
+	cases := c.Context.Get("cases").([]model.SysUserCase)
+	caseIDs := c.GetCaseIDs(cases)
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+	list, err := c.dao.GetChannelList(caseIDs, page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(list)
+}
+
+// GetChannelById根据id获取渠道
+func (c *ChannelController) GetChannelById() {
+	caseid := c.GetString(":channelId")
+	channel, err := c.dao.GetChannelById(caseid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(channel)
+}
+
+// SaveChannel 保存渠道信息
+func (c *ChannelController) SaveChannel() {
+	channel := model.TaChannel{}
+	if err := c.ParseForm(&channel); err != nil {
+		c.ResponseError(err)
+	}
+	newChannel, err := c.dao.SaveChannel(channel)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(newChannel)
+}
+
+// DeleteChannel 删除渠道
+func (c *ChannelController) DeleteChannel() {
+	channelId := c.GetString(":channelId")
+	err := c.dao.DeleteChannel(channelId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("删除成功")
+}

controllers/customer/customer.go

 func (c *CustomerController) CustWXList() {
 	phone := c.GetString("phone")
 	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
 
-	custList, total, err := c.serv.GetCustWithWXList(phone, page)
+	custList, total, err := c.serv.GetCustWithWXList(phone, page, pageSize)
 	if err != nil {
 		utils.LogError("获取客户列表失败: " + err.Error())
 		c.ResponseError(
 	}
 
 	c.ResponseJSON(map[string]interface{}{
-		"list":  custList,
-		"total": total,
+		"list":     custList,
+		"pagenum":  total,
+		"page":     page,
+		"pagesize": pageSize,
 	})
 }
 

controllers/message/cmscase.go

 	}
 	c.ResponseJSON("删除成功！")
 }
+
+// CmsCaseShow 前台展示
+func (c *MessageController) CmsCaseShow() {
+	cmscaseid := c.GetString(":cmscaseid")
+	err := c.dao.CmsCaseShow(cmscaseid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("操作成功！")
+}
+
+// CmsCaseHide 前台隐藏
+func (c *MessageController) CmsCaseHide() {
+	cmscaseid := c.GetString(":cmscaseid")
+	err := c.dao.CmsCaseHide(cmscaseid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("操作成功！")
+}

controllers/message/location.go

 	}
 	c.ResponseJSON("删除成功！")
 }
+
+// UpdateLocationSort 修改位置的排序
+func (c *MessageController) UpdateLocationSort() {
+	locations := c.GetString("locations")
+
+	err := c.dao.UpdateLocationSort(locations)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("操作成功！")
+}

controllers/message/news.go

 package message
 
-import "spaceofcheng/services/models/model"
+import (
+	"spaceofcheng/services/models/model"
+)
 
 // GetNews 获取咨询列表
 func (c *MessageController) GetNews() {

controllers/system/role.go

 	caseIDs := c.GetCaseIDs(cases)
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
+	name := c.GetString("name")
+	caseid := c.GetString("caseid")
 
-	list, err := c.dao.GetRoleList(caseIDs, page, pageSize)
+	list, err := c.dao.GetRoleList(caseIDs, name, caseid, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}
 	c.ResponseJSON(info)
 }
 
+// GetRoleMenuByRole 获取角色菜单
+func (c *RoleController) GetRoleMenuByRole() {
+	roleid := c.GetString(":roleid")
+	menus, err := c.dao.GetRoleMeneByID(roleid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(menus)
+}
+
 // SaveCaseRole 保存角色
 func (c *RoleController) SaveCaseRole() {
 	role := model.SysRole{}
 	if err := c.ParseForm(&role); err != nil {
 		c.ResponseError(err)
 	}
-	menuids := c.GetString("menuids")
-	newRole, err := c.dao.SaveRole(role, menuids)
+	newRole, err := c.dao.SaveRole(role)
 	if err != nil {
 		c.ResponseError(err)
 	}
 	c.ResponseJSON(newRole)
 }
 
+// SaveRoleMenus 保存角色对应菜单
+func (c *RoleController) SaveRoleMenus() {
+	roleid := c.GetString(":roleid")
+	menuids := c.GetString("menuids")
+	err := c.dao.SaveRoleMenu(roleid, menuids)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("保存成功！")
+}
+
 // DelCaseRole 删除角色
 func (c *RoleController) DelCaseRole() {
 	roleid := c.GetString(":roleid")

controllers/user/user.go

 	c.ResponseJSON(userList)
 }
 
+// GetUserTypes 获取用户类型
+func (c *UserController) GetUserTypes() {
+	cases := c.Context.Get("cases").([]model.SysUserCase)
+	caseIDs := c.GetCaseIDs(cases)
+	usertypes, err := c.dao.GetUserTypes(caseIDs)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(usertypes)
+}
+
 // UserMapping 用户映射
 func (c *UserController) UserMapping() {
 	userMapping := model.TaUserMapping{}
 
 	c.ResponseJSON(vars)
 }
+
+// GetUserRole 获取用户角色
+func (c *UserController) GetUserRole() {
+	userid := c.GetString("userid")
+	roles, err := c.dao.GetUserRoles(userid)
+	if err != nil {
+		c.ResponseError(
+			err,
+			http.StatusInternalServerError,
+		)
+	}
+	c.ResponseJSON(roles)
+}

models/cases/area.go

 // GetCaseAreaByCase 根据案场获取案场区域
 func (m *CaseDAO) GetCaseAreaByCase(caseid string) ([]AreaInfo, error) {
 	var areas []AreaInfo
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id =?", caseid).Table("sys_case_area").Find(&areas)
+	sql := `select * from sys_case_area where status>` + strconv.Itoa(models.STATUS_DEL) + ` and case_id ='` + caseid + `'`
+	err := m.db.Sql(sql).Find(&sql)
 	return areas, err
 }
 

models/cases/cases.go

 		sql = sql + ` and  a.case_name like '%` + casename + `%'`
 	}
 
-	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
+	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa(page*pageSize)
 
 	err := m.db.Sql(sql).Find(&cases)
 	return cases, err

models/cases/caseuser.go

 )
 
 // GetCaseUserByCase 根据案场id获取案场相关人员
-func (m *CaseDAO) GetCaseUserByCase(caseid string) ([]model.SysCaseUser, error) {
+func (m *CaseDAO) GetCaseUserByCase(caseid string, page int, pageSize int) ([]model.SysCaseUser, error) {
 	var caseusers []model.SysCaseUser
-	err := m.db.Where("case_id=?", caseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&caseusers)
+	err := m.db.Where("case_id=?", caseid).And("status>"+strconv.Itoa(models.STATUS_DEL)).Limit(pageSize, (page-1)*pageSize).Find(&caseusers)
 	return caseusers, err
 }
 
+// GetCaseUserCount 列表数量
+func (m *CaseDAO) GetCaseUserCount(caseid string) (int, error) {
+	var caseusers []model.SysCaseUser
+	err := m.db.Where("case_id=?", caseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&caseusers)
+	if err != nil {
+		return 0, err
+	}
+	return len(caseusers), nil
+}
+
 // GetCaseUserByID 根据id获取相关人员
 func (m *CaseDAO) GetCaseUserByID(userid string) (*model.SysCaseUser, error) {
 	var caseusers []model.SysCaseUser

models/cases/equipment.go

 	"spaceofcheng/services/utils"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // GetEquipmentList 获取体检设备
 // GetCaseEquipmentByID 根据ID获取体检设备
 func (m *CaseDAO) GetCaseEquipmentByID(equipmentid string) (*model.SysCaseEquipment, error) {
 	var caseEquipment []model.SysCaseEquipment
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("spec_id=?", equipmentid).Find(&caseEquipment)
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("equipment_id=?", equipmentid).Find(&caseEquipment)
 	if err != nil {
 		return nil, err
 	}
 func (m *CaseDAO) AddCaseEquipment(caseEquipment *model.SysCaseEquipment) (*model.SysCaseEquipment, error) {
 	caseEquipment.EquipmentId = utils.GetGUID()
 	caseEquipment.Status = models.STATUS_NORMAL
+	caseEquipment.CreateDate = time.Now()
+	user := m.ctx.Get("user").(model.SysUser)
+	caseEquipment.CreateUser = user.UserId
 	_, err := m.db.Insert(caseEquipment)
 	return caseEquipment, err
 }
 // UpdateCaseEquipment 修改体检设备
 func (m *CaseDAO) UpdateCaseEquipment(caseEquipment model.SysCaseEquipment) error {
 	var cols = []string{
-		"spec_name",
+		"name",
+		"equipment_code",
+		"case_id",
 	}
-	_, err := m.db.Cols(cols...).Where("spec_id=?", caseEquipment.EquipmentId).Update(caseEquipment)
+	_, err := m.db.Cols(cols...).Where("equipment_id=?", caseEquipment.EquipmentId).Update(caseEquipment)
 	return err
 }
 
 	var cols = []string{
 		"status",
 	}
-	_, err := m.db.Cols(cols...).Where("spec_id=?", caseEquipment.EquipmentId).Update(caseEquipment)
+	_, err := m.db.Cols(cols...).Where("equipment_id=?", caseEquipment.EquipmentId).Update(caseEquipment)
 	return err
 }

models/cases/key.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strconv"
+	"strings"
 	"time"
 )
 
 	}
 
 	offset := (page - 1) * pageSize
-	query += " LIMIT " + strconv.Itoa(pageSize) + " OFFSET " + strconv.Itoa(offset)
+	query += " order by lock_num asc LIMIT " + strconv.Itoa(pageSize) + " OFFSET " + strconv.Itoa(offset)
 
 	err := m.db.SQL(query, models.STATUS_NORMAL, caseid, models.STATUS_DEL).Find(&keys)
 	return keys, err
 }
 
 // GetKeysCountByCase 根据案场获取钥匙数量
-func (m *CaseDAO) GetKeysCountByCase(caseid string) (int, error) {
+func (m *CaseDAO) GetKeysCountByCase(caseid, num string) (int, error) {
 	var keys []model.TaCaseKey
-	err := m.db.Where("case_id=?", caseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&keys)
+	dao := m.db.Where("case_id=?", caseid).And("status>" + strconv.Itoa(models.STATUS_DEL))
+	if num != "" {
+		dao.And("num like '%" + num + "%'")
+	}
+	err := dao.Find(&keys)
 	return len(keys), err
 }
 
 // AddKey 新增单个钥匙信息
 func (m *CaseDAO) AddKey(key model.TaCaseKey) (*model.TaCaseKey, error) {
 	key.KeyId = utils.GetGUID()
-	key.Status = models.STATUS_NORMAL
+	key.Status = STATUS_UNLOCK
 	key.CreateDate = time.Now()
 	_, err := m.db.Insert(key)
 	return &key, err
 	_, err := m.db.Exec(sql)
 	return err
 }
+
+// GetKeyByNumRange 根据区间获取钥匙
+func (m *CaseDAO) GetKeyByNumRange(caseid, nums string) ([]model.TaCaseKey, error) {
+	var keys []model.TaCaseKey
+	sql := `select * from ta_case_key where status>` + strconv.Itoa(models.STATUS_DEL) + `
+	and case_id='` + caseid + `' and lock_num in ('` + strings.Replace(nums, ",", "','", -1) + `')`
+
+	err := m.db.Sql(sql).Find(keys)
+	return keys, err
+}

models/cases/table.go

 	sql := `select a.*,b.area_name,c.case_name from sys_case_table a 
 	inner join sys_case_area b on a.area_id=b.area_id
 	inner join sys_case c on a.case_id=c.case_id
-	where status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.case_id in ('` +
+	where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and b.status>` + strconv.Itoa(models.STATUS_DEL) +
+		` and c.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.case_id in ('` +
 		strings.Replace(caseids, ",", "','", -1) + `')`
 
 	err := m.db.Sql(sql).Find(&tables)

models/cases/tag.go

 	"strconv"
 	"strings"
 	"time"
+
+	"github.com/astaxie/beego"
 )
 
 // GetTagCount 获取标签总数
 func (m *CaseDAO) GetTagCount(caseids string) (int, error) {
-	var tags []model.SysTag
-	err := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')").Find(&tags)
+	var tags []TagInfo
+	sql := `select tag.*,c.case_names from sys_tag tag inner join (
+	select b.tag_id,GROUP_CONCAT(a.case_name) case_names from sys_case a inner join sys_tag_case b on a.case_id=b.case_id and a.status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	where b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and b.tag_id not in (select tag_id from sys_tag_case where case_id not in ('` +
+		strings.Replace(caseids, ",", "','", -1) + `'))
+	group by b.tag_id ) c on tag.tag_id = c.tag_id where tag.status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&tags)
+
 	return len(tags), err
 }
 
 // TagInfo 标签
 type TagInfo struct {
-	model.TaCmsCase `xorm:"extends"`
-	CaseNames       string
+	model.SysTag `xorm:"extends"`
+	CaseNames    string
 }
 
 // GetTagList 根据案场获取标签
 func (m *CaseDAO) GetTagList(caseids string, page int, pageSize int) ([]TagInfo, error) {
 	var tags []TagInfo
+	offset := (page - 1) * pageSize
 	sql := `select tag.*,c.case_names from sys_tag tag inner join (
 	select b.tag_id,GROUP_CONCAT(a.case_name) case_names from sys_case a inner join sys_tag_case b on a.case_id=b.case_id and a.status > ` + strconv.Itoa(models.STATUS_DEL) + `
 	where b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and b.tag_id not in (select tag_id from sys_tag_case where case_id not in ('` +
 		strings.Replace(caseids, ",", "','", -1) + `'))
-	group by b.tag_id ) c on tag.tag_id = c.tag_id`
+	group by b.tag_id ) c on tag.tag_id = c.tag_id where tag.status>` + strconv.Itoa(models.STATUS_DEL) + ` LIMIT ` + strconv.Itoa(pageSize) + ` OFFSET ` + strconv.Itoa(offset)
 
-	err := m.db.Sql(sql).Find(tags)
+	err := m.db.Sql(sql).Find(&tags)
 	return tags, err
 }
 
 // Tag 标签
 type Tag struct {
-	model.TaCmsCase `xorm:"extends"`
-	TagCases        []model.SysTagCase
+	model.SysTag `xorm:"extends"`
+	TagCases     []model.SysTagCase
 }
 
 // GetTagByID 根据ID获取标签
 func (m *CaseDAO) GetTagByID(tagid string) (*Tag, error) {
 	var tags []Tag
-	err := m.db.Table("sys_tag").Where("tag_id=?", tagid).Find(&tags)
+	sql := `select * from sys_tag where tag_id='` + tagid + `'`
+	err := m.db.Sql(sql).Find(&tags)
 	if err != nil {
 		return nil, err
 	}
 
 // DeleteTag 刪除标签
 func (m *CaseDAO) DeleteTag(tagid string) error {
+	beego.Error(tagid)
 	var tag = model.SysTag{
 		TagId:  tagid,
 		Status: models.STATUS_DEL,

models/channel/channel.go

+package channel
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-xorm/xorm"
+)
+
+// ChannelDAO 当前数据库操作对象
+type ChannelDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewChannelDAO New Inst
+func NewChannelDAO(ctx *utils.Context) *ChannelDAO {
+	return &ChannelDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+type Channel struct {
+	model.TaChannel `xorm:"extends"`
+	CaseName        string
+}
+
+// GetChannelsCount 获取渠道总数
+func (m *ChannelDAO) GetChannelsCount(caseid string) (int, error) {
+	var channels []model.TaChannel
+	dao := m.db.Where("status >" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseid, ",", "','", -1) + "')")
+	err := dao.Find(&channels)
+	return len(channels), err
+}
+
+// GetChannels 根据案场获取渠道
+func (m *ChannelDAO) GetChannels(caseid string, page int, pageSize int) ([]Channel, error) {
+	var channels []Channel
+	sql := `
+	select a.*,b.case_name 
+	from ta_channel a 
+	inner join sys_case b on a.case_id = b.case_id 
+	where a.case_id in('` + strings.Replace(caseid, ",", "','", -1) + `') and b.status> ` + strconv.Itoa(models.STATUS_DEL) + ` and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&channels)
+	return channels, err
+}
+
+// GetChannelById 根据渠道id获取渠道
+func (m *ChannelDAO) GetChannelById(channelId string) (*model.TaChannel, error) {
+	var channel []model.TaChannel
+	err := m.db.Where("channel_id = ?", channelId).And("status > ?", models.STATUS_DEL).Find(&channel)
+	if err != nil {
+		return nil, err
+	}
+	if len(channel) > 0 {
+		return &channel[0], nil
+	}
+	return nil, nil
+}
+
+// AddNewChannel 新增渠道
+func (m *ChannelDAO) AddNewChannel(channel model.TaChannel) (*model.TaChannel, error) {
+	channel.ChannelId = utils.GetGUID()
+	channel.CreateDate = time.Now()
+	channel.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(channel)
+	return &channel, err
+}
+
+// UpdateChannel 修改渠道
+func (m *ChannelDAO) UpdateChannel(channel model.TaChannel) error {
+	var cols = []string{
+		"channel_name",
+		"case_id",
+		"org_id",
+	}
+	_, err := m.db.Cols(cols...).Where("channel_id=?", channel.ChannelId).Update(channel)
+	return err
+}
+
+// DeleteChannel 删除渠道
+func (m *ChannelDAO) DeleteChannel(channelId string) error {
+	var channel = model.TaChannel{
+		ChannelId: channelId,
+		Status:    models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("channel_id", channel.ChannelId).Update(channel)
+	return err
+}

models/customer/customer.go

 	if m.ctx.Get("pageNum") != nil {
 		pageNum = m.ctx.Get("pageNum").(int)
 	}
+	if len(page) > 1 {
+		pageNum = page[1]
+	}
 
 	pg := 1
 	if len(page) > 0 {

models/message/cmscase.go

 	"strings"
 	"time"
 
+	"github.com/astaxie/beego"
+
 	"github.com/go-xorm/builder"
 )
 
 	CaseName        string
 }
 
+const (
+	STATUS_NOSHOW = 0
+)
+
 // GetCmsCaseList 获取项目专题列表
 func (m *MessageDAO) GetCmsCaseList(name, caseids string, page int, pageSize int) ([]CmsCaseInfo, error) {
 	var cases []CmsCaseInfo
 	sql := `select a.*,b.case_name from ta_cms_case a inner join sys_case b on a.case_id = b.case_id 
-	where a.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and a.name like '%` + name + `%' and a.status > ` + strconv.Itoa(models.STATUS_DEL) + `
+	where a.org_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and a.name like '%` + name + `%' and a.status > ` + strconv.Itoa(models.STATUS_DEL) + `
 	and b.status > ` + strconv.Itoa(models.STATUS_DEL) + `
-	order by create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa((page+1)*pageSize)
-
+	order by create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(page*pageSize)
 	err := m.db.Sql(sql).Find(&cases)
 	return cases, err
 }
 func (m *MessageDAO) GetCmsCaseByOrg(orgid string) ([]model.TaCmsCase, error) {
 	var cases []model.TaCmsCase
 	err := m.db.Where("org_id=?", orgid).Find(&cases)
+	beego.Error(cases)
 	return cases, err
 }
 
 // GetCmsCaseByID 获取项目专题详情
 func (m *MessageDAO) GetCmsCaseByID(cmscaseid string) (*CmsCase, error) {
 	var cases []CmsCase
-	err := m.db.Table("ta_cms_case").Where("cms_case_id=?", cmscaseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&cases)
+	sql := `select * from ta_cms_case where cms_case_id='` + cmscaseid + `' and status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&cases)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if len(cases) > 0 {
 	_, err := m.db.Insert(img)
 	return err
 }
+
+// CmsCaseShow 前台展示
+func (m *MessageDAO) CmsCaseShow(cmscaseid string) error {
+	var cmscase = model.TaCmsCase{}
+	cmscase.Status = models.STATUS_NORMAL
+	cmscase.CmsCaseId = cmscaseid
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("cms_case_id=?", cmscase.CmsCaseId).Update(cmscase)
+	return err
+}
+
+// CmsCaseHide 前台隐藏
+func (m *MessageDAO) CmsCaseHide(cmscaseid string) error {
+	var cmscase = model.TaCmsCase{}
+	cmscase.Status = STATUS_NOSHOW
+	cmscase.CmsCaseId = cmscaseid
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("cms_case_id=?", cmscase.CmsCaseId).Update(cmscase)
+	return err
+}

models/message/image.go

 		"forward_resource_id",
 		"sort",
 		"title",
+		"location_id",
+		"status",
 	}
 	_, err := m.db.Cols(cols...).Where("image_id=?", img.ImageId).Update(img)
 	return err

models/message/location.go

 )
 
 const (
-	ISSYS = 1
+	ISSYS = 0
 )
 
 // GetLocationList 获取位置字典
 	if issys != "" {
 		s = s.And("is_sys=?", issys)
 	}
-	err := s.Find(&locations)
+	err := s.Asc("order_no").Find(&locations)
 	return locations, err
 }
 
+// GetLocationMaxSort 获取最大的位置
+func (m *MessageDAO) GetLocationMaxSort(issys, org_id string) (int, error) {
+	var location []map[string][]byte
+	sql := `select max(order_no) as order_no from td_cms_image_location where is_sys=` + issys + ` and org_id ='` + org_id + `'`
+	location, err := m.db.Query(sql)
+	if err != nil {
+		return 0, err
+	}
+	if len(location) > 0 {
+		sort := string(location[0]["order_no"])
+		if sort != "" {
+			sortno, err := strconv.Atoi(string(location[0]["order_no"]))
+			return sortno, err
+		}
+		return 0, err
+	}
+	return 0, nil
+}
+
 // GetLocationById 根据ID获取明细
 func (m *MessageDAO) GetLocationById(id string) (*model.TdCmsImageLocation, error) {
 	var location []model.TdCmsImageLocation
 	_, err := m.db.Cols(cols...).Where("location_id=?", location.LocationId).Update(location)
 	return err
 }
+
+// UpdateLocationSort 修改顺序
+func (m *MessageDAO) UpdateLocationSort(loc []string) error {
+	orderno, err := strconv.Atoi(loc[1])
+	if err != nil {
+		return err
+	}
+	var location = model.TdCmsImageLocation{
+		LocationId: loc[0],
+		OrderNo:    orderno,
+	}
+	var cols = []string{
+		"order_no",
+	}
+	_, err = m.db.Cols(cols...).Where("location_id=?", location.LocationId).Update(location)
+	return err
+}

models/message/message.go

 func (m *MessageDAO) UpdateCmsInfo(cmsinfo model.TaCmsInfo) error {
 	var cols = []string{
 		"info_name",
+		"info_url",
+		"location_id",
+		"case_id",
 	}
 	_, err := m.db.Cols(cols...).Where("info_id=?", cmsinfo.InfoId).Update(cmsinfo)
 	return err

models/message/news.go

 	sql := `select * from ta_cms_news new left join (
 		select b.news_id,GROUP_CONCAT(a.location_name) location_names,GROUP_CONCAT(a.location_id) location_ids 
 		from td_cms_image_location a inner join ta_cms_location b on a.location_id=b.location_id and a.status>` + strconv.Itoa(models.STATUS_DEL) +
-		` and b.org_id='` + orgid + `' group by b.news_id
-		) c on new.news_id = c.news_id and new.status>` + strconv.Itoa(models.STATUS_DEL) + ` and new.org_id='` + orgid + `'`
+		` and a.org_id='` + orgid + `' group by b.news_id
+		) c on new.news_id = c.news_id WHERE new.status>` + strconv.Itoa(models.STATUS_DEL) + ` and new.org_id='` + orgid + `'`
 
 	if locationid != "" {
 		sql += ` and new.news_id in (select news_id from ta_cms_location where location_id='` + locationid + `')`
 	}
 
-	sql = sql + " order by new.create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
-
+	sql = sql + " order by new.create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa(page*pageSize)
 	err := m.db.Sql(sql).Find(&news)
 	return news, err
 }
 // GetNewsByID 获取咨询详情
 func (m *MessageDAO) GetNewsByID(newid string) (*CmsNews, error) {
 	var news []CmsNews
-	err := m.db.Where("news_id=?", newid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&news)
+	sql := `select * from ta_cms_news where news_id='` + newid + `' and status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&news)
 	if err != nil {
 		return nil, err
 	}
 
 // SaveNewsLocation 保存咨询与位置映射
 func (m *MessageDAO) SaveNewsLocation(newsid, locationsid string) error {
-	sql := `insert into ta_cms_location(location_id,news_id) select '` + newsid + `', location_id from td_cms_image_location where location_id in ('` + strings.Replace(locationsid, ",", "','", -1) + `') and status > ` + strconv.Itoa(models.STATUS_DEL)
+	sql := `insert into ta_cms_location(news_id,location_id) select '` + newsid + `', location_id from td_cms_image_location where location_id in ('` + strings.Replace(locationsid, ",", "','", -1) + `') and status > ` + strconv.Itoa(models.STATUS_DEL)
 	_, err := m.db.Exec(sql)
 	return err
 }
 	var cols = []string{
 		"status",
 	}
-	_, err := m.db.Cols(cols...).Where("user_id=?", news.NewsId).Update(news)
+	_, err := m.db.Cols(cols...).Where("news_id=?", news.NewsId).Update(news)
 	return err
 }

models/model/sys_menu.go

 	Status     int       `xorm:"SMALLINT(6)"`
 	CreateDate time.Time `xorm:"DATETIME"`
 	OrgId      string    `xorm:"VARCHAR(64)"`
+	FatherIds  string    `xorm:"TEXT"`
 }

models/system/role.go

 }
 
 // GetRoleCount 获取角色总数
-func (m *RoleDAO) GetRoleCount(caseids string) (int, error) {
+func (m *RoleDAO) GetRoleCount(caseids, name, caseid string) (int, error) {
 	var roles []model.SysRole
-	err := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')").Find(&roles)
+	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+	if name != "" {
+		dao.And("role_name like '%" + name + "%'")
+	}
+	if caseid != "" {
+		dao.And("case_id =?", caseid)
+	}
+	err := dao.Find(&roles)
 	return len(roles), err
 }
 
 // GetRoleList 根据案场获取角色
-func (m *RoleDAO) GetRoleList(caseids string, page int, pageSize int) ([]model.SysRole, error) {
+func (m *RoleDAO) GetRoleList(caseids, name, caseid string, page int, pageSize int) ([]model.SysRole, error) {
 	var roles []model.SysRole
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&roles)
+	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+	if name != "" {
+		dao.And("role_name like '%" + name + "%'")
+	}
+	if caseid != "" {
+		dao.And("case_id =?", caseid)
+	}
+	err := dao.Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&roles)
 	return roles, err
 }
 
 // Role 角色
 type Role struct {
-	model.TaCmsCase `xorm:"extends"`
-	RoleMenu        []model.SysMenu
+	model.SysRole `xorm:"extends"`
+	RoleMenu      []model.SysMenu
 }
 
 // GetRoleByID 根据ID获取角色
-func (m *RoleDAO) GetRoleByID(roleid string) (*Role, error) {
-	var roles []Role
-	err := m.db.Table("sys_role").Where("role_id=?", roleid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&roles)
+func (m *RoleDAO) GetRoleByID(roleid string) (*model.SysRole, error) {
+	var roles []model.SysRole
+	sql := `select * from sys_role where role_id='` + roleid + `' and status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&roles)
 	if err != nil {
 		return nil, err
 	}
 }
 
 // SaveRoleMenu 保存角色对应的菜单
-func (m *RoleDAO) SaveRoleMenu(roleid, caseids string) error {
-	sql := `insert into sys_role_menu(role_id,menu_id) select '` + roleid + `', menu_id from sys_menu where case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `') and status > ` + strconv.Itoa(models.STATUS_DEL)
+func (m *RoleDAO) SaveRoleMenu(roleid, menuids string) error {
+	sql := `insert into sys_role_menu(role_id,menu_id) select DISTINCT '` + roleid + `', a.menu_id from sys_menu a left join sys_menu b on find_in_set(b.menu_id,a.father_ids) where (b.menu_id in ('` + strings.Replace(menuids, ",", "','", -1) + `') or a.menu_id in ('` + strings.Replace(menuids, ",", "','", -1) + `')) and a.status> ` + strconv.Itoa(models.STATUS_DEL)
+	_, err := m.db.Exec(sql)
+	return err
+}
+
+// DelUserMenusByRole 批量删除处理用户对应菜单信息
+func (m *RoleDAO) DelUserMenusByRole(roleid string) error {
+	sql := "delete a from sys_user_menu a inner join sys_user_role b on a.user_id=b.user_id where b.role_id='" + roleid + "'"
+	_, err := m.db.Exec(sql)
+	return err
+}
+
+// SaveUserMenusByRole 批量保存用户对应菜单信息
+func (m *RoleDAO) SaveUserMenus(roleid string) error {
+	sql := `insert into sys_user_menu (user_id,menu_id)
+	select DISTINCT c.user_id,a.menu_id from sys_menu a 
+	inner join sys_role_menu b on a.menu_id = b.menu_id
+	inner join sys_user_role c on b.role_id = c.role_id
+	where c.user_id in (select user_id from sys_user_role where role_id='` + roleid + `')`
 	_, err := m.db.Exec(sql)
 	return err
 }

models/system/user.go

 		select a.user_id,GROUP_CONCAT(b.type_name) as user_type_names from sys_user_type a
 		INNER join td_user_type b on a.type_id = b.type_id
 		group by a.user_id) c on user.user_id = c.user_id where 
-		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user_id in 
+		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user.user_id in 
 		(select user_id from sys_user_tag a inner join sys_tag_case b on a.tag_id=b.tag_id where b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')))`
 
 	if typeid != "" {
-		sql = sql + " and user_id in (select user_id from sys_user_type where type_id = '" + typeid + "')"
+		sql = sql + " and user.user_id in (select user_id from sys_user_type where type_id = '" + typeid + "')"
 	}
 
-	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
-
+	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa(page*pageSize)
 	err := m.db.Sql(sql).Find(&users)
 	return users, err
-
-	// var users []model.SysUser
-	// userDAO := m.db.Where(`(status> `+strconv.Itoa(models.STATUS_DEL)+` and user_name like '%?%' and user_id in
-	// 	(select user_id from sys_user_tag a inner join sys_tag_case b on a.tag_id=b.tag_id where b.case_id in ('?')))`, username, strings.Replace(caseids, ",", "','", -1))
-
-	// if typeid != "" {
-	// 	userDAO.In("user_id", builder.Select("user_id").From("sys_user_type").Where(builder.Eq{"type_id": typeid}))
-	// }
-	// err := userDAO.Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&users)
-	// return users, err
 }
 
 // GetUserCount 用户列表count
 func (m *UserDAO) GetUserCount(username, typeid, caseids string) (int, error) {
-	// var users []model.SysUser
-	// userDAO := m.db.Where(`(status> `+strconv.Itoa(models.STATUS_DEL)+` and user_name like '%?%' and user_id in
-	// 	(select user_id from sys_user_tag a inner join sys_tag_case b on a.tag_id=b.tag_id where b.case_id in ('?')))`, username, strings.Replace(caseids, ",", "','", -1))
-
-	// if typeid != "" {
-	// 	userDAO.In("user_id", builder.Select("user_id").From("sys_user_type").Where(builder.Eq{"type_id": typeid}))
-	// }
-	// err := userDAO.Find(&users)
 	var users []UserListInfo
 	sql := `select user.*,c.user_type_names from sys_user user left join (
 		select a.user_id,GROUP_CONCAT(b.type_name) as user_type_names from sys_user_type a
 		INNER join td_user_type b on a.type_id = b.type_id
 		group by a.user_id) c on user.user_id = c.user_id where 
-		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user_id in 
+		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user.user_id in 
 		(select user_id from sys_user_tag a inner join sys_tag_case b on a.tag_id=b.tag_id where b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')))`
 
 	if typeid != "" {
-		sql = sql + " and user_id in (select user_id from sys_user_type where type_id = '" + typeid + "')"
+		sql = sql + " and user.user_id in (select user_id from sys_user_type where type_id = '" + typeid + "')"
 	}
 	err := m.db.Sql(sql).Find(&users)
 	if err != nil {
 	model.SysUser `xorm:"extends"`
 	UserType      []model.TdUserType
 	UserTag       []model.SysTag
-	UserCase      []model.SysCase
+	UserCase      []model.SysUserCase
 	UserRole      []model.SysRole
 	UserMenu      []model.SysMenu
 }
 
 // GetUserByID 根据ID获取用户信息
 func (m *UserDAO) GetUserByID(userid string) (*UserInfo, error) {
-	var userinfo = UserInfo{}
-	_, err := m.db.Table("sys_user").Where("user_id=?", userid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Get(&userinfo)
+	var userinfo []UserInfo
+	sql := `select * from sys_user where user_id='` + userid + `' and status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&userinfo)
 	if err != nil {
 		return nil, err
 	}
-	return &userinfo, nil
+	if len(userinfo) > 0 {
+		return &userinfo[0], nil
+	}
+	return nil, nil
+}
+
+// GetUserTypes 获取所有的用户类型
+func (m *UserDAO) GetUserTypes(caseids string) ([]model.TdUserType, error) {
+	var usertype []model.TdUserType
+	err := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')").Find(&usertype)
+	return usertype, err
 }
 
 // GetUserType 获取用户类型
 }
 
 // GetUserCase 获取用户案场
-func (m *UserDAO) GetUserCase(userid string) ([]model.SysCase, error) {
-	var userCase []model.SysCase
+func (m *UserDAO) GetUserCase(userid string) ([]model.SysUserCase, error) {
+	var userCase []model.SysUserCase
+	// err := m.db.Where("user_id=?", userid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&userCase)
 	err := m.db.In("case_id", builder.Select("case_id").From("sys_user_case").Where(builder.Eq{"user_id": userid}).And(builder.Gt{"status": models.STATUS_DEL})).Find(&userCase)
 	return userCase, err
 }
 	return err
 }
 
+// GetUserByRole 根据角色获取用户信息
+func (m *UserDAO) GetUserByRole(roleid string) ([]model.SysUserRole, error) {
+	var userroles []model.SysUserRole
+	err := m.db.Where("role_id=?", roleid).Find(&userroles)
+	return userroles, err
+}
+
 // DelUserMenu 删除用户对应的菜单信息
 func (m *UserDAO) DelUserMenu(userid string) error {
 	sql := "delete from sys_user_menu where user_id='" + userid + "'"
 func (m *UserDAO) UpdatePassword(userID, newPass string) error {
 	password := encrypt.Md5(newPass, userID)
 
-	sql := "update sys_user set passwd=? where user_id=?"
+	sql := "update sys_user set pwd=? where user_id=?"
 
 	_, err := m.db.Exec(sql, password, userID)
 	if err != nil {

models/vipcard/vipcard.go

+package vipcard
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-xorm/xorm"
+)
+
+// ChannelDAO 当前数据库操作对象
+type VipcardDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewVipcardDAO New Inst
+func NewVipcardDAO(ctx *utils.Context) *VipcardDAO {
+	return &VipcardDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+type VipChild struct {
+	model.TaVipCardChild `xorm:"extendes"`
+	CaesName             string
+	CustomerName         string
+}
+
+// GetVipCardList获取VIP卡列表
+func (m *VipcardDAO) GetVipCardList(caseid string) ([]VipChild, error) {
+	var vipcards []VipChild
+	sql := `SELECT
+	vcc.*,
+	sc.case_name,
+	tc.customer_name
+FROM
+	ta_vip_card_child vcc
+	INNER JOIN ta_vip_card vc ON vcc.vip_card_id = vc.vip_card_id
+	INNER JOIN sys_case sc ON vc.case_id = sc.case_id 
+	INNER JOIN ta_customer tc on vcc.customer_id = tc.customer_id
+WHERE
+	vcc.status > 0 ` + strconv.Itoa(models.STATUS_DEL) +
+		`AND sc.case_id IN(` + strings.Replace(caseid, ",", "','", -1) + `) `
+	err := m.db.Sql(sql).Find(&vipcards)
+	return vipcards, err
+}
+
+// AddVipCard 新增VIP卡
+func (m *VipcardDAO) AddVipCard(vipCard model.TaVipCard) (*model.TaVipCard, error) {
+	vipCard.VipCardId = utils.GetGUID()
+	vipCard.CreateDate = time.Now()
+	vipCard.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(vipCard)
+	return &vipCard, err
+
+}
+
+// AddVipChildCard 新增VIP子卡
+func (m *VipcardDAO) AddVipChildCard(vipChild model.TaVipCardChild) (*model.TaVipCardChild, error) {
+	vipChild.CreateDate = time.Now()
+	vipChild.VipCardChildId = utils.GetGUID()
+	vipChild.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(vipChild)
+	return &vipChild, err
+}
+
+// GetVipChildByCode 通过code获取VIP子卡
+func (m *VipcardDAO) GetVipChildByCode(vipCode string) (*model.TaVipCardChild, error) {
+	var vipChild []model.TaVipCardChild
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("vip_card_child_code =?", vipCode).Find(&vipChild)
+	if err != nil {
+		return nil, err
+	}
+	if len(vipChild) > 0 {
+		return &vipChild[0], nil
+	}
+	return nil, nil
+}
+
+// UpdateVipChild 更新子卡
+func (m *VipcardDAO) UpdateVipChild(vipChild model.TaVipCardChild) error {
+	var cols = []string{
+		"customer_id",
+		"customer_tel",
+		"active_date",
+	}
+	_, err := m.db.Cols(cols...).Where("vip_card_child_id", vipChild.VipCardChildId).Update(vipChild)
+	return err
+}

routers/common.go

 import (
 	"spaceofcheng/services/controllers"
 	"spaceofcheng/services/controllers/cases"
+	"spaceofcheng/services/controllers/channel"
 	"spaceofcheng/services/controllers/course"
 	"spaceofcheng/services/controllers/customer"
 	"spaceofcheng/services/controllers/goods"
 		// 系统用户
 		beego.NSRouter("/user", &user.UserController{}, "get:GetUserList"),
 		beego.NSRouter("/user/:userid", &user.UserController{}, "get:GetUserByID"),
+		beego.NSRouter("/user", &user.UserController{}, "post:SaveUser"),
+		beego.NSRouter("/user", &user.UserController{}, "put:SaveUser"),
+		beego.NSRouter("/user/:userid", &user.UserController{}, "delete:DelUser"),
 		beego.NSRouter("/user/:userid/password", &user.UserController{}, "put:UpdatePassword"),
 		beego.NSRouter("/user/password/reset", &user.UserController{}, "put:ResetPassword"),
 		beego.NSRouter("/signout", &user.UserController{}, "post:SignOut"),
 
+		// 用户类型
+		beego.NSRouter("/usertype", &user.UserController{}, "get:GetUserTypes"),
+
+		// 用户角色
+		beego.NSRouter("/userrole", &user.UserController{}, "get:GetUserRole"),
+		beego.NSRouter("/userrole", &user.UserController{}, "put:UserMapRole"),
+
 		// cms 位置
 		beego.NSRouter("/cms/location", &message.MessageController{}, "get:GetLocations"),
 		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "get:GetLocationById"),
 		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "put:SaveLocation"),
 		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "delete:DelLocation"),
 
+		beego.NSRouter("/cms/location/:locationid/sort", &message.MessageController{}, "put:UpdateLocationSort"),
+
 		// cms
 		beego.NSRouter("/cms/info", &message.MessageController{}, "get:GetCmsInfoList"),
 		beego.NSRouter("/cms/info/:infoid", &message.MessageController{}, "get:GetCmsInfoByID"),
 		beego.NSRouter("/cms/case", &message.MessageController{}, "post:SaveCmsCase"),
 		beego.NSRouter("/cms/case/:cmscaseid", &message.MessageController{}, "put:SaveCmsCase"),
 		beego.NSRouter("/cms/case/:cmscaseid", &message.MessageController{}, "delete:DelCmsCase"),
+		beego.NSRouter("/cms/caseshow/:cmscaseid", &message.MessageController{}, "put:CmsCaseShow"),
+		beego.NSRouter("/cms/casehide/:cmscaseid", &message.MessageController{}, "put:CmsCaseHide"),
+
+		// tag 标签
+		beego.NSRouter("/case/tag", &cases.CaseController{}, "get:GetTagList"),
+		beego.NSRouter("/case/tag/:tagid", &cases.CaseController{}, "get:GetTagByID"),
+		beego.NSRouter("/case/tag", &cases.CaseController{}, "post:SaveCaseTag"),
+		beego.NSRouter("/case/tag", &cases.CaseController{}, "put:SaveCaseTag"),
+		beego.NSRouter("/case/tag/:tagid", &cases.CaseController{}, "delete:DelCaseTag"),
 
 		// caseuser 案场人员
 		beego.NSRouter("/case/user", &cases.CaseController{}, "get:GetCaseUserByCase"),
 		beego.NSRouter("/case/table", &cases.CaseController{}, "put:SaveCaseTable"),
 		beego.NSRouter("/case/table/:tableid", &cases.CaseController{}, "delete:DelCaseTable"),
 
+		beego.NSRouter("/channel", &channel.ChannelController{}, "get:GetChannelList"),
+		beego.NSRouter("/channel/:channelId", &channel.ChannelController{}, "get:GetChannelById"),
+		beego.NSRouter("/channel", &channel.ChannelController{}, "post:SaveChannel"),
+		beego.NSRouter("/channel", &channel.ChannelController{}, "put:SaveChannel"),
+		beego.NSRouter("/channel/:channelId", &channel.ChannelController{}, "delete:DeleteChannel"),
+
 		// role 角色
 		beego.NSRouter("/role", &system.RoleController{}, "get:GetRoleList"),
 		beego.NSRouter("/role/:roleid", &system.RoleController{}, "get:GetRoleByID"),
 		beego.NSRouter("/role", &system.RoleController{}, "put:SaveCaseRole"),
 		beego.NSRouter("/role/:roleid", &system.RoleController{}, "delete:DelCaseRole"),
 
+		beego.NSRouter("/rolemenu/:roleid", &system.RoleController{}, "get:GetRoleMenuByRole"),
+		beego.NSRouter("/rolemenu/:roleid", &system.RoleController{}, "put:SaveRoleMenus"),
+
 		// course 课程
 		beego.NSRouter("/course/taglist", &course.CourseController{}, "get:GetCourseTagsByPage"),
 		beego.NSRouter("/course/tag", &course.CourseController{}, "get:GetCourseTags"),

service/cases/area.go

 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 
 	"github.com/astaxie/beego"
 )
 // SaveCaseArea 保存区域
 func (s *CaseServ) SaveCaseArea(area model.SysCaseArea) (*model.SysCaseArea, error) {
 	var err error
+	if area.AreaName == "" {
+		return nil, utils.LogError("区域名称不能为空！")
+	}
+
 	if area.AreaId == "" {
 		_, err = s.dao.AddCaseArea(&area)
 	} else {

service/cases/cases.go

 func (s *CaseServ) SaveCase(caseinfo model.SysCase) (*model.SysCase, error) {
 	var newInfo *model.SysCase
 	var err error
+	if caseinfo.CaseName == "" {
+		return nil, utils.LogError("案场名称不能为空！")
+	}
+	if caseinfo.Coordinate == "" {
+		return nil, utils.LogError("案场经纬度不能为空！")
+	}
+
 	if caseinfo.CaseId == "" {
 		newInfo, err = s.dao.AddCase(caseinfo)
 		if err != nil {

service/cases/caseuser.go

 package cases
 
-import "spaceofcheng/services/models/model"
+import (
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
+)
 
 // GetCaseUserByCase 根据案场id获取案场相关人员信息
-func (s *CaseServ) GetCaseUserByCase(caseid string) ([]model.SysCaseUser, error) {
-	caseusers, err := s.dao.GetCaseUserByCase(caseid)
-	return caseusers, err
+func (s *CaseServ) GetCaseUserByCase(caseid string, page int, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	if page == 0 {
+		page = 1
+	}
+	caseusers, err := s.dao.GetCaseUserByCase(caseid, page, pageSize)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	total, err := s.dao.GetCaseUserCount(caseid)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+
+	return map[string]interface{}{
+		"list":     caseusers,
+		"pagesize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, err
 }
 
 // GetCaseUserByType 根据类型获取人员
 func (s *CaseServ) SaveCaseUser(caseuser model.SysCaseUser) (*model.SysCaseUser, error) {
 	var newInfo *model.SysCaseUser
 	var err error
+	if caseuser.UserName == "" {
+		return nil, utils.LogError("人员名称不能为空！")
+	}
+	if caseuser.UserType == "" {
+		return nil, utils.LogError("人员类型不能为空！")
+	}
+	if caseuser.Tel == "" {
+		return nil, utils.LogError("人员电话不能为空！")
+	}
 	if caseuser.CaseUserId == "" {
 		newInfo, err = s.dao.AddCaseUser(caseuser)
 	} else {

service/cases/equipment.go

 import (
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 
 	"github.com/astaxie/beego"
 )
 // SaveCaseEquipment 保存体检设备
 func (s *CaseServ) SaveCaseEquipment(equipment model.SysCaseEquipment) (*model.SysCaseEquipment, error) {
 	var err error
+	if equipment.Name == "" {
+		return nil, utils.LogError("体检设备名称不能为空！")
+	}
 	if equipment.EquipmentId == "" {
 		_, err = s.dao.AddCaseEquipment(&equipment)
 	} else {

service/cases/key.go

 package cases
 
 import (
+	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strconv"
+	"time"
 
 	"github.com/astaxie/beego"
 )
 			isdict = true
 		}
 	}
+
 	if !isdict {
 		return nil, utils.LogError("您没有该案场的权限！")
 	}
 		return nil, err
 	}
 
-	total, err := s.dao.GetCaseCount(caseid, num)
+	total, err := s.dao.GetKeysCountByCase(caseid, num)
 	if err != nil {
 		beego.Error(err)
 		return nil, err
 			beego.Error(err)
 			return nil, err
 		}
-		keys[index].CustomerId = use.CustomerId
-		keys[index].CustomerName = use.CustomerName
+		if use != nil {
+			keys[index].CustomerId = use.CustomerId
+			keys[index].CustomerName = use.CustomerName
+		}
 	}
 
 	return map[string]interface{}{
 
 	for i := beginnum; i <= endnum; i++ {
 		key := model.TaCaseKey{
-			OrgId:   orgid,
-			CaseId:  caseid,
-			LockNum: strconv.Itoa(i),
+			OrgId:      orgid,
+			CaseId:     caseid,
+			LockNum:    strconv.Itoa(i),
+			KeyId:      utils.GetGUID(),
+			Status:     cases.STATUS_UNLOCK,
+			CreateDate: time.Now(),
 		}
 		_, err := s.dao.AddKey(key)
 		if err != nil {

service/cases/table.go

 import (
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 
 	"github.com/astaxie/beego"
 )
 // SaveCaseTable 保存桌位
 func (s *CaseServ) SaveCaseTable(table model.SysCaseTable) (*model.SysCaseTable, error) {
 	var err error
+	if table.TableNo == "" {
+		return nil, utils.LogError("桌位名称不能为空")
+	}
 	if table.TableId == "" {
 		_, err = s.dao.AddCaseTable(&table)
 	} else {

service/cases/tag.go

 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 
 	"github.com/astaxie/beego"
 )
 func (s *CaseServ) SaveTag(tag model.SysTag, caseids string) (*model.SysTag, error) {
 	var newInfo *model.SysTag
 	var err error
+	if tag.TagName == "" {
+		return nil, utils.LogError("标签名称不能为空！")
+	}
+	if caseids == "" {
+		return nil, utils.LogError("案场不能为空！")
+	}
 	if tag.TagId == "" {
 		newInfo, err = s.dao.AddTag(tag)
 	} else {

service/channel/channel.go

+package channel
+
+import (
+	"spaceofcheng/services/models/channel"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+)
+
+// ChannelServ 系统处理
+type ChannelServ struct {
+	ctx *utils.Context
+	dao *channel.ChannelDAO
+}
+
+// NewChannelServ 初始化
+func NewChannelServ(ctx *utils.Context) *ChannelServ {
+	return &ChannelServ{
+		ctx: ctx,
+		dao: channel.NewChannelDAO(ctx),
+	}
+}
+
+// GetChannelList 获取渠道列表
+func (s *ChannelServ) GetChannelList(caseid string, page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	channels, err := s.dao.GetChannels(caseid, page, pageSize)
+	if err != nil {
+		return nil, err
+	}
+	total, err := s.dao.GetChannelsCount(caseid)
+	if err != nil {
+		return nil, err
+	}
+	return map[string]interface{}{
+		"list":     channels,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, err
+}
+
+// GetChannelById 根据渠道id获取渠道
+func (s *ChannelServ) GetChannelById(channelId string) (*model.TaChannel, error) {
+	channel, err := s.dao.GetChannelById(channelId)
+	return channel, err
+}
+
+// SaveChannel 保存渠道
+func (s *ChannelServ) SaveChannel(channel model.TaChannel) (*model.TaChannel, error) {
+	var newChannel *model.TaChannel
+	var err error
+	if channel.ChannelId == "" {
+		newChannel, err = s.dao.AddNewChannel(channel)
+	} else {
+		err = s.dao.UpdateChannel(channel)
+		newChannel = &channel
+	}
+	return newChannel, err
+}
+
+// DeleteChannel 删除渠道
+func (s *ChannelServ) DeleteChannel(caseid string) error {
+	err := s.dao.DeleteChannel(caseid)
+	return err
+}

service/message/cmscase.go

 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 	"strings"
 
 	"github.com/astaxie/beego"
 func (s *MessageServ) SaveCmsCase(cmscase model.TaCmsCase, courseids, imgs, detailimgs string) (*model.TaCmsCase, error) {
 	var newInfo *model.TaCmsCase
 	var err error
+	if cmscase.Name == "" {
+		return nil, utils.LogError("项目名称不能为空！")
+	}
+
+	if cmscase.Title == "" {
+		return nil, utils.LogError("项目标题不能为空！")
+	}
+
 	if cmscase.CmsCaseId == "" {
 		newInfo, err = s.dao.AddCmsCase(cmscase)
 	} else {
 		return nil, err
 	}
 
-	arrimg := strings.Split(imgs, ",")
-	for index, img := range arrimg {
-		CmsImg := model.TaCmsCaseImage{
-			ImageType:    models.IMAGETYPE_COVER,
-			Sort:         (index + 1),
-			CaseImageUrl: img,
-			CmsCaseId:    newInfo.CmsCaseId,
-		}
-		err = s.dao.SaveCmsCaseImg(CmsImg)
-		if err != nil {
-			beego.Error(err)
-			return nil, err
+	if imgs != "" {
+		arrimg := strings.Split(imgs, ",")
+		for index, img := range arrimg {
+			CmsImg := model.TaCmsCaseImage{
+				ImageType:    models.IMAGETYPE_COVER,
+				Sort:         (index + 1),
+				CaseImageUrl: img,
+				CmsCaseId:    newInfo.CmsCaseId,
+			}
+			err = s.dao.SaveCmsCaseImg(CmsImg)
+			if err != nil {
+				beego.Error(err)
+				return nil, err
+			}
 		}
 	}
-	arrdetailimg := strings.Split(detailimgs, ",")
-	for index, img := range arrdetailimg {
-		CmsImg := model.TaCmsCaseImage{
-			ImageType:    models.IMAGETYPE_DETAIL,
-			Sort:         (index + 1),
-			CaseImageUrl: img,
-			CmsCaseId:    newInfo.CmsCaseId,
-		}
-		err = s.dao.SaveCmsCaseImg(CmsImg)
-		if err != nil {
-			beego.Error(err)
-			return nil, err
+	if detailimgs != "" {
+		arrdetailimg := strings.Split(detailimgs, ",")
+		for index, img := range arrdetailimg {
+			CmsImg := model.TaCmsCaseImage{
+				ImageType:    models.IMAGETYPE_DETAIL,
+				Sort:         (index + 1),
+				CaseImageUrl: img,
+				CmsCaseId:    newInfo.CmsCaseId,
+			}
+			err = s.dao.SaveCmsCaseImg(CmsImg)
+			if err != nil {
+				beego.Error(err)
+				return nil, err
+			}
 		}
 	}
 	return newInfo, err
 	err := s.dao.DelCmsCase(cmscaseid)
 	return err
 }
+
+// CmsCaseShow 前台展示
+func (s *MessageServ) CmsCaseShow(cmscaseid string) error {
+	err := s.dao.CmsCaseShow(cmscaseid)
+	return err
+}
+
+// CmsCaseHide 前台隐藏
+func (s *MessageServ) CmsCaseHide(cmscaseid string) error {
+	err := s.dao.CmsCaseHide(cmscaseid)
+	return err
+}

service/message/location.go

 package message
 
-import "spaceofcheng/services/models/model"
+import (
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strings"
+
+	"github.com/astaxie/beego"
+)
 
 // GetLocationList 获取列表
 func (s *MessageServ) GetLocationList(issys, orgid string) ([]model.TdCmsImageLocation, error) {
 // SaveLocation 保存
 func (s *MessageServ) SaveLocation(location model.TdCmsImageLocation) (*model.TdCmsImageLocation, error) {
 	if location.LocationId == "" {
+		sort, err := s.dao.GetLocationMaxSort("0", location.OrgId)
+		if err != nil {
+			beego.Error(err)
+			return nil, err
+		}
+		location.OrderNo = sort + 1
 		newlocation, err := s.dao.AddLocation(location)
 		return newlocation, err
 	}
 	err := s.dao.DelLocation(locationID)
 	return err
 }
+
+// UpdateLocationSort 更新顺序
+func (s *MessageServ) UpdateLocationSort(locations string) error {
+	if locations == "" {
+		return utils.LogError("没有需要修改的5A信息！")
+	}
+	arrlocation := strings.Split(locations, ",")
+	for _, loc := range arrlocation {
+		loc := strings.Split(loc, ":")
+		if len(loc) < 2 {
+			return utils.LogError("修改信息不全！")
+		}
+		err := s.dao.UpdateLocationSort(loc)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

service/message/news.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 func (s *MessageServ) SaveNews(news model.TaCmsNews, locationids string) (*model.TaCmsNews, error) {
 	var newInfo *model.TaCmsNews
 	var err error
+	if news.Title == "" {
+		return nil, errors.New("咨询标题不允许为空！")
+	}
+
+	if news.ImageUrl == "" {
+		return nil, errors.New("图片不允许为空！")
+	}
+
+	if news.ForwardType == "" {
+		return nil, errors.New("跳转类型不允许为空！")
+	}
+	if news.ForwardType == ForwardTypeUrl && news.ForwardUrl == "" {
+		return nil, errors.New("跳转地址不允许为空！")
+	}
+
+	if news.ForwardType == ForwardTypeCourse && news.CaseId == "" {
+		return nil, errors.New("跳转资源不允许为空！")
+	}
+
 	if news.NewsId == "" {
 		newInfo, err = s.dao.AddNews(news)
 	} else {

service/system/role.go

 }
 
 // GetRoleList 获取Role列表
-func (s *RoleServ) GetRoleList(caseids string, page, pageSize int) (map[string]interface{}, error) {
+func (s *RoleServ) GetRoleList(caseids, name, caseid string, page, pageSize int) (map[string]interface{}, error) {
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
 	if page == 0 {
 		page = 1
 	}
-	roles, err := s.dao.GetRoleList(caseids, page, pageSize)
+	roles, err := s.dao.GetRoleList(caseids, name, caseid, page, pageSize)
 	if err != nil {
 		beego.Error(err)
 		return nil, err
 	}
-	total, err := s.dao.GetRoleCount(caseids)
+	total, err := s.dao.GetRoleCount(caseids, name, caseid)
 	if err != nil {
 		beego.Error(err)
 		return nil, err
 }
 
 // GetRoleByID 根据ID获取角色
-func (s *RoleServ) GetRoleByID(roleid string) (*system.Role, error) {
+func (s *RoleServ) GetRoleByID(roleid string) (*model.SysRole, error) {
 	role, err := s.dao.GetRoleByID(roleid)
 	if err != nil {
 		beego.Error(err)
 		return nil, err
 	}
-	if role != nil {
-		menus, err := s.dao.GetRoleMenuByRoleID(roleid)
-		if err != nil {
-			beego.Error(err)
-			return nil, err
-		}
-		role.RoleMenu = menus
-	}
+	// if role != nil {
+	// 	menus, err := s.dao.GetRoleMenuByRoleID(roleid)
+	// 	if err != nil {
+	// 		beego.Error(err)
+	// 		return nil, err
+	// 	}
+	// 	role.RoleMenu = menus
+	// }
 	return role, err
 }
 
+// GetRoleMeneByID 根据ID获取角色菜单
+func (s *RoleServ) GetRoleMeneByID(roleid string) ([]model.SysMenu, error) {
+	menus, err := s.dao.GetRoleMenuByRoleID(roleid)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	return menus, nil
+}
+
 // SaveRole 保存角色
-func (s *RoleServ) SaveRole(role model.SysRole, menuids string) (*model.SysRole, error) {
+func (s *RoleServ) SaveRole(role model.SysRole) (*model.SysRole, error) {
 	var newInfo *model.SysRole
 	var err error
 	if role.RoleId == "" {
 		beego.Error(err)
 		return nil, err
 	}
-	err = s.dao.DelRoleMenu(newInfo.RoleId)
+
+	return newInfo, err
+}
+
+// SaveRoleMenu 保存角色菜单
+func (s *RoleServ) SaveRoleMenu(roleid, menuids string) error {
+	var err error
+	err = s.dao.DelRoleMenu(roleid)
 	if err != nil {
 		beego.Error(err)
-		return nil, err
+		return err
 	}
-	err = s.dao.SaveRoleMenu(newInfo.RoleId, menuids)
+	err = s.dao.SaveRoleMenu(roleid, menuids)
 	if err != nil {
 		beego.Error(err)
-		return nil, err
+		return err
 	}
-	return newInfo, err
+	err = s.dao.DelUserMenusByRole(roleid)
+	if err != nil {
+		beego.Error(err)
+		return err
+	}
+	err = s.dao.SaveUserMenus(roleid)
+	return err
 }
 
 // DelRole 删除角色

service/user.go

 	return err
 }
 
+// GetUserTypes 获取用户类型
+func (s *UserServ) GetUserTypes(caseids string) ([]model.TdUserType, error) {
+	types, err := s.dao.GetUserTypes(caseids)
+	return types, err
+}
+
+// GetUserRoles 获取用户角色
+func (s *UserServ) GetUserRoles(userid string) ([]model.SysRole, error) {
+	if userid == "" {
+		return nil, utils.LogError("没有对应的用户信息！")
+	}
+	userroles, err := s.dao.GetUserRole(userid)
+	return userroles, err
+}
+
 // SaveUserRole 保存用户对应角色
 func (s *UserServ) SaveUserRole(userid, roleids string) error {
+	if userid == "" {
+		return utils.LogError("没有对应的用户信息！")
+	}
+	if roleids == "" {
+		return utils.LogError("没有对应的角色信息！")
+	}
 	err := s.dao.DelUserRole(userid)
 	if err != nil {
 		return err

service/vipcard/vipcard.go

+package vipcard
+
+import (
+	"spaceofcheng/services/models/vipcard"
+	"spaceofcheng/services/utils"
+)
+
+// CaseServ 系统处理
+type VipcardServ struct {
+	ctx *utils.Context
+	dao *vipcard.VipcardDAO
+}
+
+// NewVipcardServ 初始化
+func NewVipcardServ(ctx *utils.Context) *VipcardServ {
+	return &VipcardServ{
+		ctx: ctx,
+		dao: vipcard.NewVipcardDAO(ctx),
+	}
+}