feats

conf/sms.conf

 # 短信接口
-url = http://localhost:8080/sms
+url = http://micservice.ycjcjy.com/sms
 method = POST
 contentType = "application/json;charset=UTF-8"
 
 [captcha]
-code = 0107
+code = 0113

controllers/cases/case.go

 
 // GetCaseByID 根据ID获取案场信息
 func (c *CaseController) GetCaseByID() {
-	caseid := c.GetString(":caseid")
+	caseid := c.GetString(":id")
 	info, err := c.dao.GetCaseByID(caseid)
 	if err != nil {
 		c.ResponseError(err)
 
 //DelCase 删除案场信息
 func (c *CaseController) DelCase() {
-	caseid := c.GetString(":caseid")
+	caseid := c.GetString(":id")
 	err := c.dao.DelCase(caseid)
 	if err != nil {
 		c.ResponseError(err)

controllers/cases/key.go

 	pageSize, _ := c.GetInt("pagesize")
 	num := c.GetString("num")
 
+	if page < 1 {
+		page = 1
+	}
+
 	list, err := c.dao.GetKeysByCase(caseid, num, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)

controllers/course/course.go

+package course
+
+import (
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/service/course"
+)
+
+// CourseController 商品
+type CourseController struct {
+	dao *course.CourseServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *CourseController) Constructor() {
+	c.dao = course.NewCourseServ(c.Context)
+}

controllers/course/tag.go

+package course
+
+import "spaceofcheng/services/models/model"
+
+// GetCourseTagsByPage 获取课程标签
+func (c *CourseController) GetCourseTagsByPage() {
+	orgid := c.GetString("orgid")
+	if orgid == "" {
+		org := c.Context.Get("org").(*model.SysOrg)
+		orgid = org.OrgId
+	}
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+	tags, err := c.dao.GetTagsList(orgid, page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(tags)
+}
+
+// GetCourseTags 获取课程标签
+func (c *CourseController) GetCourseTags() {
+	orgid := c.GetString("orgid")
+	if orgid == "" {
+		org := c.Context.Get("org").(*model.SysOrg)
+		orgid = org.OrgId
+	}
+	tags, err := c.dao.GetCourseTags(orgid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(tags)
+}

controllers/message/image.go

 package message
 
-import "spaceofcheng/services/models/model"
+import (
+	"spaceofcheng/services/models/model"
+)
 
 // GetImgList 获取轮播图列表
 func (c *MessageController) GetImgList() {

log/common.2018-08-19.log

+2018/08/19 11:00:44 [E] 用户登录失败: 账户不存在
+2018/08/19 11:02:08 [E] 用户登录失败: 账户不存在
+2018/08/19 11:02:30 [E] 用户登录失败: 账户不存在
+2018/08/19 11:04:13 [E] 用户登录失败: 账户不存在
+2018/08/19 11:04:23 [E] 用户登录失败: 账户不存在
+2018/08/19 11:04:53 [E] 用户登录失败: 账户不存在
+2018/08/19 12:40:59 [E] 用户登录失败: 账户不存在
+2018/08/19 12:41:32 [E] 用户登录失败: 账户不存在
+2018/08/19 12:53:00 [E] 用户登录失败: 账户不存在
+2018/08/19 12:53:39 [E] 用户登录失败: 账户不存在
+2018/08/19 12:53:59 [E] 用户登录失败: 账户不存在
+2018/08/19 12:56:51 [E] 用户登录失败: 账户不存在
+2018/08/19 12:57:10 [E] 用户登录失败: 账户不存在
+2018/08/19 12:58:27 [E] 用户登录失败: 账户不存在
+2018/08/19 13:00:08 [E] 用户登录失败: 账户不存在
+2018/08/19 13:33:36 [E] 用户登录失败: 账户不存在
+2018/08/19 13:51:39 [E] 用户登录失败: 账户不存在
+2018/08/19 13:51:48 [E] 用户登录失败: 账户不存在
+2018/08/19 13:52:14 [E] 用户登录失败: 用户密码不正确
+2018/08/19 13:52:14 [E] 用户登录失败: 账户不存在
+2018/08/19 13:52:20 [E] 用户登录失败: 账户不存在
+2018/08/19 13:52:27 [E] 用户登录失败: 账户不存在

log/common.log

+2018/08/20 15:27:18 [E] 获取客户列表失败: sql: converting Exec argument $1 type: unsupported type []interface {}, a slice of interface
+2018/08/20 15:36:51 [E] 获取客户列表失败: sql: converting Exec argument $1 type: unsupported type []interface {}, a slice of interface
+2018/08/20 15:37:19 [E] 获取客户列表失败: sql: converting Exec argument $1 type: unsupported type []interface {}, a slice of interface
+2018/08/20 15:44:30 [E] 获取客户列表失败: Error 1248: Every derived table must have its own alias
+2018/08/20 15:46:35 [E] 获取客户列表失败: Error 1248: Every derived table must have its own alias
+2018/08/20 15:49:09 [E] 获取客户列表失败: Error 1060: Duplicate column name 'user_id'
+2018/08/20 15:57:45 [E] 获取客户列表失败: sql: statement expects 2 inputs; got 1
+2018/08/20 19:25:08 [E] 短信发送失败: 400 
+2018/08/20 19:27:58 [E] 短信发送失败: 400 
+2018/08/20 19:28:52 [E] 短信发送失败: 400 
+2018/08/21 13:38:17 [E] 用户没有设置默认案场
+2018/08/21 13:38:17 [E] 您没有该案场的权限！
+2018/08/21 13:39:04 [E] 用户没有设置默认案场
+2018/08/21 13:39:04 [E] 您没有该案场的权限！
+2018/08/21 13:39:09 [E] 用户没有设置默认案场
+2018/08/21 13:39:09 [E] 您没有该案场的权限！
+2018/08/21 13:39:24 [E] 用户没有设置默认案场
+2018/08/21 13:39:24 [E] 您没有该案场的权限！
+2018/08/21 13:41:04 [E] 用户没有设置默认案场
+2018/08/21 13:41:04 [E] 您没有该案场的权限！

models/cases/area.go

 func (m *CaseDAO) GetCaseArea(caseids string, page int, pageSize int) ([]model.SysCaseArea, error) {
 	var areas []model.SysCaseArea
 	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
-	err := dao.Limit(pageSize, page*pageSize).Find(&areas)
+	err := dao.Limit(pageSize, (page-1)*pageSize).Find(&areas)
 	return areas, err
 }
 
 // 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)
+	// err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id =?", caseid).Table("sys_case_area").Find(&areas)
 	return areas, err
 }
 
 	area.AreaId = utils.GetGUID()
 	area.Status = models.STATUS_NORMAL
 	area.CreateDate = time.Now()
-	user := m.ctx.Get("user").(*model.SysUser)
+	user := m.ctx.Get("user").(model.SysUser)
 	area.CreateUser = user.UserId
 	_, err := m.db.Insert(area)
 	return area, err
 		"area_name",
 		"area_icon",
 		"area_icon_white",
+		"order",
 	}
 	_, err := m.db.Cols(cols...).Where("area_id=?", area.AreaId).Update(area)
 	return err

models/cases/cases.go

 
 // CaseInfo 案场
 type CaseInfo struct {
-	model.TaCmsCase `xorm:"extends"`
-	CreateUserName  string
+	model.SysCase  `xorm:"extends"`
+	CreateUserName string
 }
 
 // GetCaseList 获取案场列表
 func (m *CaseDAO) GetCaseList(caseids, casename string, page, pageSize int) ([]CaseInfo, error) {
 	var cases []CaseInfo
-	sql := `select a.*,b.user_name as create_user_name from sys_case a inner join sys_user b on a.create_user = b.user_id
+	sql := `select a.*,b.user_name as create_user_name from sys_case a left join sys_user b on a.create_user = b.user_id
 	 where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')`
 	if casename != "" {
 		sql = sql + ` and  a.case_name like '%` + casename + `%'`
 	}
 
-	sql = sql + " order by create_date desc limit " + strconv.Itoa(page*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
+	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
+
 	err := m.db.Sql(sql).Find(&cases)
 	return cases, err
 }
 
 // AddCase 新增案场信息
 func (m *CaseDAO) AddCase(caseinfo model.SysCase) (*model.SysCase, error) {
+	caseinfo.CaseId = utils.GetGUID()
 	caseinfo.CreateDate = time.Now()
 	caseinfo.Status = models.STATUS_NORMAL
-	user := m.ctx.Get("user").(*model.SysUser)
+	user := m.ctx.Get("user").(model.SysUser)
 	caseinfo.CreateUser = user.UserId
-	_, err := m.db.Insert(&caseinfo)
+	_, err := m.db.Insert(caseinfo)
 	return &caseinfo, err
 }
 

models/cases/caseuser.go

 	caseuser.CreateDate = time.Now()
 	caseuser.Status = models.STATUS_NORMAL
 	caseuser.CaseUserId = utils.GetGUID()
-	_, err := m.db.Insert(&caseuser)
+	_, err := m.db.Insert(caseuser)
 	return &caseuser, err
 }
 

models/cases/equipment.go

 // GetEquipmentList 获取体检设备
 func (m *CaseDAO) GetEquipmentList(caseids string, page, pageSize int) ([]model.SysCaseEquipment, error) {
 	var equipments []model.SysCaseEquipment
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, page*pageSize).Find(&equipments)
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, (page-1)*pageSize).Find(&equipments)
 	return equipments, err
 }
 

models/cases/key.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strconv"
+	"strings"
 	"time"
 )
 
 // GetKeysByCase 根据案场获取钥匙信息
 func (m *CaseDAO) GetKeysByCase(caseid, num string, page, pageSize int) ([]CaseKeyInfo, error) {
 	var keys []CaseKeyInfo
-	dao := m.db.Where("case_id=?", caseid).Table("ta_case_key").And("status>" + strconv.Itoa(models.STATUS_DEL))
+	query := `
+		SELECT
+			t.*, s.customer_id,
+			s.customer_name
+		FROM
+			ta_case_key t
+		LEFT JOIN ta_case_key_use s ON t.key_id = s.key_id AND s.status != ?
+		WHERE
+			t.case_id = ?
+		AND t.status > ?
+	`
+
 	if num != "" {
-		dao.And("lock_num like '%" + num + "%'")
+		query += " AND t.lock_num like '%" + num + "%'"
 	}
-	err := dao.Limit(pageSize, page*pageSize).Find(&keys)
+
+	offset := (page - 1) * pageSize
+	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)
+	_, 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)
 	area.TableId = utils.GetGUID()
 	area.Status = models.STATUS_NORMAL
 	area.CreateDate = time.Now()
-	user := m.ctx.Get("user").(*model.SysUser)
+	user := m.ctx.Get("user").(model.SysUser)
 	area.CreateUser = user.UserId
 	_, err := m.db.Insert(area)
 	return area, err

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.TagId = utils.GetGUID()
 	tag.Status = models.STATUS_NORMAL
 	tag.CreateDate = time.Now()
-	_, err := m.db.Insert(&tag)
+	_, err := m.db.Insert(tag)
 	return &tag, err
 }
 
 
 // DeleteTag 刪除标签
 func (m *CaseDAO) DeleteTag(tagid string) error {
+	beego.Error(tagid)
 	var tag = model.SysTag{
 		TagId:  tagid,
 		Status: models.STATUS_DEL,

models/constant.go

 
 // 状态列表
 const (
-	STATUS_NORMAL = 1
-	STATUS_DEL    = -1
+	// 删除
+	STATUS_DEL = iota - 1
+
+	// 新录入
+	STATUS_READY
+
+	// 正常
+	STATUS_NORMAL
 )
 
 // 映射数据库的布尔型

models/course/course.go

+package course
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+
+	"github.com/go-xorm/xorm"
+)
+
+// CourseDAO 当前数据库操作对象
+type CourseDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewCourseDAO New Inst
+func NewCourseDAO(ctx *utils.Context) *CourseDAO {
+	return &CourseDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+// GetCourseList 获取课程列表
+func (m *CourseDAO) GetCourseList(caseids, name, typeid string, page, pageSize int) ([]model.TaCourse, error) {
+	var courses []model.TaCourse
+
+	m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("")
+
+	return courses, nil
+}

models/course/tag.go

+package course
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"strings"
+)
+
+// GetTagsList 获取标签列表
+func (m *CourseDAO) GetTagsList(orgid string, page, pageSize int) ([]model.TdCourseTag, error) {
+	var tags []model.TdCourseTag
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("org_id=?", orgid).Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&tags)
+	return tags, err
+}
+
+// GetTagsCount 获取标签count
+func (m *CourseDAO) GetTagsCount(orgid string) (int, error) {
+	var tags []model.TdCourseTag
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("org_id=?", orgid).Find(&tags)
+	if err != nil {
+		return 0, nil
+	}
+	if len(tags) > 0 {
+		return len(tags), nil
+	}
+	return 0, nil
+}
+
+// AddCourseTag 新增课程标签
+func (m *CourseDAO) AddCourseTag(tag *model.TdCourseTag) (*model.TdCourseTag, error) {
+	tag.TagId = utils.GetGUID()
+	tag.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(tag)
+	return tag, err
+}
+
+// DelCourseTag 删除课程对应标签
+func (m *CourseDAO) DelCourseTag(courseid string) error {
+	sql := `delete ta_course_tag where course_id='` + courseid + `'`
+	_, err := m.db.Exec(sql)
+	return err
+}
+
+// CourseTagSave 保存课程对应标签
+func (m *CourseDAO) CourseTagSave(courseid, tagids string) error {
+	sql := `insert into ta_course_tag(course_id,tag_id) select '` + courseid + `',tag_id from td_course_tag where tag_id in ('` + strings.Replace(tagids, ",", "','", -1) + `') and status>` + strconv.Itoa(models.STATUS_DEL)
+	_, err := m.db.Exec(sql)
+	return err
+}

models/customer/customer.go

 
 // CustWithWXList 客户列表
 func (m *CustomerDAO) CustWithWXList(phone string, page ...int) ([]CustWithWX, int64, error) {
+	org := m.ctx.Get("org").(model.SysOrg)
+
 	if phone == "" {
 		phone = "%"
 	} else {
 	}
 
 	query := `
-		SELECT *
+		SELECT
+			t.*, s.account_info,
+			s.account_type,
+			s.mapping_id,
+			s.openid,
+			s.user_id as map_user,
+			s.user_type,
+			s.uuid
 		FROM
 			ta_customer t
 		LEFT JOIN ta_user_mapping s ON t.customer_id = s.user_id
 		WHERE
 			t.phone like ?
 		AND t.status > ?
+		AND t.org_id = '` + org.OrgId + `'
 		ORDER BY
 			t.create_date DESC
 	`
 
 	var cust []CustWithWX
 
-	cnt, err := utils.GetPageList(m.db, &cust, []int{pageNum, offset}, query, phone, models.STATUS_DEL)
+	cnt, err := utils.NewPageNaviEngine(m.ctx).GetPageList(&cust, query, []int{pageNum, offset}, phone, models.STATUS_DEL)
 	if err != nil {
 		return nil, 0, err
 	}
 	cust.CreateDate = time.Now().Local()
 	cust.Status = models.STATUS_NORMAL
 
-	_, err := m.db.Insert(&cust)
+	_, err := m.db.Insert(cust)
 	return err
 }

models/customer/types.go

 	model.TaCustomer    `xorm:"extends"`
 	model.TaUserMapping `xorm:"extends"`
 	Points              int
+	MapUser             string
 }

models/goods/goods.go

 package goods
 
 import (
+	"errors"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+	"time"
+
+	"github.com/yl10/kit/guid"
 
 	"github.com/go-xorm/xorm"
 )
 		db:  ctx.DB,
 	}
 }
+
+// GetGoodsListOfCase 获取案场商品列表
+// 暂时没涉及分页
+func (m *GoodsDAO) GetGoodsListOfCase(caseID string) ([]GoodsWithSpec, error) {
+	var goodsList []GoodsWithSpec
+
+	sql := "select * from ta_goods where case_id = ? and status = ? order by t.type_id, t.create_date"
+	if err := m.db.SQL(sql, caseID, models.STATUS_NORMAL).Find(&goodsList); err != nil {
+		return nil, err
+	}
+
+	for inx, goods := range goodsList {
+		sql = `SELECT * FROM td_spec t
+			JOIN ta_goods_spec s ON t.spec_id = s.spec_id
+			WHERE t.status = ? AND s.goods_id = ?
+		`
+
+		var specs []SpecWithPrice
+		if err := m.db.SQL(sql, models.STATUS_DEL, goods.GoodsId).Find(&specs); err != nil {
+			return nil, err
+		}
+
+		goodsList[inx].Specs = specs
+	}
+
+	return goodsList, nil
+}
+
+// GetGoodsByID 依据ID 获取商品
+func (m *GoodsDAO) GetGoodsByID(id, caseID string) (*model.TaGoods, error) {
+	goods := new(model.TaGoods)
+	if _, err := m.db.Where("goods_id=?", id).And("case_id=?", caseID).Get(goods); err != nil {
+		return nil, err
+	}
+
+	return goods, nil
+}
+
+// UpdateGoods 更新商品
+func (m *GoodsDAO) UpdateGoods(goods *model.TaGoods, cols []string) error {
+	if _, err := m.db.Where("goods_id=?", goods.GoodsId).Cols(cols...).Update(goods); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// SaveGoods 保存商品
+func (m *GoodsDAO) SaveGoods(goods *model.TaGoods) error {
+	userRaw := m.ctx.Get("user")
+	if userRaw == nil {
+		return errors.New("登录异常, 请登出重试")
+	}
+	user := userRaw.(model.SysUser)
+
+	goods.GoodsId = guid.NewGUIDString()
+	goods.Status = models.STATUS_NORMAL
+	goods.CreateDate = time.Now().Local()
+	goods.CreateUser = user.UserId
+	goods.OrgId = user.OrgId
+
+	if _, err := m.db.Insert(goods); err != nil {
+		return err
+	}
+
+	return nil
+}

models/goods/orders.go

+package goods
+
+import (
+	"errors"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strings"
+	"time"
+
+	"github.com/yl10/kit/guid"
+)
+
+// SaveOrders 下单
+func (m *GoodsDAO) SaveOrders(order *model.TaGoodsOrders) error {
+	if order.UserId == "" {
+		return errors.New("没有下单人信息")
+	}
+
+	caseID := order.CaseId
+	if caseID == "" {
+		return errors.New("没有指定案场")
+	}
+
+	caseInfo, err := m.getCaseByID(caseID)
+	if err != nil {
+		return err
+	}
+
+	order.OrdersId = guid.NewGUIDString()
+	order.OrgId = caseInfo.OrgId
+	order.CreateDate = time.Now().Local()
+	order.Status = models.STATUS_NORMAL
+
+	// 当前订单号的随机方式 = 时间 + 个人ID
+	order.OrdersNo = time.Now().Local().Format("20060102150405") + "-" + strings.Join(utils.GUIID2IntString(order.UserId), "")
+
+	return nil
+}
+
+func (m *GoodsDAO) getCaseByID(caseID string) (*model.SysCase, error) {
+	cs := new(model.SysCase)
+	if _, err := m.db.Where("case_id=?", caseID).Get(cs); err != nil {
+		return nil, err
+	}
+
+	return cs, nil
+}

models/goods/spec.go

 // GetGoodsSpec 根据案场获取商品规格
 func (m *GoodsDAO) GetGoodsSpec(caseids string, page int, pageSize int) ([]model.TdSpec, error) {
 	var goodsSpec []model.TdSpec
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, page*pageSize).Find(&goodsSpec)
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, (page-1)*pageSize).Find(&goodsSpec)
 	return goodsSpec, err
 }
 

models/goods/type.go

 // GetGoodsType 根据案场获取商品类型
 func (m *GoodsDAO) GetGoodsType(caseids string, page int, pageSize int) ([]model.TdGoodsType, error) {
 	var goodstype []model.TdGoodsType
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("case_id in ('"+strings.Replace(caseids, ",", "','", -1)+"')").Limit(pageSize, page*pageSize).Desc("create_date").Find(&goodstype)
+	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(&goodstype)
 	return goodstype, err
 }
 
 	goodsType.TypeId = utils.GetGUID()
 	goodsType.CreateDate = time.Now()
 	goodsType.Status = models.STATUS_NORMAL
-	user := m.ctx.Get("user").(*model.SysUser)
+	user := m.ctx.Get("user").(model.SysUser)
 	goodsType.CreateUser = user.UserId
-	_, err := m.db.Insert(&goodsType)
+	_, err := m.db.Insert(goodsType)
 	return goodsType, err
 }
 

models/goods/types.go

+package goods
+
+import (
+	"spaceofcheng/services/models/model"
+)
+
+// SpecWithPrice 规格价格
+type SpecWithPrice struct {
+	model.TdSpec
+	GoodsPrice float32 `xorm:"FLOAT(8,2)"`
+}
+
+// GoodsWithSpec 含规格商品
+type GoodsWithSpec struct {
+	model.TaGoods
+	Specs []SpecWithPrice
+}

models/message/cmscase.go

 	"strings"
 	"time"
 
+	"github.com/astaxie/beego"
+
 	"github.com/go-xorm/builder"
 )
 
 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*pageSize) + `, ` + strconv.Itoa((page+1)*pageSize)
-
+	order by create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa((page+1)*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)
+	// err := m.db.Table("ta_cms_case").Where("cms_case_id=?", cmscaseid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&cases)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if len(cases) > 0 {
 
 // SaveCmsCaseImg 保存项目专题对应的图片
 func (m *MessageDAO) SaveCmsCaseImg(img model.TaCmsCaseImage) error {
+	img.CmsCaseImageId = utils.GetGUID()
 	img.Status = models.STATUS_NORMAL
-	_, err := m.db.Insert(&img)
+	_, err := m.db.Insert(img)
 	return err
 }

models/message/image.go

 // GetImgList 获取轮播图列表
 func (m *MessageDAO) GetImgList(orgid string, page int, pageSize int) ([]model.TaCmsImages, error) {
 	var imgs []model.TaCmsImages
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("org_id=?", orgid).Limit(pageSize, page*pageSize).Desc("create_date").Find(&imgs)
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("org_id=?", orgid).Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&imgs)
 	return imgs, err
 }
 
 // AddCmsImg 保存轮播图
 func (m *MessageDAO) AddCmsImg(info model.TaCmsImages) (*model.TaCmsImages, error) {
 	info.ImageId = utils.GetGUID()
-	info.Status = models.STATUS_NORMAL
+	// info.Status = models.STATUS_NORMAL
 	info.CreateDate = time.Now()
 	user := m.ctx.Get("user").(model.SysUser)
 	info.CreateUser = user.UserId
-	_, err := m.db.Insert(&info)
+	_, err := m.db.Insert(info)
 	return &info, err
 }
 
 	var cols = []string{
 		"image_url",
 		"forward_type",
-		"foward_url",
-		"foward_resource_id",
+		"forward_url",
+		"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

 	location.LocationId = utils.GetGUID()
 	location.Status = models.STATUS_NORMAL
 	location.IsSys = ISSYS
-	_, err := m.db.Insert(&location)
+	_, err := m.db.Insert(location)
 	return &location, err
 }
 

models/message/message.go

 		dao.And("info_name like '%" + title + "%'")
 	}
 
-	err := dao.Limit(pageSize, page*pageSize).Desc("create_date").Find(&cmsinfos)
+	err := dao.Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&cmsinfos)
 	return cmsinfos, err
 }
 
 	cmsinfo.CreateDate = time.Now()
 	user := m.ctx.Get("user").(model.SysUser)
 	cmsinfo.CreateUser = user.UserId
-	_, err := m.db.Insert(&cmsinfo)
+	_, err := m.db.Insert(cmsinfo)
 	return &cmsinfo, err
 }
 
 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
+		` and a.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 + `'`
 
 	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*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
-
+	sql = sql + " order by new.create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
 	err := m.db.Sql(sql).Find(&news)
 	return news, err
 }
 func (m *MessageDAO) AddNews(news model.TaCmsNews) (*model.TaCmsNews, error) {
 	news.NewsId = utils.GetGUID()
 	news.CreateDate = time.Now()
-	user := m.ctx.Get("user").(*model.SysUser)
+	user := m.ctx.Get("user").(model.SysUser)
 	news.CreateUser = user.UserId
-	_, err := m.db.Insert(&news)
+	_, err := m.db.Insert(news)
 	return &news, err
 }
 

models/model/sys_case_area.go

 	Status        int       `xorm:"SMALLINT(6)"`
 	CreateDate    time.Time `xorm:"DATETIME"`
 	CreateUser    string    `xorm:"VARCHAR(64)"`
+	Order         int       `xorm:"INT(11)"`
 }

models/model/sys_case_user.go

 )
 
 type SysCaseUser struct {
-	CaseUserId string `xorm:"not null pk VARCHAR(64)"`
-	OrgId      string `xorm:"VARCHAR(64)"`
-	CaseId     string `xorm:"VARCHAR(64)"`
-	UserName   string `xorm:"VARCHAR(50)"`
-	Tel        string `xorm:"VARCHAR(50)"`
-	UserType   string `xorm:"comment('案场管理员
-            咖啡师
-            消息收发员') VARCHAR(20)"`
+	CaseUserId string    `xorm:"not null pk VARCHAR(64)"`
+	OrgId      string    `xorm:"VARCHAR(64)"`
+	CaseId     string    `xorm:"VARCHAR(64)"`
+	UserName   string    `xorm:"VARCHAR(50)"`
+	Tel        string    `xorm:"VARCHAR(50)"`
+	UserType   string    `xorm:"comment('案场管理员 咖啡师 消息收发员') VARCHAR(20)"`
 	Status     int       `xorm:"SMALLINT(6)"`
 	CreateDate time.Time `xorm:"DATETIME"`
 }

models/model/sys_user_case.go

 
 type SysUserCase struct {
 	UserId     string    `xorm:"not null pk VARCHAR(64)"`
-	CaseId     string    `xorm:"VARCHAR(64)"`
+	CaseId     string    `xorm:"not null pk VARCHAR(64)"`
 	CaseName   string    `xorm:"VARCHAR(100)"`
+	IsCreated  int       `xorm:"TINYINT(1)"`
 	IsBelong   int       `xorm:"TINYINT(1)"`
 	Status     int       `xorm:"SMALLINT(6)"`
 	CreateDate time.Time `xorm:"DATETIME"`

models/model/sys_wechat_conf.go

 type SysWechatConf struct {
 	ConfId string `xorm:"VARCHAR(64)"`
 	OrgId  string `xorm:"VARCHAR(64)"`
-	Type   int    `xorm:"comment('wechat 微信公众号
-            mini 小程序') SMALLINT(6)"`
+	Type   int    `xorm:"comment('wechat 微信公众号 mini 小程序') SMALLINT(6)"`
 	Appid  string `xorm:"VARCHAR(50)"`
 	Secret string `xorm:"VARCHAR(50)"`
 	Token  string `xorm:"VARCHAR(50)"`

models/model/ta_account_change.go

 )
 
 type TaAccountChange struct {
-	DetailId   string `xorm:"not null pk VARCHAR(64)"`
-	AccountId  string `xorm:"VARCHAR(64)"`
-	UserId     string `xorm:"VARCHAR(64)"`
-	UserName   string `xorm:"VARCHAR(50)"`
-	OrgId      string `xorm:"VARCHAR(64)"`
-	CaseId     string `xorm:"VARCHAR(64)"`
-	ChangeType string `xorm:"comment('integral 积分
-            amount 城币') VARCHAR(20)"`
-	ChangeSource string `xorm:"comment('vip vip卡充值
-            orders 订单消费
-            register 注册
-            perfect 完善资料
-            recommend 推荐') VARCHAR(20)"`
-	SourceId   string  `xorm:"VARCHAR(64)"`
-	SourceName string  `xorm:"VARCHAR(255)"`
-	Amount     float32 `xorm:"FLOAT(8,2)"`
-	FloatType  string  `xorm:"comment('+
-            -') VARCHAR(5)"`
-	CreateDate time.Time `xorm:"DATETIME"`
-	CreateUser string    `xorm:"VARCHAR(64)"`
-	Status     int       `xorm:"SMALLINT(6)"`
+	DetailId     string    `xorm:"not null pk VARCHAR(64)"`
+	AccountId    string    `xorm:"VARCHAR(64)"`
+	UserId       string    `xorm:"VARCHAR(64)"`
+	UserName     string    `xorm:"VARCHAR(50)"`
+	OrgId        string    `xorm:"VARCHAR(64)"`
+	CaseId       string    `xorm:"VARCHAR(64)"`
+	ChangeType   string    `xorm:"comment('integral 积分 amount 城币') VARCHAR(20)"`
+	ChangeSource string    `xorm:"comment('vip vip卡充值 orders 订单消费 register 注册 perfect 完善资料 recommend 推荐') VARCHAR(20)"`
+	SourceId     string    `xorm:"VARCHAR(64)"`
+	SourceName   string    `xorm:"VARCHAR(255)"`
+	Amount       float32   `xorm:"FLOAT(8,2)"`
+	FloatType    string    `xorm:"comment('+ -') VARCHAR(5)"`
+	CreateDate   time.Time `xorm:"DATETIME"`
+	CreateUser   string    `xorm:"VARCHAR(64)"`
+	Status       int       `xorm:"SMALLINT(6)"`
 }

models/model/ta_channel.go

 package model
 
-import "time"
+import (
+	"time"
+)
 
 type TaChannel struct {
 	ChannelId   string    `xorm:"not null pk VARCHAR(64)"`

models/model/ta_cms_case_image.go

 	CmsCaseId      string `xorm:"VARCHAR(64)"`
 	CaseImageUrl   string `xorm:"TEXT"`
 	Status         int    `xorm:"SMALLINT(6)"`
-	ImageType      string `xorm:"comment('cover：封面
-            detail：详情') VARCHAR(32)"`
-	Sort int `xorm:"INT(11)"`
+	ImageType      string `xorm:"comment('cover：封面 detail：详情') VARCHAR(32)"`
+	Sort           int    `xorm:"INT(11)"`
 }

models/model/ta_cms_images.go

 )
 
 type TaCmsImages struct {
-	ImageId          string    `xorm:"not null pk VARCHAR(64)"`
-	LocationId       string    `xorm:"VARCHAR(64)"`
-	ImageUrl         string    `xorm:"VARCHAR(128)"`
-	ForwardType      string    `xorm:"comment('url：转跳链接，course：转跳课程') CHAR(32)"`
-	FowardUrl        string    `xorm:"VARCHAR(255)"`
-	FowardResourceId string    `xorm:"VARCHAR(64)"`
-	Status           int       `xorm:"comment('是否发布 0是1否') SMALLINT(6)"`
-	Sort             int       `xorm:"INT(11)"`
-	CaseId           string    `xorm:"VARCHAR(64)"`
-	OrgId            string    `xorm:"VARCHAR(64)"`
-	CreateUser       string    `xorm:"VARCHAR(64)"`
-	CreateDate       time.Time `xorm:"DATETIME"`
+	ImageId           string    `xorm:"not null pk VARCHAR(64)"`
+	LocationId        string    `xorm:"VARCHAR(64)"`
+	ImageUrl          string    `xorm:"VARCHAR(128)"`
+	ForwardType       string    `xorm:"comment('url：转跳链接，course：转跳课程') CHAR(32)"`
+	ForwardUrl        string    `xorm:"VARCHAR(255)"`
+	ForwardResourceId string    `xorm:"VARCHAR(64)"`
+	Status            int       `xorm:"comment('是否发布 0是1否') SMALLINT(6)"`
+	Sort              int       `xorm:"INT(11)"`
+	CaseId            string    `xorm:"VARCHAR(64)"`
+	OrgId             string    `xorm:"VARCHAR(64)"`
+	CreateUser        string    `xorm:"VARCHAR(64)"`
+	CreateDate        time.Time `xorm:"DATETIME"`
+	Title             string    `xorm:"VARCHAR(50)"`
 }

models/model/ta_course_orders.go

 	JoinNum      int       `xorm:"INT(11)"`
 	CreateDate   time.Time `xorm:"DATETIME"`
 	Status       int       `xorm:"SMALLINT(6)"`
-	PayType      int       `xorm:"SMALLINT(6)"`
+	PayType      string    `xorm:"VARCHAR(20)"`
 	Address      string    `xorm:"VARCHAR(200)"`
 	CourseDate   string    `xorm:"VARCHAR(200)"`
 	Remark       string    `xorm:"TEXT"`

models/model/ta_customer.go

 	RecommendName string    `xorm:"VARCHAR(50)"`
 	CreateDate    time.Time `xorm:"DATETIME"`
 	Status        int       `xorm:"SMALLINT(6)"`
+	UserId        string    `xorm:"VARCHAR(64)"`
 }

models/model/ta_experience_card.go

-package model
-
-import (
-	"time"
-)
-
-type TaExperienceCard struct {
-	CardId     string    `xorm:"not null pk VARCHAR(64)"`
-	CardTypeId string    `xorm:"VARCHAR(64)"`
-	SendType   string    `xorm:"comment('0案场 1渠道') VARCHAR(32)"`
-	VideoUrl   string    `xorm:"TEXT"`
-	CoverUrl   string    `xorm:"TEXT"`
-	Price      float32   `xorm:"FLOAT(64)"`
-	StartDate  time.Time `xorm:"DATETIME"`
-	EndDate    time.Time `xorm:"DATETIME"`
-	TotalCount int       `xorm:"INT(11)"`
-	SentCount  int       `xorm:"INT(11)"`
-	UsedCount  int       `xorm:"INT(11)"`
-	Status     string    `xorm:"comment('private未发布 public发布 over过期') VARCHAR(32)"`
-	CaseId     string    `xorm:"VARCHAR(64)"`
-	OrgId      string    `xorm:"VARCHAR(64)"`
-	CreateDate time.Time `xorm:"DATETIME"`
-	CreateUser string    `xorm:"VARCHAR(64)"`
-	IsOver     int       `xorm:"TINYINT(1)"`
-}

models/model/ta_goods_orders.go

 	AreaId     string    `xorm:"VARCHAR(64)"`
 	AreaName   string    `xorm:"VARCHAR(50)"`
 	TableId    string    `xorm:"VARCHAR(64)"`
-	TableName  string    `xorm:"VARCHAR(50)"`
+	TableNo    string    `xorm:"VARCHAR(50)"`
 	Amount     string    `xorm:"DECIMAL(8,2)"`
 	CreateDate time.Time `xorm:"DATETIME"`
 	Status     int       `xorm:"SMALLINT(6)"`
-	PayType    int       `xorm:"comment('vip VIP卡城币抵用
-            coupon 优惠券抵用') SMALLINT(6)"`
-	UserType     int    `xorm:"SMALLINT(6)"`
+	PayType    string    `xorm:"comment('vip VIP卡城币抵用
+            coupon 优惠券抵用') VARCHAR(20)"`
+	UserType     string `xorm:"VARCHAR(20)"`
 	UserId       string `xorm:"VARCHAR(64)"`
 	UserName     string `xorm:"VARCHAR(50)"`
 	OrdersNum    int    `xorm:"INT(11)"`

models/model/ta_user_mapping.go

 package model
 
 type TaUserMapping struct {
-	MappingId string `xorm:"not null pk VARCHAR(64)"`
-	UserId    string `xorm:"VARCHAR(64)"`
-	UserType  string `xorm:"comment('customer 为会员
-            user 为后台用户') VARCHAR(50)"`
-	AccountType string `xorm:"comment('wechat 微信公众号
-            mini 小程序') VARCHAR(50)"`
+	MappingId   string `xorm:"not null pk VARCHAR(64)"`
+	UserId      string `xorm:"VARCHAR(64)"`
+	UserType    string `xorm:"comment('customer 为会员 user 为后台用户') VARCHAR(50)"`
+	AccountType string `xorm:"comment('wechat 微信公众号 mini 小程序') VARCHAR(50)"`
 	Openid      string `xorm:"VARCHAR(200)"`
 	Uuid        string `xorm:"VARCHAR(200)"`
 	AccountInfo string `xorm:"TEXT"`

models/sys.go

 		Update(&user)
 	return err
 }
+
+// GetCaseByContext 获取案场
+func GetCaseByContext(ctx *utils.Context) (string, error) {
+	csRaw := ctx.Get("currentCase")
+	if csRaw == nil {
+		return "", errors.New("当前人员无案场权限")
+	}
+
+	cs := csRaw.(model.SysUserCase)
+	if cs.CaseId == "" || cs.Status == STATUS_DEL {
+		return "", errors.New("当前人员无案场权限")
+	}
+
+	return cs.CaseId, nil
+}

models/system/role.go

 // GetRoleList 根据案场获取角色
 func (m *RoleDAO) GetRoleList(caseids 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*pageSize).Desc("create_date").Find(&roles)
+	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)
 	return roles, err
 }
 
 }
 
 // AddRole 新增角色
-func (m *RoleDAO) AddRole(Role model.SysRole) (*model.SysRole, error) {
-	Role.RoleId = utils.GetGUID()
-	Role.Status = models.STATUS_NORMAL
-	Role.CreateDate = time.Now()
-	_, err := m.db.Insert(&Role)
-	return &Role, err
+func (m *RoleDAO) AddRole(role model.SysRole) (*model.SysRole, error) {
+	role.RoleId = utils.GetGUID()
+	role.Status = models.STATUS_NORMAL
+	role.CreateDate = time.Now()
+	_, err := m.db.Insert(role)
+	return &role, err
 }
 
 // UpdateRole 修改角色

models/system/user.go

 		sql = sql + " and 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*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
+	sql = sql + " order by create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa((page+1)*pageSize)
 
 	err := m.db.Sql(sql).Find(&users)
 	return users, err
 	// 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*pageSize).Desc("create_date").Find(&users)
+	// err := userDAO.Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&users)
 	// return users, err
 }
 
 	return err
 }
 
+// DelUserCase 删除用户的案场信息
+func (m *UserDAO) DelUserCase(userid string) error {
+	sql := "delete from sys_user_case where is_belong=0 and is_created=0 and user_id='" + userid + "'"
+	_, err := m.db.Exec(sql)
+	return err
+}
+
 // SaveUserCase 保存用户对应案场信息
 func (m *UserDAO) SaveUserCase(usercase model.SysUserCase) error {
 	usercase.CreateDate = time.Now()
 	usercase.Status = models.STATUS_NORMAL
-	_, err := m.db.Insert(&usercase)
+	_, err := m.db.Insert(usercase)
 	return err
 }
 
 // SaveUserMapping 保存用户映射信息
 func (m *UserDAO) SaveUserMapping(usermapping *model.TaUserMapping) error {
 	usermapping.MappingId = utils.GetGUID()
-	_, err := m.db.Insert(&usermapping)
+	_, err := m.db.Insert(usermapping)
 	return err
 }
 
 // GetUserCustomer 获取我的推荐客户
 func (m *UserDAO) GetUserCustomer(userid string, page int, pageSize int) ([]model.TaCustomer, error) {
 	var customers []model.TaCustomer
-	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("recommend_id=?", userid).Limit(pageSize, page*pageSize).Desc("create_date").Find(&customers)
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("recommend_id=?", userid).Limit(pageSize, (page-1)*pageSize).Desc("create_date").Find(&customers)
 	return customers, err
 }
 

routers/common.go

 	"spaceofcheng/services/controllers"
 	"spaceofcheng/services/controllers/cases"
 	"spaceofcheng/services/controllers/channel"
+	"spaceofcheng/services/controllers/course"
 	"spaceofcheng/services/controllers/customer"
 	"spaceofcheng/services/controllers/goods"
 	"spaceofcheng/services/controllers/message"
 		beego.NSRouter("/cms/case/:cmscaseid", &message.MessageController{}, "put:SaveCmsCase"),
 		beego.NSRouter("/cms/case/:cmscaseid", &message.MessageController{}, "delete:DelCmsCase"),
 
-		beego.NSRouter("/caseuser", &cases.CaseController{}, "get:GetCaseUserByCase"),
-		beego.NSRouter("/caseuserbytype", &cases.CaseController{}, "get:GetCaseUserByType"),
-		beego.NSRouter("/caseuser/:userid", &cases.CaseController{}, "get:GetCaseUserByID"),
-		beego.NSRouter("/caseuser", &cases.CaseController{}, "post:SaveCaseUser"),
-		beego.NSRouter("/caseuser", &cases.CaseController{}, "put:SaveCaseUser"),
-		beego.NSRouter("/caseuser/:userid", &cases.CaseController{}, "delete:DelCaseUser"),
+		// 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/userbytype", &cases.CaseController{}, "get:GetCaseUserByType"),
+		beego.NSRouter("/case/user/:userid", &cases.CaseController{}, "get:GetCaseUserByID"),
+		beego.NSRouter("/case/user", &cases.CaseController{}, "post:SaveCaseUser"),
+		beego.NSRouter("/case/user", &cases.CaseController{}, "put:SaveCaseUser"),
+		beego.NSRouter("/case/user/:userid", &cases.CaseController{}, "delete:DelCaseUser"),
+
+		// equipment 体检设备
+		beego.NSRouter("/case/equipment", &cases.CaseController{}, "get:GetEquipmentList"),
+		beego.NSRouter("/case/equipment/:id", &cases.CaseController{}, "get:GetEquipmentByID"),
+		beego.NSRouter("/case/equipment", &cases.CaseController{}, "post:SaveCaseEquipment"),
+		beego.NSRouter("/case/equipment", &cases.CaseController{}, "put:SaveCaseEquipment"),
+		beego.NSRouter("/case/equipment/:id", &cases.CaseController{}, "delete:DelCaseEquipment"),
+
+		// case 案场
+		beego.NSRouter("/case/info", &cases.CaseController{}, "get:GetCaseList"),
+		beego.NSRouter("/case/info/:id", &cases.CaseController{}, "get:GetCaseByID"),
+		beego.NSRouter("/case/info", &cases.CaseController{}, "post:SaveCase"),
+		beego.NSRouter("/case/info", &cases.CaseController{}, "put:SaveCase"),
+		beego.NSRouter("/case/info/:id", &cases.CaseController{}, "delete:DelCase"),
+
+		// casekey 案场钥匙
+		beego.NSRouter("/case/key", &cases.CaseController{}, "get:GetKeyList"),
+		beego.NSRouter("/case/key", &cases.CaseController{}, "post:AddKeys"),
+		beego.NSRouter("/case/unlock/:keyid", &cases.CaseController{}, "put:UnLockKey"),
+		beego.NSRouter("/case/key/:id", &cases.CaseController{}, "delete:DelKey"),
+
+		// casearea 案场区域
+		beego.NSRouter("/case/area", &cases.CaseController{}, "get:GetCaseArea"),
+		beego.NSRouter("/case/area/:areaid", &cases.CaseController{}, "get:GetCaseAreaByID"),
+		beego.NSRouter("/case/area", &cases.CaseController{}, "post:SaveCaseArea"),
+		beego.NSRouter("/case/area", &cases.CaseController{}, "put:SaveCaseArea"),
+		beego.NSRouter("/case/area/:areaid", &cases.CaseController{}, "delete:DelCaseArea"),
+
+		// casetable 案场桌位
+		beego.NSRouter("/case/table", &cases.CaseController{}, "get:GetCaseTable"),
+		beego.NSRouter("/case/table/:tableid", &cases.CaseController{}, "get:GetCaseTableByID"),
+		beego.NSRouter("/case/table", &cases.CaseController{}, "post:SaveCaseTable"),
+		beego.NSRouter("/case/table", &cases.CaseController{}, "put:SaveCaseTable"),
+		beego.NSRouter("/case/table/:tableid", &cases.CaseController{}, "delete:DelCaseTable"),
 
-		beego.NSRouter("/equipment", &cases.CaseController{}, "get:GetEquipmentList"),
-		beego.NSRouter("/equipment/:id", &cases.CaseController{}, "get:GetEquipmentByID"),
-		beego.NSRouter("/equipment", &cases.CaseController{}, "post:SaveCaseEquipment"),
-		beego.NSRouter("/equipment", &cases.CaseController{}, "put:SaveCaseEquipment"),
-		beego.NSRouter("/equipment/:id", &cases.CaseController{}, "delete:DelCaseEquipment"),
-
-		// 渠道
 		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"),
 
-		beego.NSRouter("/case", &cases.CaseController{}, "get:GetCaseList"),
-		beego.NSRouter("/case/:id", &cases.CaseController{}, "get:GetCaseByID"),
-		beego.NSRouter("/case", &cases.CaseController{}, "post:SaveCase"),
-		beego.NSRouter("/case", &cases.CaseController{}, "put:SaveCase"),
-		beego.NSRouter("/case/:id", &cases.CaseController{}, "delete:DelCase"),
-
-		beego.NSRouter("/key", &cases.CaseController{}, "get:GetKeyList"),
-		beego.NSRouter("/key", &cases.CaseController{}, "post:AddKeys"),
-		beego.NSRouter("/unlock/:keyid", &cases.CaseController{}, "put:UnLockKey"),
-		beego.NSRouter("/key/:id", &cases.CaseController{}, "delete:DelKey"),
-
-		beego.NSRouter("/area", &cases.CaseController{}, "get:GetCaseArea"),
-		beego.NSRouter("/area/:areaid", &cases.CaseController{}, "get:GetCaseAreaByID"),
-		beego.NSRouter("/area", &cases.CaseController{}, "post:SaveCaseArea"),
-		beego.NSRouter("/area", &cases.CaseController{}, "put:SaveCaseArea"),
-		beego.NSRouter("/area/:areaid", &cases.CaseController{}, "delete:DelCaseArea"),
-
-		beego.NSRouter("/table", &cases.CaseController{}, "get:GetCaseTable"),
-		beego.NSRouter("/table/:tableid", &cases.CaseController{}, "get:GetCaseTableByID"),
-		beego.NSRouter("/table", &cases.CaseController{}, "post:SaveCaseTable"),
-		beego.NSRouter("/table", &cases.CaseController{}, "put:SaveCaseTable"),
-		beego.NSRouter("/table/:tableid", &cases.CaseController{}, "delete:DelCaseTable"),
-
+		// role 角色
 		beego.NSRouter("/role", &system.RoleController{}, "get:GetRoleList"),
 		beego.NSRouter("/role/:roleid", &system.RoleController{}, "get:GetRoleByID"),
 		beego.NSRouter("/role", &system.RoleController{}, "post:SaveCaseRole"),
 		beego.NSRouter("/role", &system.RoleController{}, "put:SaveCaseRole"),
 		beego.NSRouter("/role/:roleid", &system.RoleController{}, "delete:DelCaseRole"),
 
+		// course 课程
+		beego.NSRouter("/course/taglist", &course.CourseController{}, "get:GetCourseTagsByPage"),
+		beego.NSRouter("/course/tag", &course.CourseController{}, "get:GetCourseTags"),
+
 		// 文件
 		beego.NSRouter("/file", &controllers.BaseController{}, "post:FileUpload"),
 
 		beego.NSRouter("/customer", &customer.CustomerController{}, "get:CustWXList"),
 
 		// 系统相关
-		beego.NSRouter("/system/env", &user.UserController{}, "get:GetEnvVars"),
+		beego.NSRouter("/system/init", &user.UserController{}, "get:GetEnvVars"),
 	)
 }

routers/guest.go

 		beego.NSRouter("/cms/news", &message.MessageController{}, "get:GetNewsByLocation"),
 
 		// 案场
-		beego.NSRouter("/case/area", &cases.CaseController{}, "get:GetAreaByCase"),
+		beego.NSRouter("/casearea", &cases.CaseController{}, "get:GetAreaByCase"),
 
 		// 验证码 获取, 校验
 		beego.NSRouter("/captcha", &controllers.BaseController{}, "get:SendCaptcha"),

routers/wechat.go

 		beego.NSRouter("/signout", &user.UserController{}, "post:SignOut"),
 
 		// cms 位置
-		beego.NSRouter("/cms/location", &message.MessageController{}, "get:GetLocations"),
-		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "get:GetLocationById"),
-		beego.NSRouter("/cms/location", &message.MessageController{}, "post:SaveLocation"),
-		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "put:SaveLocation"),
-		beego.NSRouter("/cms/location/:locationid", &message.MessageController{}, "delete:DelLocation"),
+		beego.NSRouter("/cms/area", &message.MessageController{}, "get:GetLocations"),
+		beego.NSRouter("/cms/area/:locationid", &message.MessageController{}, "get:GetLocationById"),
+		beego.NSRouter("/cms/area", &message.MessageController{}, "post:SaveLocation"),
+		beego.NSRouter("/cms/area/:locationid", &message.MessageController{}, "put:SaveLocation"),
+		beego.NSRouter("/cms/area/:locationid", &message.MessageController{}, "delete:DelLocation"),
 
 		// cms
 		beego.NSRouter("/cms/info", &message.MessageController{}, "get:GetCmsInfoList"),

service/cases/area.go

 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCaseArea 获取案场区域
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	areas, err := s.dao.GetCaseArea(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseAreaCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 // 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 {
 func (s *CaseServ) GetAreaByCase(caseid string) ([]cases.AreaInfo, error) {
 	areas, err := s.dao.GetCaseAreaByCase(caseid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	for index, area := range areas {
 		tables, err := s.dao.GetCaseTableByAreaID(area.AreaId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		areas[index].Tables = tables

service/cases/cases.go

 import (
 	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // CaseServ 系统处理
 type CaseServ struct {
-	ctx *utils.Context
-	dao *cases.CaseDAO
+	ctx     *utils.Context
+	dao     *cases.CaseDAO
+	userdao *system.UserDAO
 }
 
 // NewCaseServ 初始化
 func NewCaseServ(ctx *utils.Context) *CaseServ {
 	return &CaseServ{
-		ctx: ctx,
-		dao: cases.NewCaseDAO(ctx),
+		ctx:     ctx,
+		dao:     cases.NewCaseDAO(ctx),
+		userdao: system.NewUserDAO(ctx),
 	}
 }
 
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	cases, err := s.dao.GetCaseList(caseids, casename, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseCount(caseids, casename)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 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 {
+			return nil, err
+		}
+		// 新增之后保存用户对应案场
+		var userCase = model.SysUserCase{
+			CaseId:    newInfo.CaseId,
+			UserId:    newInfo.CreateUser,
+			CaseName:  newInfo.CaseName,
+			IsBelong:  0,
+			IsCreated: 1,
+		}
+		err = s.userdao.SaveUserCase(userCase)
 	} else {
 		err = s.dao.UpdateCase(caseinfo)
 		newInfo = &caseinfo

service/cases/caseuser.go

 package cases
 
-import "spaceofcheng/services/models/model"
+import (
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+)
 
 // GetCaseUserByCase 根据案场id获取案场相关人员信息
 func (s *CaseServ) GetCaseUserByCase(caseid string) ([]model.SysCaseUser, error) {
 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"
 )
 
 // GetCaseEquipment 获取体检设备
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	specs, err := s.dao.GetEquipmentList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetEquipmentCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 // 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"
 )
 
 // GetKeysByCase 根据案场获取钥匙信息
 			isdict = true
 		}
 	}
+
 	if !isdict {
 		return nil, utils.LogError("您没有该案场的权限！")
 	}
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+
 	keys, err := s.dao.GetKeysByCase(caseid, num, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		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
 	}
 
 	for index, key := range keys {
 		use, err := s.dao.GetCurrentKey(key.KeyId)
 		if err != nil {
+			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"
 )
 
 // GetCaseTable 获取案场桌位
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	areas, err := s.dao.GetCaseTable(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCaseTableCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 // 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"
 )
 
 // GetTagList 获取tag列表
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	tags, err := s.dao.GetTagList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetTagCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CaseServ) GetTagByID(tagid string) (*cases.Tag, error) {
 	tag, err := s.dao.GetTagByID(tagid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if tag != nil {
 		tagcases, err := s.dao.GetTagCaseByTagID(tagid)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		tag.TagCases = tagcases
 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 {
 		newInfo = &tag
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelTagCase(newInfo.TagId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveTagCase(newInfo.TagId, caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/course/course.go

+package course
+
+import (
+	"spaceofcheng/services/models/course"
+	"spaceofcheng/services/utils"
+)
+
+// CourseServ 系统处理
+type CourseServ struct {
+	ctx *utils.Context
+	dao *course.CourseDAO
+}
+
+// NewCourseServ 初始化
+func NewCourseServ(ctx *utils.Context) *CourseServ {
+	return &CourseServ{
+		ctx: ctx,
+		dao: course.NewCourseDAO(ctx),
+	}
+}

service/course/tag.go

+package course
+
+import (
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
+)
+
+// GetTagsList 获取标签列表
+func (s *CourseServ) GetTagsList(orgid string, page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	if page == 0 {
+		page = 1
+	}
+	tags, err := s.dao.GetTagsList(orgid, page, pageSize)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	total, err := s.dao.GetTagsCount(orgid)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+
+	return map[string]interface{}{
+		"list":     tags,
+		"pagesize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, err
+}
+
+// GetCourseTags 获取课程标签
+func (s *CourseServ) GetCourseTags(orgid string) ([]model.TdCourseTag, error) {
+	tags, err := s.dao.GetTagsList(orgid, 0, 10000)
+	return tags, err
+}

service/customer/customer.go

 	"spaceofcheng/services/service/events"
 	"spaceofcheng/services/utils"
 	"strconv"
+
+	"github.com/astaxie/beego"
 )
 
 // CustomerServ 系统处理
 func (s *CustomerServ) GetCustWithWXByID(custID string) (*customer.CustWithWX, error) {
 	cust, err := s.dao.GetCustWithWXByID(custID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CustomerServ) GetCustUserByID(userID string) (*UserProfile, error) {
 	user, err := s.dao.GetUserByID(userID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *CustomerServ) BindWechatUser(userMap *model.TaUserMapping, phone string) (*model.TaCustomer, error) {
 	user, err := s.dao.GetUserByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 
 	cust, err := s.dao.GetCustomerByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
 		newCust, err := s.SaveNewCustomer(wxInfo, "", "", user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		cust = newCust
 func (s *CustomerServ) BindWechatCust(userMap *model.TaUserMapping, phone, caseID, userID string) (*model.TaCustomer, error) {
 	cust, err := s.dao.GetCustomerByPhone(phone)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
 		newCust, err := s.SaveNewCustomer(wxInfo, caseID, userID, "")
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if caseID != "" {
 		cs, err := s.casedao.GetCaseByID(caseID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if arID != "" {
 		ar, err := s.dao.GetUserByID(arID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 	if userID != "" {
 		user, err := s.dao.GetUserByID(userID)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 
 
 	if err := s.dao.SaveCustomer(&cust); err != nil {
 		utils.LogError("更新客户信息失败: " + err.Error())
+		beego.Error(err)
 		return nil, errors.New("更新客户信息失败")
 	}
 

service/goods/spec.go

 package goods
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetGoodsSpec 获取商品规格
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	specs, err := s.dao.GetGoodsSpec(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetGoodsSpecCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 
 // SaveGoodsSpec 保存商品类型
 func (s *GoodsServ) SaveGoodsSpec(goodsSpec model.TdSpec) (*model.TdSpec, error) {
+	if goodsSpec.SpecName == "" {
+		return nil, errors.New("规格名称不能为空！")
+	}
+
+	if goodsSpec.CaseId == "" {
+		return nil, errors.New("案场不能为空！")
+	}
 	var err error
 	if goodsSpec.SpecId == "" {
 		_, err = s.dao.AddGoodsSpec(&goodsSpec)

service/goods/type.go

 package goods
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetGoodsType 获取商品类型
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	types, err := s.dao.GetGoodsType(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetGoodsTypeCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 
 // SaveGoodsType 保存商品类型
 func (s *GoodsServ) SaveGoodsType(goodsType model.TdGoodsType) (*model.TdGoodsType, error) {
+	if goodsType.TypeName == "" {
+		return nil, errors.New("类型名称不能为空！")
+	}
+
+	if goodsType.CaseId == "" {
+		return nil, errors.New("案场不能为空！")
+	}
+
 	var err error
 	if goodsType.TypeId == "" {
 		_, err = s.dao.AddGoodsType(&goodsType)

service/message/cmscase.go

 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
 	"strings"
+
+	"github.com/astaxie/beego"
 )
 
 // GetCmsCasesList 获取项目列表
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	infos, err := s.dao.GetCmsCaseList(name, orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCmsCaseListCount(name, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	var err error
 	info, err = s.dao.GetCmsCaseByID(cmscaseid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	var course []model.TaCourse
 		course, err = s.dao.GetCoursesByCmsCase(info.CmsCaseId)
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.Courses = course
 
 	imgs, err := s.dao.GetCmsCaseImgs(info.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.CmsCaseImgs = imgs
 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 {
 		newInfo = &cmscase
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelCmsCaseCourse(newInfo.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if newInfo.IsAllCourse == 0 {
 		err = s.dao.SaveCmsCaseCourse(newInfo.CmsCaseId, courseids)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 	err = s.dao.DelCmsCaseImg(newInfo.CmsCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 		}
 		err = s.dao.SaveCmsCaseImg(CmsImg)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 		}
 		err = s.dao.SaveCmsCaseImg(CmsImg)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}

service/message/image.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
+)
+
+const (
+	ForwardTypeUrl    = "url"
+	ForwardTypeCourse = "course"
 )
 
 // GetImgList 获取图片列表
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	infos, err := s.dao.GetImgList(orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetImgListCount(orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 
 // SaveImg 保存轮播图信息
 func (s *MessageServ) SaveImg(imginfo model.TaCmsImages) (*model.TaCmsImages, error) {
+	if imginfo.ImageUrl == "" {
+		return nil, errors.New("图片不允许为空！")
+	}
+
+	if imginfo.ForwardType == "" {
+		return nil, errors.New("跳转类型不允许为空！")
+	}
+	if imginfo.ForwardType == ForwardTypeUrl && imginfo.ForwardUrl == "" {
+		return nil, errors.New("跳转地址不允许为空！")
+	}
+
+	if imginfo.ForwardType == ForwardTypeCourse && imginfo.CaseId == "" {
+		return nil, errors.New("跳转资源不允许为空！")
+	}
+
 	if imginfo.ImageId == "" {
 		newinfo, err := s.dao.AddCmsImg(imginfo)
 		return newinfo, err

service/message/message.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // MessageServ 系统处理
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	infos, err := s.dao.GetCmsInfoList(title, orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetCmsInfoListCount(title, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/message/news.go

 package message
 
 import (
+	"errors"
 	"spaceofcheng/services/models/message"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
+
+	"github.com/astaxie/beego"
 )
 
 // GetNewsList 获取咨询列表
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	infos, err := s.dao.GetNewsList(locationid, orgid, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetNewsListCount(locationid, orgid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *MessageServ) GetNewsByID(newsid string) (*message.CmsNews, error) {
 	info, err := s.dao.GetNewsByID(newsid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	newslocation, err := s.dao.GetNewsLocationByID(newsid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	info.NewsLocations = newslocation
 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 {
 		newInfo = &news
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelNewsLocation(newInfo.NewsId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveNewsLocation(newInfo.NewsId, locationids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/sys.go

 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 const (
 
 	accountRaw, err := json.Marshal(user)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	account := string(accountRaw)
 	// 查询数据库是否存在已有映射
 	userMapList, err := s.dao.GetUserMappingByOpenID(openID)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	// 更新数据库内容, 没有的话则插入
 	err = s.dao.UpdateUserMapping(&userMapping)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

service/system/role.go

 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
+
+	"github.com/astaxie/beego"
 )
 
 // RoleServ 系统处理
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	roles, err := s.dao.GetRoleList(caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetRoleCount(caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *RoleServ) GetRoleByID(roleid string) (*system.Role, 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
 		newInfo = &role
 	}
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.DelRoleMenu(newInfo.RoleId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveRoleMenu(newInfo.RoleId, menuids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	return newInfo, err

service/user.go

 	"spaceofcheng/services/models/system"
 	"spaceofcheng/services/utils"
 
+	"github.com/astaxie/beego"
 	"github.com/yl10/kit/encrypt"
 )
 
 	if pageSize == 0 {
 		pageSize = PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	userList, err := s.dao.GetUserList(username, typeid, caseids, page, pageSize)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	total, err := s.dao.GetUserCount(username, typeid, caseids)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 	// 当前用户角色
 	roles, err := s.dao.GetUserRole(user.UserId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	// 当前用户菜单
 	menus, err := s.dao.GetUserMenu(user.UserId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 
 func (s *UserServ) GetUserByID(userid string) (*system.UserInfo, error) {
 	userinfo, err := s.dao.GetUserByID(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.Pwd = ""
 	usertype, err := s.dao.GetUserType(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserType = usertype
 
 	usertag, err := s.dao.GetUserTag(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserTag = usertag
 
 	usercase, err := s.dao.GetUserCase(userid)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	userinfo.UserCase = usercase
 	if user.UserId != "" {
 		err = s.dao.UpdateUser(userInfo)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		// 删除用户对应的标签、用户类型及所属案场
 		err = s.dao.DelUserTag(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		err = s.dao.DelUserType(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		err = s.dao.DelUserBelongCase(user.UserId)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 		newUSer = &userInfo
 	} else {
 		newUSer, err = s.dao.AddUser(userInfo)
 		if err != nil {
+			beego.Error(err)
 			return nil, err
 		}
 	}
 	// 保存用户的标签、用户类型及所属案场
 	err = s.dao.SaveUserTag(newUSer.UserId, user.TagIds)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	err = s.dao.SaveUserType(newUSer.UserId, user.TypeId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	caseInfo, err := s.casedao.GetCaseByID(user.BelongCaseId)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	if caseInfo == nil {
 	userCase.UserId = newUSer.UserId
 	err = s.dao.SaveUserCase(userCase)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 	newUSer.Pwd = ""
 	if pageSize == 0 {
 		pageSize = PAGENUM
 	}
+	if page == 0 {
+		page = 1
+	}
 	customers, err := s.dao.GetUserCustomer(userid, page, pageSize)
 	return customers, err
 }
 func (s *UserServ) CheckUserSignIn(userName, userPassword string) (*model.SysUser, error) {
 	user, err := s.dao.GetUserByName(userName)
 	if err != nil {
+		beego.Error(err)
 		return nil, err
 	}
 

utils/captcha.go

 func (c *CaptchaEngine) ValidCaptcha(phone, cap string) error {
 	theCap, ok := c.capList[phone]
 	if !ok {
-		return errors.New("未发送过该号码的验证码")
+		return errors.New("手机号无效或验证码已过期")
 	}
 
-	if time.Now().Local().Before(theCap.Expire) {
+	if time.Now().Local().After(theCap.Expire) {
+		// 注销
+		delete(c.capList, phone)
+
 		return errors.New("验证码已过期")
 	}
 
 		return errors.New("验证码不正确")
 	}
 
+	// 如果成功, 则注销
+	delete(c.capList, phone)
+
 	return nil
 }
 

utils/pagenavi.go

 package utils
 
 import (
-	"errors"
-	"regexp"
 	"strconv"
-
-	"github.com/go-xorm/xorm"
 )
 
+type PageNaviEngine struct {
+	ctx *Context
+}
+
+func NewPageNaviEngine(ctx *Context) *PageNaviEngine {
+	return &PageNaviEngine{ctx: ctx}
+}
+
 // GetPageList 获取列表
-func GetPageList(db *xorm.Session, target interface{}, limit []int, sqlorArgs ...interface{}) (int64, error) {
-	if sqlorArgs == nil || len(sqlorArgs) == 0 {
-		return 0, errors.New("SQL 语句不存在")
+func (t *PageNaviEngine) GetPageList(target interface{}, sql string, limit []int, sqlArgs ...interface{}) (int64, error) {
+	countSQL := "select count(*) as cnt from (" + sql + ") as virtualTable"
+	countSQLorArgs := []interface{}{countSQL}
+	for _, arg := range sqlArgs {
+		countSQLorArgs = append(countSQLorArgs, arg)
 	}
 
-	countSQLorArgs := GetCountSQL(sqlorArgs...)
-	cntRes, err := db.Query(countSQLorArgs...)
+	cntRes, err := t.ctx.DB.Query(countSQLorArgs...)
 	if err != nil {
 		return 0, err
 	}
 	cntStr := string(cntRes[0]["cnt"])
 	cnt, _ := strconv.ParseInt(cntStr, 10, 64)
 
-	sql, args := PackLimitToSQL(limit, sqlorArgs...)
+	newSQL := t.PackLimitToSQL(sql, limit)
 
-	err = db.SQL(sql, args...).Find(target)
+	err = t.ctx.DB.SQL(newSQL, sqlArgs...).Find(target)
 	if err != nil {
 		return 0, err
 	}
 	return cnt, nil
 }
 
-// GetCountSQL 获取计算 Count 的相关 SQL 脚本
-func GetCountSQL(sqlorArgs ...interface{}) []interface{} {
-	sql := sqlorArgs[0].(string)
-
-	re := regexp.MustCompile("(?ims)(select .* from)")
-	cntSQL := re.ReplaceAllString(sql, "select count(*) as cnt from")
-
-	newSQLorArgs := []interface{}{cntSQL}
-	newSQLorArgs = append(newSQLorArgs, sqlorArgs[1:])
-	return newSQLorArgs
-}
-
 // PackLimitToSQL 添加 limit 语句到 sql 最后
-func PackLimitToSQL(limit []int, sqlorArgs ...interface{}) (string, []interface{}) {
-	sql := sqlorArgs[0].(string)
-	args := sqlorArgs[1:]
-
+func (t *PageNaviEngine) PackLimitToSQL(sql string, limit []int) string {
 	switch len(limit) {
 	case 1:
-		return sql + " LIMIT " + strconv.Itoa(limit[0]), args
+		return sql + " LIMIT " + strconv.Itoa(limit[0])
 	case 2:
-		return sql + " LIMIT " + strconv.Itoa(limit[0]) + " OFFSET " + strconv.Itoa(limit[1]), args
+		return sql + " LIMIT " + strconv.Itoa(limit[0]) + " OFFSET " + strconv.Itoa(limit[1])
 	default:
-		return sql, args
+		return sql
 	}
 }

utils/pagenavi_test.go

-package utils_test
-
-import (
-	"spaceofcheng/services/utils"
-	"testing"
-)
-
-func TestGetCountSQL(t *testing.T) {
-	testCases := []map[string]string{
-		map[string]string{
-			"sql":      "Select field1, field2 From table",
-			"expected": "select count(*) as cnt from table",
-		},
-		map[string]string{
-			"sql": `Select 
-								field1, field2 From table where status = ?`,
-			"expected": "select count(*) as cnt from table where status = ?",
-		},
-	}
-
-	for inx, cs := range testCases {
-		sql := cs["sql"]
-		expected := cs["expected"]
-
-		var res []interface{}
-		if inx < 1 {
-			res = utils.GetCountSQL(sql)
-		} else {
-			res = utils.GetCountSQL(sql, inx)
-		}
-
-		if res == nil || len(res) == 0 {
-			t.Fatalf("Test GetCountSQL fail --1")
-		}
-
-		newSQL := res[0].(string)
-		if newSQL != expected {
-			t.Fatalf("Test GetCountSQL fail: %s", newSQL)
-		}
-	}
-}
-
-func TestPackLimitToSQL(t *testing.T) {
-	testCases := []map[string]string{
-		map[string]string{
-			"sql":      "Select * From table",
-			"expected": "Select * From table LIMIT 1 OFFSET 0",
-		},
-		map[string]string{
-			"sql":      "Select * From table",
-			"expected": "Select * From table LIMIT 1",
-		},
-	}
-
-	for inx, cs := range testCases {
-		sql := cs["sql"]
-		expected := cs["expected"]
-
-		var sqlRes string
-		if inx < 1 {
-			sqlRes, _ = utils.PackLimitToSQL([]int{inx + 1, inx}, sql)
-		} else {
-			sqlRes, _ = utils.PackLimitToSQL([]int{inx}, sql, inx)
-		}
-
-		if sqlRes != expected {
-			t.Fatalf("\n%v: Test PackLimitToSQL fail: %s", inx+1, sqlRes)
-		}
-	}
-
-}

utils/permission.go

+package utils
+
+import (
+	"errors"
+	"spaceofcheng/services/models/model"
+	"strings"
+)
+
+// 系统内置数据种类
+const (
+	DATATYPE_USER   = "user"
+	DATATYPE_CASE   = "case"
+	DATATYPE_COURSE = "course"
+	DATATYPE_COUPON = "coupon"
+	DATATYPE_CARD   = "card"
+)
+
+// DataAuthEngine 鉴权数据
+type DataAuthEngine struct {
+	ctx *Context
+}
+
+// NewAuthEngine 生成新实例
+func NewAuthEngine(ctx *Context) *DataAuthEngine {
+	return &DataAuthEngine{ctx: ctx}
+}
+
+// AuthFilter 按权限过滤
+func (t *DataAuthEngine) AuthFilter(targ interface{}, sql string, params ...interface{}) error {
+	if t.ctx == nil {
+		return errors.New("未指定上下文环境")
+	}
+
+	// 用户所属案场
+	casesRaw := t.ctx.Get("cases")
+	if casesRaw == nil {
+		return errors.New("用户无权限操作该数据")
+	}
+	cases := casesRaw.([]model.SysUserCase)
+	csIDs := make([]string, 0)
+	for _, cs := range cases {
+		csIDs = append(csIDs, cs.CaseId)
+	}
+
+	newSQL := "select * from (" + sql + ") where case_id in ('" + strings.Join(csIDs, "','") + "')"
+	if err := t.ctx.DB.SQL(newSQL, params...).Find(targ); err != nil {
+		LogError("按权限查询数据失败: " + err.Error())
+		return errors.New("数据查询失败")
+	}
+
+	return nil
+}
+
+// HasUserPermission 是否有人员权限
+func (t *DataAuthEngine) HasUserPermission(userID, borrower string, caseID ...string) error {
+	// 1、先判断组织是否相同
+	userOrg, err := t.getOrgOfData(userID, DATATYPE_USER)
+	if err != nil {
+		LogError("查询用户(" + userID + ") 所属组织失败: " + err.Error())
+		return errors.New("查询用户相关信息失败")
+	}
+
+	borwOrg, err := t.getOrgOfData(borrower, DATATYPE_USER)
+	if err != nil {
+		LogError("查询用户(" + borrower + ") 所属组织失败: " + err.Error())
+		return errors.New("查询用户相关信息失败")
+	}
+
+	if userOrg != borwOrg {
+		return errors.New("人员不存在或无权浏览")
+	}
+
+	// 2、再判断是否案场相同
+	sameCases, err := t.getSameCase(userID, borrower)
+	if err != nil {
+		return errors.New("用户没有相同案场授权")
+	}
+
+	// 3、是否指定了案场
+	if len(caseID) > 0 {
+		if StrSliceIndexOf(sameCases, caseID[0]) < 0 {
+			return errors.New("用户没有当前案场权限")
+		}
+	}
+
+	return nil
+}
+
+func (t *DataAuthEngine) getOrgOfData(dataID, dataType string) (string, error) {
+	org := make(map[string]interface{})
+
+	switch dataType {
+	// 用户
+	case DATATYPE_USER:
+		if _, err := t.ctx.DB.SQL("select org_id from sys_user where user_id = ?", dataID).Get(&org); err != nil {
+			return "", err
+		}
+
+		orgID := org["org_id"].(string)
+		return orgID, nil
+
+		// 案场
+	case DATATYPE_CASE:
+		if _, err := t.ctx.DB.SQL("select org_id from sys_case where case_id = ?", dataID).Get(&org); err != nil {
+			return "", err
+		}
+
+		orgID := org["org_id"].(string)
+		return orgID, nil
+	default:
+		return "", nil
+	}
+}
+
+func (t *DataAuthEngine) getSameCase(user1, user2 string) ([]string, error) {
+	sql := `
+		SELECT t.case_id
+		FROM
+			sys_user_case t
+		JOIN sys_user_case s ON t.user_id = ?
+		AND s.user_id = ?
+		AND t.case_id = s.case_id	
+	`
+	res, err := t.ctx.DB.Query(sql, user1, user2)
+	if err != nil {
+		LogError("查询用户相同案场失败: " + err.Error())
+		return nil, err
+	}
+
+	if res == nil || len(res) == 0 {
+		return nil, errors.New("用户没有相同案场授权")
+	}
+
+	csIDs := make([]string, 0)
+	for _, cs := range res {
+		csIDs = append(csIDs, string(cs["case_id"]))
+	}
+
+	return csIDs, nil
+}

utils/sms.go

 		}
 
 		// 接口内容
-		paramsTpl := `{"code": "%s", "tel": "%s", "params": "[%s]"}`
+		paramsTpl := `{"code": "%s", "tel": "%s", "params": [%s]}`
 		// 发送消息
 		message := strings.Join(messages, `","`)
 		if message != "" {

utils/utils.go

 
 import (
 	"net/http"
+	"strconv"
 	"strings"
 )
 
 
 	return ClientAdmin
 }
+
+// StrSliceIndexOf slice indexof
+func StrSliceIndexOf(s []string, t string) int64 {
+	if s == nil || len(s) == 0 {
+		return -1
+	}
+
+	for k, v := range s {
+		if v == t {
+			return int64(k)
+		}
+	}
+
+	return -1
+}
+
+// GUIID2IntString guid 转 int 字符串
+func GUIID2IntString(id string) []string {
+	if id == "" {
+		return nil
+	}
+
+	res := make([]string, 0)
+	for _, part := range strings.Split(id, "-") {
+		sum := 0
+		for _, r := range []rune(part) {
+			sum += int(r)
+		}
+
+		res = append(res, strconv.Itoa(sum))
+	}
+
+	return res
+}

utils/utils_test.go

+package utils_test
+
+import (
+	"spaceofcheng/services/utils"
+	"strings"
+	"testing"
+)
+
+func TestStrSliceIndexOf(t *testing.T) {
+	cases := []map[string]interface{}{
+		map[string]interface{}{
+			"case":     []string{"a", "b", "c"},
+			"expected": int64(1),
+		},
+		map[string]interface{}{
+			"case":     []string{"aa", "bb", "cc"},
+			"expected": int64(-1),
+		},
+	}
+
+	for _, cs := range cases {
+		td := cs["case"].([]string)
+		ex := cs["expected"].(int64)
+
+		res := utils.StrSliceIndexOf(td, "b")
+
+		if ex != res {
+			t.Fatalf("TestStrSliceIndexOf case fail : %v", res)
+		}
+	}
+}
+
+func TestGUIID2IntString(t *testing.T) {
+	cases := []map[string]string{
+		map[string]string{
+			"case":     "3b2da085-8881-4029-9a3d-6d33caf870d0",
+			"expected": "553-217-207-305-861",
+		},
+	}
+
+	for _, cs := range cases {
+		res := utils.GUIID2IntString(cs["case"])
+		if strings.Join(res, "-") != cs["expected"] {
+			t.Fatalf("TestGUIID2IntString fail")
+		}
+	}
+
+}