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

.gitignore

 *.exe
 *.exe~
-*.test
+*.test
+*.log

conf/app.conf

 copyrequestbody = true
 EnableDocs = true
 sessionon = true
+excelpath = ./
 
 
 [cros]
 guest = "/guest/:org"
 common = "/common/:org"
 wechat = "/wechat/:org"
+

controllers/auth.go

 import (
 	"errors"
 	"net/http"
+	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	"strings"
 
 	// 客户端类型
 	clientType := utils.GetClientType(c.Ctx.Request)
+
 	switch clientType {
 	case utils.ClientAdmin:
 		c.authPCAdmin(serv)
 		custID = custIDRaw.(string)
 	}
 
-	// 机构ID - 后面再思考机构问题
-	var orgID = "1"
+	// 机构
+	org := c.Context.Get("org").(model.SysOrg)
+
 	// 微信配置
-	wxConf, err := serv.GetWeChatConfig(orgID)
+	wxConf, err := serv.GetWeChatConfig(org.OrgId)
 	if err != nil {
 		utils.LogError("查询微信配置失败: " + err.Error())
 		c.ResponseError(
 			http.StatusBadRequest,
 		)
 	}
-	utils.WxClientSingleton(orgID, wxConf)
+	utils.WxClientSingleton(org.OrgId, wxConf)
 
 	// 用户微信信息
 	var wxDetail map[string]interface{}
 				"unionid":    "o6_bmasdasdsad6_2sgVt7hMZOPfL",
 			}
 		} else {
-			wxDetail = c.getWechatDetail(orgID, serv)
+			wxDetail = c.getWechatDetail(org.OrgId, serv)
 		}
 
 		c.SetSession("wechat_user", wxDetail)
 	if !c.needAuth() {
 		return
 	}
-
 	// 未登录或者绑定, 返回 401
 	if custID == "" && userMap.UserId == "" {
-		c.ResponseData(
-			map[string]interface{}{
-				"appid": wxConf["appid"],
-			},
+		c.ResponseError(
 			errors.New("用户未登录或绑定"),
-			http.StatusUnauthorized,
+			http.StatusNotAcceptable,
 		)
 	}
 
 	// 微信 code
 	code := c.GetString("code")
 	if code == "" {
-		c.ResponseError(
-			errors.New("没有接收到微信 code"),
+		c.ResponseData(
+			map[string]interface{}{
+				"appid": utils.GetWxAppID(org),
+			},
+			errors.New("获取微信信息失败"),
 			http.StatusUnauthorized,
 		)
 	}

controllers/cases/case.go

 package cases
 
 import (
+	"errors"
 	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/cases"
+	"spaceofcheng/services/utils"
 )
 
 // CaseController 信息
 
 	c.ResponseJSON(res)
 }
+
+// GetCaseConf 获取案场对应的配置
+func (c *CaseController) GetCaseConf() {
+	caseid := c.GetString(":caseid")
+	conf, err := c.dao.GetCaseConf(caseid, cases.CONFTYPE_GOODS)
+	if err != nil {
+		utils.LogError("获取案场配置信息失败: " + err.Error())
+		c.ResponseError(errors.New("获取案场信息失败！"))
+	}
+	c.ResponseJSON(conf)
+}
+
+// OpenCaseCoffee 开启
+func (c *CaseController) OpenCaseCoffee() {
+	caseid := c.GetString(":caseid")
+	err := c.dao.UpdateCaseConf(caseid, cases.CONFTYPE_GOODS, models.STATUS_NORMAL)
+	if err != nil {
+		utils.LogError("开启失败: " + err.Error())
+		c.ResponseError(errors.New("操作失败！"))
+	}
+	c.ResponseJSON("操作成功！")
+}
+
+// CloseCaseCoffee 关闭
+func (c *CaseController) CloseCaseCoffee() {
+	caseid := c.GetString(":caseid")
+	err := c.dao.UpdateCaseConf(caseid, cases.CONFTYPE_GOODS, models.STATUS_READY)
+	if err != nil {
+		utils.LogError("关闭失败: " + err.Error())
+		c.ResponseError(errors.New("操作失败！"))
+	}
+	c.ResponseJSON("操作成功！")
+}

controllers/cases/tag.go

 	cases := c.Context.Get("cases").([]model.SysUserCase)
 	caseIDs := c.GetCaseIDs(cases)
 
+	if caseid == "" {
+		caseid = caseIDs
+	}
+
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
 

controllers/course/course.go

 func (c *CourseController) GetCourseSchedule() {
 	name := c.GetString("name")
 	caseids := c.GetString("caseid")
+	courseid := c.GetString("courseid")
 	if caseids == "" {
 		cases := c.Context.Get("cases").([]model.SysUserCase)
 		caseids = c.GetCaseIDs(cases)
 	date := c.GetString("date")
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
-	list, err := c.serv.GetCourseSchedule(name, caseids, date, page, pageSize)
+	list, err := c.serv.GetCourseSchedule(name, caseids, courseid, date, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}
 func (c *CourseController) GetDetails() {
 	caseid := c.GetString("caseid")
 	date := c.GetString("date")
-	list, err := c.serv.GetDetails(caseid, date)
+	courseid := c.GetString("courseid")
+	list, err := c.serv.GetDetails(caseid, date, courseid)
 	if err != nil {
 		c.ResponseError(err)
 	}
 	}
 	c.ResponseJSON(courses)
 }
+
+// GetCustomerCourse 获取用户课程信息
+func (c *CourseController) GetCustomerCourse() {
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+
+	courses, err := c.serv.GetCustomerCourse(page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(courses)
+}
+
+// GetCustomerCourseByID 获取用户课程信息明细
+func (c *CourseController) GetCustomerCourseByID() {
+	id := c.GetString(":id")
+	info, err := c.serv.GetCustomerCourseByID(id)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(info)
+}

controllers/customer/customer.go

 
 	c.ResponseJSON("ok")
 }
+
+// CustByTel 根据电话查询用户信息
+func (c *CustomerController) CustByTel() {
+	tel := c.GetString(":tel")
+	customer, err := c.serv.GetCustUserByTel(tel)
+	if err != nil {
+		utils.LogError("获取客户信息失败: " + err.Error())
+		c.ResponseError(
+			errors.New("获取客户信息失败"),
+			http.StatusInternalServerError,
+		)
+	}
+	c.ResponseJSON(customer)
+}

controllers/goods/goods.go

 	"encoding/json"
 	"errors"
 	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models/cases"
 	goodsModel "spaceofcheng/services/models/goods"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/goods"
 type GoodsController struct {
 	serv *goods.GoodsServ
 	controllers.BaseController
+	caseserv *cases.CaseDAO
 }
 
 // Constructor 初始化 Controller
 // @Description 初始化 Controller, 系统自动调用
 func (c *GoodsController) Constructor() {
 	c.serv = goods.NewGoodsServ(c.Context)
+	c.caseserv = cases.NewCaseDAO(c.Context)
 }
 
 // GetListByCase 获取案场商品列表
 func (c *GoodsController) GetListByCase() {
 	page, _ := c.GetInt("page")
 	pagesize, _ := c.GetInt("pagesize")
-	caseID := c.GetString("caseid")
+	caseids := c.GetString("caseid")
 	goodsName := c.GetString("name")
 	goodsType := c.GetString("type")
 
-	goodsList, cnt, err := c.serv.GetGoodsListPageNavi(goodsName, goodsType, caseID, page, pagesize)
+	if caseids == "" {
+		cases := c.Context.Get("cases").([]model.SysUserCase)
+		caseids = c.GetCaseIDs(cases)
+	}
+	goodsList, cnt, err := c.serv.GetGoodsListPageNavi(goodsName, goodsType, caseids, page, pagesize)
 	if err != nil {
 		c.ResponseError(err)
 	}

controllers/goods/order.go

 package goods
 
 import (
+	"cdkj-check/models"
 	"encoding/json"
 	"errors"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+	"strconv"
 	"time"
+
+	"github.com/astaxie/beego"
+	"github.com/tealeg/xlsx"
 )
 
 // GetOrderList 获取商品订单
 	c.ResponseJSON("ok")
 }
 
-// GetOrdersByRecord 根据月记录获取订单信息
+// GetOrdersByRecord 根据月记录导出订单信息
 func (c *GoodsController) GetOrdersByRecord() {
 	recordid := c.GetString(":recordid")
+
+	record, err := c.caseserv.GetRecordByID(recordid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	if record == nil {
+		c.ResponseError(errors.New("不存在对应的月记录！"))
+	}
+
 	orders, err := c.serv.GetOrdersByRecord(recordid)
 	if err != nil {
 		c.ResponseError(err)
 	}
+
+	file := xlsx.NewFile()
+	sheet, _ := file.AddSheet("Sheet1")
+	row := sheet.AddRow()
+	row.SetHeightCM(0.8) //设置每行的高度
+	cell := row.AddCell()
+	cell.Value = "归属案场"
+	cell = row.AddCell()
+	cell.Value = "商品分类"
+	cell = row.AddCell()
+	cell.Value = "商品名称"
+	cell = row.AddCell()
+	cell.Value = "商品规格"
+	cell = row.AddCell()
+	cell.Value = "下单人"
+	cell = row.AddCell()
+	cell.Value = "销售数量"
+	cell = row.AddCell()
+	cell.Value = "商品单价"
+	cell = row.AddCell()
+	cell.Value = "商品总价"
+	cell = row.AddCell()
+	cell.Value = "订单状态"
+	cell = row.AddCell()
+	cell.Value = "下单时间"
+	cell = row.AddCell()
+	cell.Value = "订单号"
+	var amount float64
+	amount = 0
+	for _, order := range orders {
+		for _, good := range order.Goods {
+			row := sheet.AddRow()
+			row.SetHeightCM(0.8) //设置每行的高度
+			cell := row.AddCell()
+			cell.Value = order.CaseName
+			cell = row.AddCell()
+			cell.Value = good.TypeName
+			cell = row.AddCell()
+			cell.Value = good.GoodsName
+			cell = row.AddCell()
+			cell.Value = good.SpecName
+			cell = row.AddCell()
+			cell.Value = order.UserName
+			cell = row.AddCell()
+			cell.Value = strconv.Itoa(good.Number)
+			cell = row.AddCell()
+			cell.Value = good.Price
+			cell = row.AddCell()
+			price, err := strconv.ParseFloat(good.Price, 64)
+			if err != nil {
+				c.ResponseError(errors.New("金额类型不正确！"))
+			}
+			num, err := strconv.ParseFloat(strconv.Itoa(good.Number), 64)
+			if err != nil {
+				c.ResponseError(errors.New("金额类型不正确！"))
+			}
+			amount = amount + price*num
+			cell.Value = strconv.FormatFloat(price*num, 'f', -1, 64)
+			cell = row.AddCell()
+			var status = "未完成"
+			if order.Status == models.STATUS_NOMAL {
+				status = "已完成"
+			}
+			cell.Value = status
+			cell = row.AddCell()
+			cell.Value = order.CreateDate.Format("2006-01-02 15:04:05")
+			cell = row.AddCell()
+			cell.Value = order.OrdersNo
+		}
+	}
+	row = sheet.AddRow()
+	row.SetHeightCM(0.8)
+	cell = row.AddCell()
+	cell.Value = "总规定次数"
+	cell = row.AddCell()
+	cell.Value = strconv.Itoa(record.Num)
+	cell = row.AddCell()
+	cell.Value = "实际使用总数"
+	cell = row.AddCell()
+	cell.Value = strconv.Itoa(record.ActrualNum)
+	cell = row.AddCell()
+	cell.Value = "总价"
+	cell = row.AddCell()
+	cell.Value = strconv.FormatFloat(amount, 'f', -1, 64)
+
+	excelpath := beego.AppConfig.String("excelpath") + utils.GetGUID() + ".xlsx"
+	err = file.Save(excelpath)
+
 	c.ResponseJSON(orders)
 }
+
+// GetCustomerOrders 获取用户订单
+func (c *GoodsController) GetCustomerOrders() {
+	page, _ := c.GetInt("page")
+	pageSize, _ := c.GetInt("pagesize")
+
+	orders, err := c.serv.GetCustomerOrders(page, pageSize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(orders)
+}
+
+// GetCaseOrdersNum 获取案场订单数量
+func (c *GoodsController) GetCaseOrdersNum() {
+	caseid := c.GetString(":caseid")
+	num, err := c.serv.GetCaseOrdersNum(caseid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(num)
+}
+
+// FinishMake 完成制作
+func (c *GoodsController) FinishMake() {
+	orderid := c.GetString(":id")
+	err := c.serv.FinishMake(orderid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("操作成功！")
+}
+
+// CancelMake 取消制作
+func (c *GoodsController) CancelMake() {
+	orderid := c.GetString(":id")
+	err := c.serv.CancelMake(orderid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("操作成功！")
+}

controllers/system/role.go

 
 // GetRoleList 获取角色列表
 func (c *RoleController) GetRoleList() {
-	cases := c.Context.Get("cases").([]model.SysUserCase)
-	caseIDs := c.GetCaseIDs(cases)
+	// cases := c.Context.Get("cases").([]model.SysUserCase)
+	// caseIDs := c.GetCaseIDs(cases)
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
 	name := c.GetString("name")
-	caseid := c.GetString("caseid")
+	// caseid := c.GetString("caseid")
 
-	list, err := c.dao.GetRoleList(caseIDs, name, caseid, page, pageSize)
+	list, err := c.dao.GetRoleList(name, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}

controllers/user/user.go

 	}
 	c.ResponseJSON(roles)
 }
+
+// GetUserByTel 根据电话获取用户信息
+func (c *UserController) GetUserByTel() {
+	tel := c.GetString(":tel")
+	user, err := c.dao.GetUserByTel(tel)
+	if err != nil {
+		utils.LogError("获取用户信息失败: " + err.Error())
+		c.ResponseError(
+			errors.New("获取用户信息失败"),
+			http.StatusInternalServerError,
+		)
+	}
+	c.ResponseJSON(user)
+}

controllers/verify/verify.go

 // GetCustomerCourseDetailListById 根据id获取我的课程详情
 func (c *VerifyController) GetCustomerCourseDetailListById() {
 	customerCourseId := c.GetString(":customerCourseId")
-	caseid := c.GetString("caseid")
-	if caseid == "" {
-		caseinfo := c.Context.Get("currentCase").(model.SysUserCase)
-		caseid = caseinfo.CaseId
-	}
+	cases := c.Context.Get("cases").([]model.SysUserCase)
+	caseids := c.GetCaseIDs(cases)
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
-	list, err := c.dao.GetCustomerCourseDetailById(customerCourseId, caseid, page, pageSize)
+	list, err := c.dao.GetCustomerCourseDetailById(customerCourseId, caseids, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}
 
 // GetCustomerCourseDetailListBytel 根据手机号获取我的课程详情id
 func (c *VerifyController) GetCustomerCourseDetailListBytel() {
-	caseid := c.GetString("caseid")
-	if caseid == "" {
-		caseinfo := c.Context.Get("currentCase").(model.SysUserCase)
-		caseid = caseinfo.CaseId
-	}
+	cases := c.Context.Get("cases").([]model.SysUserCase)
+	caseids := c.GetCaseIDs(cases)
 	tel := c.GetString(":tel")
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
-	list, err := c.dao.GetCustomerCourseDetailByTel(tel, caseid, page, pageSize)
+	list, err := c.dao.GetCustomerCourseDetailByTel(tel, caseids, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}

controllers/vipcard/vipcard.go

 
 import (
 	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/vipcard"
 	"time"
 
 // GetVipList 获取VIP卡列表
 func (c *VipcardController) GetVipList() {
-	cases := c.Context.Get("cases").([]model.SysUserCase)
-	caseId := c.GetCaseIDs(cases)
+	caseids := c.GetString("caseid")
+	if caseids == "" {
+		cases := c.Context.Get("cases").([]model.SysUserCase)
+		caseids = c.GetCaseIDs(cases)
+	}
+
 	page, _ := c.GetInt("page")
 	pageSize, _ := c.GetInt("pagesize")
-	list, err := c.dao.GetVipChild(caseId, page, pageSize)
+
+	cardNo := c.GetString("cardNo")
+	sellerName := c.GetString("sellerName")
+	userName := c.GetString("userName")
+
+	list, err := c.dao.GetVipChild(caseids, cardNo, sellerName, userName, page, pageSize)
 	if err != nil {
 		c.ResponseError(err)
 	}
 // userCharge 用户激活vip卡
 func (c *VipcardController) UserCharge() {
 	vipCode := c.GetString(":vipCardChildCode")
-	tel := c.GetString(":tel")
+	tel := c.GetString("tel")
 	var createUser = c.Context.Get("user").(model.SysUser)
 	vipChild, err := c.dao.GetVipChildByCode(vipCode)
 	if err != nil {
 	if err != nil {
 		c.ResponseError(err)
 	}
+
+	salesid := c.GetString("salesid")
+	salesname := c.GetString("salesname")
+
 	vipChild.CustomerId = customer.CustomerId
 	vipChild.CustomerTel = tel
 	vipChild.ActiveDate = time.Now()
-	err1 := c.dao.UpdateVipChild(vipChild)
-	if err1 != nil {
+	vipChild.Status = models.STATUS_NORMAL
+	vipChild.SalesId = salesid
+	vipChild.SalesName = salesname
+	err = c.dao.UpdateVipChild(vipChild)
+	if err != nil {
 		c.ResponseError(err)
 	}
-	err2 := c.dao.CustomerCharge(vipChild, createUser)
-	if err2 != nil {
+	err = c.dao.CustomerCharge(vipChild, createUser)
+	if err != nil {
 		c.ResponseError(err)
 	}
 	c.ResponseJSON("激活成功")
 
 }
+
+// GetVipByCode 根据code获取Vip卡信息
+func (c *VipcardController) GetVipByCode() {
+	code := c.GetString(":code")
+	vipChild, err := c.dao.GetVipChildByCode(code)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(vipChild)
+}

models/cases/cases.go

 // GetCaseUserByType 获取案场人员
 func (m *CaseDAO) GetCaseUserByType(csIDs []string, typeID string) ([]UserCase, error) {
 	query := `
-		SELECT n.user_id, n.real_name as user_name, s.case_id, '' as case_name
+			SELECT
+			n.user_id,
+			n.real_name AS user_name,
+			c.case_id,
+			'' AS case_name
 		FROM
 			td_user_type s
 		JOIN sys_user_type m ON s.type_id = m.type_id
 		JOIN sys_user n ON m.user_id = n.user_id
+		JOIN sys_user_case c on n.user_id = c.user_id
 		AND n.status = ?
 		WHERE
-			s.case_id IN ('` + strings.Join(csIDs, "','") + `')
+			c.case_id IN ('` + strings.Join(csIDs, "','") + `')
 		AND s.type_id = ?
 	`
-
 	var users []UserCase
 	if err := m.db.SQL(query, models.STATUS_NORMAL, typeID).Find(&users); err != nil {
 		return nil, err

models/cases/conf.go

 
 // GetConfByCase 获取配置信息
 func (m *CaseDAO) GetConfByCase(caseid, conftype string) (*model.SysCaseConf, error) {
-	var conf = new(model.SysCaseConf)
-	conf.Status = models.STATUS_NORMAL
-	has, err := m.db.Where("case_id=?", caseid).And("conf_type=?", conftype).Get(&conf)
+	var conf []model.SysCaseConf
+	err := m.db.Where("case_id=?", caseid).And("conf_type=?", conftype).Find(&conf)
 	if err != nil {
 		return nil, err
 	}
-	if !has {
-		return nil, err
+	if len(conf) > 0 {
+		return &conf[0], err
 	}
-	return conf, err
+	return nil, err
 }
 
 // SaveCaseConf 保存案场配置信息
 func (m *CaseDAO) SaveCaseConf(conf model.SysCaseConf) (*model.SysCaseConf, error) {
 	conf.ConfId = utils.GetGUID()
+	conf.Status = models.STATUS_READY
 	_, err := m.db.Insert(conf)
 	return &conf, err
 }
 	cols := []string{
 		"status",
 	}
-	_, err := m.db.Cols(cols...).Where("conf_id=?", conf.ConfId).Update(conf)
+	_, err := m.db.Cols(cols...).Where("case_id=?", conf.CaseId).And("conf_type=?", conf.ConfType).Update(conf)
 	return err
 }

models/cases/record.go

 	LeftNum             int
 }
 
+const (
+	ISOVER   = 1
+	ISNOOVER = 0
+)
+
 // GetCaseRecord 获取案场月记录
 func (m *CaseDAO) GetCaseRecord(caseids string, page, pageSize int) ([]CaseRecord, error) {
 	var records []CaseRecord
 	record.CreateDate = time.Now()
 	record.RecordId = utils.GetGUID()
 	record.Status = models.STATUS_NORMAL
-	record.IsOver = 1
+	record.IsOver = ISOVER
 	_, err := m.db.Insert(record)
 	return &record, err
 }
 	}
 	return nil, nil
 }
+
+// GetRecordByID 根据id获取月记录
+func (m *CaseDAO) GetRecordByID(recordid string) (*CaseRecord, error) {
+	var records []CaseRecord
+	sql := `select * from sys_case_record where record_id='` + recordid + `'`
+
+	err := m.db.Sql(sql).Find(&records)
+	if err != nil {
+		return nil, err
+	}
+	if len(records) > 0 {
+		var record = records[0]
+		info, err := m.GetRecordWithNum(record)
+		return info, err
+	}
+
+	return nil, nil
+}
+
+// GetRecordWithNum 获取月记录对应信息
+func (m *CaseDAO) GetRecordWithNum(record CaseRecord) (*CaseRecord, error) {
+	orders := new(model.TaGoodsOrders)
+	total, err := m.db.Where("case_id=?", record.CaseId).And("status=?", models.STATUS_NORMAL).And("user_type=?", goods.USERTPE_SALES).And("date_format(create_date,'%Y-%m')=?", record.Month).Sums(orders, "orders_num")
+	if err != nil {
+		return nil, err
+	}
+	record.ActrualNum = int(total[0])
+	var overnum int
+	var leftnum int
+	if record.ActrualNum > record.Num {
+		overnum = record.ActrualNum - record.Num
+	} else {
+		leftnum = record.Num - record.ActrualNum
+	}
+	record.OverNum = overnum
+	record.LeftNum = leftnum
+	return &record, err
+}
+
+// GetRecordByCase 获取案场当月记录信息
+func (m *CaseDAO) GetRecordByCase(caseid string) (*CaseRecord, error) {
+	var records []CaseRecord
+	sql := `select * from sys_case_record where month = date_format(NOW(),'%Y-%m') and case_id='` + caseid + `'`
+
+	err := m.db.Sql(sql).Find(&records)
+	if err != nil {
+		return nil, err
+	}
+	if len(records) > 0 {
+		var record = records[0]
+		info, err := m.GetRecordWithNum(record)
+		return info, err
+	}
+
+	return nil, nil
+}

models/constant.go

 	USERTYPE_SALES = "sales"
 	// 主管
 	USERTYPE_MANAGER = "manager"
+	// 客户
+	USERTYPE_CUSTOMER = "customer"
 )
 
 // 课程获取方式
 	VERIFY_USED    = "used"
 	VERIFY_LATE    = "late"
 )
+
+// 游泳健身卡种类
+const (
+	GYM_CARD_ONCE    = "once"
+	GYM_CARD_MONTH   = "month"
+	GYM_CARD_QUARTER = "quarter"
+	GYM_CARD_YEAR    = "year"
+)

models/coupon/coupon.go

+package coupon
+
+import (
+	"errors"
+	"fmt"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strings"
+	"time"
+
+	"github.com/yl10/kit/guid"
+
+	"github.com/go-xorm/xorm"
+)
+
+// CouponDAO 当前数据库操作对象
+type CouponDAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewCouponDAO New Inst
+func NewCouponDAO(ctx *utils.Context) *CouponDAO {
+	return &CouponDAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+// GetCouponInfoByID 获取优惠券详情
+func (m *CouponDAO) GetCouponInfoByID(id string) (*CouponInfo, error) {
+	cp := new(CouponInfo)
+
+	query := `
+		SELECT
+			t.*, s.coupon_type_name
+		FROM
+			ta_coupon t
+		LEFT JOIN td_coupon_type s ON t.coupon_type_id = s.coupon_type_id
+		WHERE
+			t.coupon_id = ?
+	`
+
+	if _, err := m.db.SQL(query, id).Get(cp); err != nil {
+		return nil, err
+	}
+
+	// 规则
+	var rules []model.TaCouponRule
+	if err := m.db.Where("coupon_id=?", id).And("status=?", models.STATUS_NORMAL).Find(&rules); err != nil {
+		return nil, err
+	}
+
+	// 图片
+	var imgs []model.TaCouponImage
+	if err := m.db.Where("coupon_id=?", id).Find(&imgs); err != nil {
+		return nil, err
+	}
+
+	// 关联目标
+	var targes []model.TaCouponTarget
+	if err := m.db.Where("coupon_id=?", id).Find(&targes); err != nil {
+		return nil, err
+	}
+
+	// 分享
+	share := new(model.TaCouponShare)
+	if _, err := m.db.Where("coupon_id=?", id).And("status=?", models.STATUS_NORMAL).Get(share); err != nil {
+		return nil, err
+	}
+
+	cp.Targets = targes
+	cp.Images = imgs
+	cp.Rules = rules
+	cp.Share = *share
+
+	return cp, nil
+}
+
+// GetCouponList 获取优惠券列表
+func (m *CouponDAO) GetCouponList(filters []string, limit []int) ([]model.TaCoupon, int64, error) {
+	var cps []model.TaCoupon
+
+	filterString := ""
+	if len(filters) > 0 {
+		filterString = strings.Join(filters, " and ")
+	}
+
+	sql := `select * from ta_coupon where %s status = 1 order by create_date desc`
+
+	total, err := utils.NewPageNaviEngine(m.ctx).GetPageList(&cps, fmt.Sprintf(sql, filterString), limit)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return cps, total, nil
+}
+
+// SaveCoupon 保存优惠券
+func (m *CouponDAO) SaveCoupon(cp *model.TaCoupon) error {
+	if cp.CouponId == "" {
+		cp.CouponId = guid.NewGUIDString()
+	}
+
+	userRaw := m.ctx.Get("user")
+	if userRaw != nil {
+		user := userRaw.(model.SysUser)
+		cp.CreateUser = user.UserId
+	}
+
+	cp.Status = models.STATUS_NORMAL
+	cp.CreateDate = time.Now().Local()
+
+	if _, err := m.db.Insert(cp); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateCoupon 更新优惠券
+func (m *CouponDAO) UpdateCoupon(cp *model.TaCoupon, cols []string) error {
+	if cp.CouponId == "" {
+		return errors.New("无优惠券信息")
+	}
+
+	if _, err := m.db.Cols(cols...).Where("coupon_id=?", cp.CouponId).Update(cp); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// DeleteCoupon 删除优惠券
+func (m *CouponDAO) DeleteCoupon(id string) error {
+	if id == "" {
+		return errors.New("无优惠券信息")
+	}
+
+	cp := model.TaCoupon{
+		CouponId: id,
+		Status:   models.STATUS_DEL,
+	}
+
+	if err := m.UpdateCoupon(&cp, []string{"status"}); err != nil {
+		return err
+	}
+
+	return nil
+}

models/coupon/image.go

+package coupon
+
+import (
+	"spaceofcheng/services/models/model"
+
+	"github.com/yl10/kit/guid"
+)
+
+// UpdateImages 更新图片 -- 插入或者更新
+func (m *CouponDAO) UpdateImages(imgs []model.TaCouponImage, couponID string) error {
+	if imgs == nil || len(imgs) == 0 {
+		return nil
+	}
+
+	for i := range imgs {
+		imgs[i].CouponId = couponID
+
+		if imgs[i].CouponImageId == "" {
+			imgs[i].CouponImageId = guid.NewGUIDString()
+		}
+	}
+
+	var delImgs []model.TaCouponImage
+	if _, err := m.db.Where("coupon_id=?", couponID).Delete(&delImgs); err != nil {
+		return err
+	}
+
+	if _, err := m.db.Insert(imgs); err != nil {
+		return err
+	}
+
+	return nil
+}

models/coupon/rule.go

+package coupon
+
+import (
+	"spaceofcheng/services/models/model"
+
+	"github.com/yl10/kit/guid"
+)
+
+// UpdateRule 更新规则 -- 插入或者更新
+func (m *CouponDAO) UpdateRule(rules []model.TaCouponRule, couponID string) error {
+	if rules == nil || len(rules) == 0 {
+		return nil
+	}
+
+	for i := range rules {
+		rules[i].CouponId = couponID
+
+		if rules[i].CouponRuleId == "" {
+			rules[i].CouponRuleId = guid.NewGUIDString()
+		}
+	}
+
+	var delRules []model.TaCouponRule
+	if _, err := m.db.Where("coupon_id=?", couponID).Delete(&delRules); err != nil {
+		return err
+	}
+
+	if _, err := m.db.Insert(rules); err != nil {
+		return err
+	}
+
+	return nil
+}

models/coupon/share.go

+package coupon
+
+import (
+	"errors"
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+
+	"github.com/yl10/kit/guid"
+)
+
+// SaveCouponShare 保存优惠券
+func (m *CouponDAO) SaveCouponShare(cp *model.TaCouponShare) error {
+	if cp.CouponShareId == "" {
+		cp.CouponShareId = guid.NewGUIDString()
+	}
+
+	cp.Status = models.STATUS_NORMAL
+
+	if _, err := m.db.Insert(cp); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateCouponShare 更新优惠券
+func (m *CouponDAO) UpdateCouponShare(cp *model.TaCouponShare, cols []string) error {
+	if cp.CouponShareId == "" {
+		return errors.New("无优惠券分享信息")
+	}
+
+	if _, err := m.db.Cols(cols...).Where("coupon_share_id=?", cp.CouponShareId).Update(cp); err != nil {
+		return err
+	}
+
+	return nil
+}

models/coupon/target.go

+package coupon
+
+import (
+	"spaceofcheng/services/models/model"
+)
+
+// UpdateTarget 更新关联内容 -- 插入或者更新
+func (m *CouponDAO) UpdateTarget(targets []model.TaCouponTarget, couponID string) error {
+	if targets == nil || len(targets) == 0 {
+		return nil
+	}
+
+	for i := range targets {
+		targets[i].CouponId = couponID
+	}
+
+	var delTargets []model.TaCouponTarget
+	if _, err := m.db.Where("coupon_id=?", couponID).Delete(&delTargets); err != nil {
+		return err
+	}
+
+	if _, err := m.db.Insert(targets); err != nil {
+		return err
+	}
+
+	return nil
+}

models/coupon/types.go

+package coupon
+
+import (
+	"spaceofcheng/services/models/model"
+)
+
+// 优惠券用途
+const (
+	COUPON_FOR_GOODS  = "goods"
+	COUPON_FOR_COURSE = "course"
+)
+
+// CouponInfo 优惠券信息
+type CouponInfo struct {
+	model.TaCoupon `xorm:"extends"`
+	CouponTypeName string
+	Share          model.TaCouponShare
+	Targets        []model.TaCouponTarget
+	Images         []model.TaCouponImage
+	Rules          []model.TaCouponRule
+}

models/course/course.go

 func (m *CourseDAO) GetCourseInfo(courseid string) (*CourseDetail, error) {
 	course := new(CourseDetail)
 	sql := `select * from ta_course where course_id='` + courseid + `'`
-	has, err := m.db.Sql(sql).Get(&course)
+	has, err := m.db.Sql(sql).Get(course)
 	if err != nil {
 		return nil, err
 	}
 }
 
 // GetDetails 获取所有的排课记录
-func (m *CourseDAO) GetDetails(caseid, date string) ([]DetailInfo, error) {
+func (m *CourseDAO) GetDetails(caseid, date, courseid string) ([]DetailInfo, error) {
 	var details []DetailInfo
 
 	sql := `select a.*,b.course_name,b.status as course_status,c.case_name,c.case_address from ta_course_detail a 
 	inner join ta_course b on a.course_id=b.course_id 
 	inner join sys_case c on a.case_id=c.case_id where a.status>` + strconv.Itoa(models.STATUS_DEL) + `
-	and b.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.case_id='` + caseid + `' and DATE_FORMAT(a.begin_date,'%Y-%m') = '` + date + `'`
+	and b.status>` + strconv.Itoa(models.STATUS_DEL) + ` and DATE_FORMAT(a.begin_date,'%Y-%m') = '` + date + `'`
+
+	if courseid != "" {
+		sql = sql + ` and a.course_id = '` + courseid + `'`
+	} else {
+		sql = sql + ` and a.case_id='` + caseid + `'`
+	}
 	err := m.db.Sql(sql).Find(&details)
 
-	// err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("DATE_FORMAT(begin_date,'%Y-%m') = ?", date).Find(&details)
 	return details, err
 }
 
 // GetCourseSchedule 获取需要排课的记录
-func (m *CourseDAO) GetCourseSchedule(name, caseids, date string, page, pageSize int) ([]model.TaCourse, error) {
+func (m *CourseDAO) GetCourseSchedule(name, caseids, courseid, date string, page, pageSize int) ([]model.TaCourse, error) {
 	var courses []model.TaCourse
 	dao := m.db.Where("status=?", STATUS_UNPUBLISH).And("schedule_num<course_num").And("'" + date + "' BETWEEN begin_date and end_date")
 	if name != "" {
 		dao.And("course_name like '%" + name + "%'")
 	}
-	if caseids != "" {
-		dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+
+	if courseid != "" {
+		dao.And("course_id=?", courseid)
+	} else {
+		if caseids != "" {
+			dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+		}
 	}
 	err := dao.Desc("create_date").Limit(pageSize, (page-1)*pageSize).Find(&courses)
 	return courses, err
 }
 
 // GetCourseScheduleCount 获取排课记录数
-func (m *CourseDAO) GetCourseScheduleCount(name, caseids, date string) (int, error) {
+func (m *CourseDAO) GetCourseScheduleCount(name, caseids, courseid, date string) (int, error) {
 	var courses []model.TaCourse
 	dao := m.db.Where("status=?", STATUS_UNPUBLISH).And("schedule_num<course_num").And("'" + date + "' BETWEEN begin_date and end_date")
 	if name != "" {
 		dao.And("course_name like '%" + name + "%'")
 	}
-	if caseids != "" {
-		dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+	if courseid != "" {
+		dao.And("course_id=?", courseid)
+	} else {
+		if caseids != "" {
+			dao.And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+		}
 	}
 	err := dao.Find(&courses)
 	return len(courses), err
 
 	return nil
 }
+
+// CustomerCourse 客户课程信息
+type CustomerCourse struct {
+	model.TaCustomerCourse `xorm:"extends"`
+	CourseImg              string
+	QrCodeString           string
+	OrdersNo               string
+	Details                []model.TaCustomerCourseDetail
+}
+
+// GetCustomerCourse 获取我的课程信息
+func (m *CourseDAO) GetCustomerCourse(custID string, page, pageSize int) ([]CustomerCourse, error) {
+	var courses []CustomerCourse
+	sql := `select a.*,a.customer_course_id as qr_code_string,b.orders_no,c.course_img from ta_customer_course a 
+	inner join ta_course c on a.course_id=c.course_id
+	left join ta_course_orders b on a.source_id=b.orders_id
+	 where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.customer_id='` + custID + `'`
+	sql += ` order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
+	err := m.db.Sql(sql).Find(&courses)
+	if err != nil {
+		return nil, err
+	}
+	for inx, course := range courses {
+		details, err := m.GetCustomerCourseDetail(course.CustomerCourseId)
+		if err != nil {
+			return nil, err
+		}
+		courses[inx].Details = details
+	}
+	return courses, nil
+}
+
+// GetCustomerCourseCount 获取我的课程总数
+func (m *CourseDAO) GetCustomerCourseCount(custID string) (int, error) {
+	var courses []model.TaCustomerCourse
+	err := m.db.Where("status>"+strconv.Itoa(models.STATUS_DEL)).And("customer_id=?", custID).Find(&courses)
+	if err != nil {
+		return 0, err
+	}
+	return len(courses), nil
+}
+
+// GetCustomerCourseDetail 获取我的课程明细
+func (m *CourseDAO) GetCustomerCourseDetail(customerCourseID string) ([]model.TaCustomerCourseDetail, error) {
+	var details []model.TaCustomerCourseDetail
+	err := m.db.Where("customer_course_id=?", customerCourseID).And(`status>` + strconv.Itoa(models.STATUS_DEL)).Find(&details)
+	return details, err
+}
+
+// GetCustomerCourseByID 获取我的课程信息明细
+func (m *CourseDAO) GetCustomerCourseByID(id string) (*CustomerCourse, error) {
+	var courses []CustomerCourse
+	sql := `select a.*,a.customer_course_id as qr_code_string,b.orders_no,c.course_img from ta_customer_course a 
+	inner join ta_course c on a.course_id=c.course_id
+	left join ta_course_orders b on a.source_id=b.orders_id
+	 where a.status>` + strconv.Itoa(models.STATUS_DEL) + ` and a.customer_course_id='` + id + `'`
+
+	err := m.db.Sql(sql).Find(&courses)
+	if err != nil {
+		return nil, err
+	}
+	if len(courses) > 0 {
+		details, err := m.GetCustomerCourseDetail(courses[0].CustomerCourseId)
+		if err != nil {
+			return nil, err
+		}
+		courses[0].Details = details
+		return &courses[0], nil
+	}
+
+	return nil, nil
+}

models/course/order.go

 
 // SaveCourseOrder 保存订单
 func (m *CourseDAO) SaveCourseOrder(order *model.TaCourseOrders) error {
-	order.OrdersId = guid.NewGUIDString()
+
+	if order.OrdersId == "" {
+		order.OrdersId = guid.NewGUIDString()
+	}
+
 	// 当前订单号的随机方式 = 时间 + 个人ID
-	order.OrdersNo = "C-" + time.Now().Local().Format("20060102150405") + "-" + strings.Join(utils.GUIID2IntString(order.CustomerId), "")
+	ordersno := "C-" + time.Now().Local().Format("20060102150405") + "-" + strings.Join(utils.GUIID2IntString(order.CustomerId), "")
+	order.OrdersNo = string([]byte(ordersno)[:32])
 	order.CreateDate = time.Now()
 	_, err := m.db.Insert(order)
 	return err

models/customer/account.go

 
 		accAmount -= moenyCheng
 		accPoints -= points
+	} else {
+		accAmount += moenyCheng
+		accPoints += points
 	}
 
 	// 账户不能为负

models/customer/customer.go

 		return nil, nil
 	}
 
-	if len(custs) > 0 {
+	if len(custs) > 1 {
 		return nil, errors.New("数据异常, 一个手机绑定了多个用户")
 	}
 

models/goods/goods.go

 	}
 
 	for inx, goods := range goodsList {
+		imgs, err := m.GetGoodsImgByGoodsID(goods.GoodsId)
+		if err != nil {
+			return nil, err
+		}
+		goodsList[inx].Images = imgs
+
 		specs, err := m.GetSpecWithPrice(goods.GoodsId)
 		if err != nil {
 			return nil, err

models/goods/orders.go

 		return err
 	}
 
-	order.OrdersId = guid.NewGUIDString()
+	// order.OrdersId = guid.NewGUIDString()
 	order.OrgId = caseInfo.OrgId
 	order.CreateDate = time.Now().Local()
 	order.Status = models.STATUS_NORMAL
 	order.CouponAmount = "0"
 
 	// 当前订单号的随机方式 = 时间 + 个人ID
-	order.OrdersNo = "G-" + time.Now().Local().Format("20060102150405") + "-" + strings.Join(utils.GUIID2IntString(order.UserId), "")
-
+	ordersno := "G-" + time.Now().Local().Format("20060102150405") + "-" + strings.Join(utils.GUIID2IntString(order.UserId), "")
+	order.OrdersNo = string([]byte(ordersno)[:32])
 	if _, err := m.db.Insert(order); err != nil {
 		utils.LogError("保存订单主记录失败: " + err.Error())
 
 // SaveOrdersDetail 保存订单明细
 func (m *GoodsDAO) SaveOrdersDetail(list []model.TaGoodsOrdersDetail, ordersID string) error {
 	for inx := range list {
+		list[inx].DetailId = guid.NewGUIDString()
 		list[inx].OrdersId = ordersID
 	}
 
 func (m *GoodsDAO) GetOrdersByCaseID(caseID, userType string, makeStatus []string, orderDate []time.Time, limit []int) ([]OrdersWithGoods, int64, error) {
 	var orderList []OrdersWithGoods
 
-	query := "select * from ta_goods_orders where case_id = ? and status = ?"
+	query := "select a.*,b.area_icon,b.area_icon_white from ta_goods_orders a inner join sys_case_area b on a.area_id=b.area_id where a.case_id = ? and a.status = ?"
 
 	// 制作状态
 	if makeStatus != nil && len(makeStatus) > 0 {
-		query += ` and make_status in ('` + strings.Join(makeStatus, "','") + `')`
+		query += ` and a.make_status in ('` + strings.Join(makeStatus, "','") + `')`
 	}
 
 	// 用户类型
 	if userType != "" {
-		query += ` and user_type = '` + userType + `'`
+		query += ` and a.user_type = '` + userType + `'`
 	}
 
 	// 订单起始时间
 	if orderDate != nil && len(orderDate) > 0 {
-		query += ` and DATE_FORMAT(create_date, '%Y-%m-%d %H:%i') >= '` + orderDate[0].Format("2006-01-02 15:04") + `'`
+		query += ` and DATE_FORMAT(a.create_date, '%Y-%m-%d %H:%i') >= '` + orderDate[0].Format("2006-01-02 15:04") + `'`
 
 		if len(orderDate) > 1 {
-			query += ` and DATE_FORMAT(create_date, '%Y-%m-%d %H:%i') <= '` + orderDate[1].Format("2006-01-02 15:04") + `'`
+			query += ` and DATE_FORMAT(a.create_date, '%Y-%m-%d %H:%i') <= '` + orderDate[1].Format("2006-01-02 15:04") + `'`
 		}
 	}
 
-	query += " order by create_date asc"
+	query += " order by a.create_date asc"
 
 	var cnt int64
 	if limit != nil && len(limit) > 1 {
 // GetOrdersByRecord 根据
 func (m *GoodsDAO) GetOrdersByRecord(recordid string) ([]OrdersWithGoods, error) {
 	var orderList []OrdersWithGoods
-	sql := `select a.* from ta_goods_orders a inner join sys_case_record b on a.case_id=b.case_id and date_format(a.create_date,'%Y-%m')=b.month where b.record_id='` + recordid +
-		`' and a.user_type='` + USERTPE_SALES + `' and b.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and a.status=` + strconv.Itoa(models.STATUS_NORMAL)
+	sql := `select a.*, c.case_name from ta_goods_orders a inner join sys_case_record b on a.case_id=b.case_id and date_format(a.create_date,'%Y-%m')=b.month
+	inner join sys_case c on a.case_id=c.case_id
+	where b.record_id='` + recordid +
+		`' and a.user_type != '` + USERTYPE_CUSTOMER + `' and b.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and a.status=` + strconv.Itoa(models.STATUS_NORMAL)
 	err := m.db.Sql(sql).Find(&orderList)
 	if err != nil {
 		return nil, err
 	}
 	return orderList, nil
 }
+
+// GetCustomerOrders 获取用户订单
+func (m *GoodsDAO) GetCustomerOrders(custID string, page, pageSize int) ([]OrdersWithGoods, error) {
+	var orderList []OrdersWithGoods
+	sql := `select a.*, c.case_name from ta_goods_orders a 
+	inner join sys_case c on a.case_id=c.case_id
+	where a.user_id='` + custID +
+		`' and c.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and a.status=` + strconv.Itoa(models.STATUS_NORMAL)
+	sql += ` order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
+	err := m.db.Sql(sql).Find(&orderList)
+	if err != nil {
+		return nil, err
+	}
+	for i, o := range orderList {
+		details, err := m.GetOrderDetailByOrder(o.OrdersId)
+		if err != nil {
+			return nil, err
+		}
+		orderList[i].Goods = details
+	}
+	return orderList, nil
+}
+
+// GetCustomerOrdersCount 获取用户订单count
+func (m *GoodsDAO) GetCustomerOrdersCount(custID string) (int, error) {
+	var orderList []OrdersWithGoods
+	sql := `select a.*, c.case_name from ta_goods_orders a 
+	inner join sys_case c on a.case_id=c.case_id
+	where a.user_id='` + custID +
+		`' and c.status=` + strconv.Itoa(models.STATUS_NORMAL) + ` and a.status=` + strconv.Itoa(models.STATUS_NORMAL)
+	err := m.db.Sql(sql).Find(&orderList)
+	if err != nil {
+		return 0, err
+	}
+	return len(orderList), nil
+}
+
+// GetOrdersCountByCase 根据案场获取订单信息
+func (m *GoodsDAO) GetOrdersCountByCase(caseid string) (int64, error) {
+	order := new(model.TaGoodsOrders)
+	total, err := m.db.Where("case_id = ?", caseid).And("status>"+strconv.Itoa(models.STATUS_DEL)).SumInt(order, "orders_num")
+	return total, err
+}
+
+// GetMonthOrdersCountByCase 获取案场本月的订单数量
+func (m *GoodsDAO) GetMonthOrdersCountByCase(caseid string) (int64, error) {
+	order := new(model.TaGoodsOrders)
+	total, err := m.db.Where("case_id = ?", caseid).And("status>"+strconv.Itoa(models.STATUS_DEL)).And("date_format(create_date,'%Y-%m')=date_format(NOW(),'%Y-%m')").SumInt(order, "orders_num")
+	return total, err
+}
+
+// UpdateOrdersMake 更新订单制作状态
+func (m *GoodsDAO) UpdateOrdersMake(orders model.TaGoodsOrders) error {
+	cols := []string{
+		"make_status",
+	}
+	_, err := m.db.Cols(cols...).Where("orders_id=?", orders.OrdersId).Update(orders)
+	return err
+}

models/goods/types.go

 // OrdersWithGoods 订单列表
 type OrdersWithGoods struct {
 	model.TaGoodsOrders `xorm:"extends"`
+	CaseName            string
+	AreaIcon            string
+	AreaIconWhite       string
 	Goods               []DetailWithType
 }

models/gymcard/gymcard.go

 		db:  ctx.DB,
 	}
 }
-func (m *GymcardDAO) GetGymcard(caseid string, page, pageSize int) ([]model.TaGymCard, error) {
-	var gymcard []model.TaGymCard
-	sql := `select a.* from ta_gym_card a
+
+type CustomerGym struct {
+	model.TaCustomerGym `xorm:"extends"`
+	CardImageUrl        string
+	CardShareInfo       string
+	CardUseInstruction  string
+	CardUseRule         string
+}
+
+type Gymcard struct {
+	model.TaGymCard    `xorm:"extends"`
+	CardImageUrl       string
+	CardShareInfo      string
+	CardUseInstruction string
+	CardUseRule        string
+}
+
+// GetGymcard 根据案场id获取游泳健身卡列表
+func (m *GymcardDAO) GetGymcard(caseid string, page, pageSize int) ([]Gymcard, error) {
+	var gymcard []Gymcard
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_gym_card a
+	INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+	INNER JOIN ta_card_share c ON a.gym_card_id = c.gym_card_id
 	where a.case_id in('` + strings.Replace(caseid, ",", "','", -1) + `')
 	and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
 	sql += ` order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
 	return gymcard, err
 }
 
-func (m *GymcardDAO) GetGymcardById(gymcardId string) (*model.TaGymCard, error) {
-	var gymcard []model.TaGymCard
-	err := m.db.Where("gym_card_id=?", gymcardId).And("status > ?", models.STATUS_DEL).Find(&gymcard)
+// GetGymcardCount 根据案场id获取游泳健身卡数量
+func (m *GymcardDAO) GetGymcardCount(caseid string) (int, error) {
+	var gymcard []Gymcard
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_gym_card a
+	INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+	INNER JOIN ta_card_share c ON a.gym_card_id = c.gym_card_id
+	where a.case_id in('` + strings.Replace(caseid, ",", "','", -1) + `')
+	and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&gymcard)
+	return len(gymcard), err
+}
+
+// GetGymcardById 根据id获取游泳健身卡详情
+func (m *GymcardDAO) GetGymcardById(gymcardId string) (*Gymcard, error) {
+	var gymcard []Gymcard
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_gym_card a
+	INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+	INNER JOIN ta_card_share c ON a.gym_card_id = c.gym_card_id
+	where a.gym_card_id = '` + gymcardId + `'
+	and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&gymcard)
 	if err != nil {
 		return nil, err
 	}
 	return nil, nil
 }
 
-func (m *GymcardDAO) AddGymCard(gymcard model.TaGymCard) (*model.TaGymCard, error) {
+// AddGymcard 新增游泳健身卡
+func (m *GymcardDAO) AddGymcard(gymcard model.TaGymCard) (model.TaGymCard, error) {
 	gymcard.GymCardId = utils.GetGUID()
 	gymcard.SentCount = 0
 	gymcard.UsedCount = 0
 	gymcard.Status = models.STATUS_NORMAL
 	gymcard.CreateDate = time.Now()
 	_, err := m.db.Insert(gymcard)
-	return &gymcard, err
+	return gymcard, err
+}
+
+// AddGymcardImg 新增游泳健身卡图片
+func (m *GymcardDAO) AddGymcardImg(gymcardId, imgUrl string) error {
+	var cardImg model.TaCardImage
+	cardImg.CardImageId = utils.GetGUID()
+	cardImg.CardImageUrl = imgUrl
+	cardImg.GymCardId = gymcardId
+	cardImg.Sort = 1
+	cardImg.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(cardImg)
+	return err
+}
+
+// AddGymcardShare 新增游泳健身卡分享信息
+func (m *GymcardDAO) AddGymcardShare(gymcardId, cardShareInfo, cardUseRule, cardUseInstraction string) error {
+	var cardShare model.TaCardShare
+	cardShare.CardShareId = utils.GetGUID()
+	cardShare.GymCardId = gymcardId
+	cardShare.CardShareInfo = cardShareInfo
+	cardShare.CardUseInstruction = cardUseInstraction
+	cardShare.CardUseRule = cardUseRule
+	cardShare.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(cardShare)
+	return err
 }
 
+// DeleteGymcard 删除游泳健身卡
 func (m *GymcardDAO) DeleteGymcard(gymcardId string) error {
 	var gymcard = model.TaGymCard{
 		GymCardId: gymcardId,
 	return err
 }
 
+// DeleteCardImg 删除健身卡图片
 func (m *GymcardDAO) DeleteCardImg(gymcardId string) error {
 	var cardImg = model.TaCardImage{
 		GymCardId: gymcardId,
 	return err
 
 }
+
+// DeleteCardImg 删除健身卡分享信息
+func (m *GymcardDAO) DeleteCardShare(gymcardId string) error {
+	var cardShare = model.TaCardShare{
+		GymCardId: gymcardId,
+		Status:    models.STATUS_DEL,
+	}
+	var cols = []string{
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("gym_card_id = ?", cardShare.GymCardId).Update(cardShare)
+	return err
+}
+
+// EditGymcardImg 修改健身卡图片
+func (m *GymcardDAO) EditGymcardImg(gymcardId, imgUrl string) error {
+	var cardImg = model.TaCardImage{
+		GymCardId:    gymcardId,
+		CardImageUrl: imgUrl,
+	}
+	var cols = []string{
+		"img_url",
+	}
+	_, err := m.db.Cols(cols...).Where("gym_card_id = ?", cardImg.GymCardId).Update(cardImg)
+	return err
+}
+
+// EditGymcardShare 修改健身卡分享信息
+func (m *GymcardDAO) EditGymcardShare(gymcardId, cardShareInfo, cardUseRule, cardUseInstraction string) error {
+	var cardShare = model.TaCardShare{
+		GymCardId:          gymcardId,
+		CardShareInfo:      cardShareInfo,
+		CardUseRule:        cardUseRule,
+		CardUseInstruction: cardUseInstraction,
+	}
+	var cols = []string{
+		"card_share_info",
+		"card_use_rule",
+		"card_use_instruction",
+	}
+	_, err := m.db.Cols(cols...).Where("gym_card_id = ?", cardShare.GymCardId).Update(cardShare)
+	return err
+}
+
+// SendGymcardToCustomer 新增用户健身卡
+func (m *GymcardDAO) SendGymcardToCustomer(gymcard *model.TaGymCard, customerId string) (*model.TaCustomerGym, error) {
+	var customerGym model.TaCustomerGym
+	customerGym.CustomerGymId = utils.GetGUID()
+	customerGym.CaseId = gymcard.CaseId
+	customerGym.CustomerGymName = gymcard.GymCardName
+	customerGym.CustomerId = customerId
+	customerGym.EndDate = gymcard.EndDate
+	customerGym.GymCardId = gymcard.GymCardId
+	customerGym.GymType = gymcard.GymTypeId
+	customerGym.OrgId = gymcard.OrgId
+	customerGym.ReceiveDate = time.Now()
+	customerGym.StartDate = gymcard.StartDate
+	customerGym.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(customerGym)
+	return &customerGym, err
+}
+
+// UpdateCustomerGym 修改用户卡
+func (m *GymcardDAO) UpdateCustomerGym(customerGym model.TaCustomerGym) error {
+	var cols = []string{
+		"start_date",
+		"end_date",
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("customer_gym_id =?", customerGym.CustomerGymId).Update(customerGym)
+	return err
+}
+
+// AddGymcardUsage 新增用户健身卡使用记录
+func (m *GymcardDAO) AddGymcardUsage(customerGym model.TaCustomerGym) (*model.TaGymCardUsage, error) {
+	var gymcardUsage model.TaGymCardUsage
+	gymcardUsage.CustomerGymId = customerGym.CustomerGymId
+	gymcardUsage.GymCardUsageId = utils.GetGUID()
+	gymcardUsage.UseCaseId = customerGym.CaseId
+	gymcardUsage.UseDate = time.Now()
+	gymcardUsage.Status = models.STATUS_NORMAL
+	_, err := m.db.Insert(gymcardUsage)
+	return &gymcardUsage, err
+}
+
+// GetCustomerGymByCustomerId 通过用户id获取用户所有游泳健身卡
+func (m *GymcardDAO) GetCustomerGymByCustomerId(customerId string, page, pageSize int) ([]CustomerGym, error) {
+	var customerGym []CustomerGym
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_customer_gym a
+INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+INNER JOIN ta_card_share C oN a.gym_card_id = c.gym_card_id
+WHERE
+	a.customer_id = '` + customerId + `' and a.status >` + strconv.Itoa(models.STATUS_DEL)
+	sql += ` order by a.create_date desc limit ` + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
+	err := m.db.Sql(sql).Find(&customerGym)
+	return customerGym, err
+}
+
+// GetCustomerGymCountByCustomerId 通过用户id获取用户所有游泳健身卡数量
+func (m *GymcardDAO) GetCustomerGymCountByCustomerId(customerId string) (int, error) {
+	var customerGym []CustomerGym
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_customer_gym a
+INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+INNER JOIN ta_card_share C oN a.gym_card_id = c.gym_card_id
+WHERE
+	a.customer_id = '` + customerId + `' and a.status >` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&customerGym)
+	return len(customerGym), err
+
+}
+
+// GetCustomerGymById 根据id获取用户健身卡详情
+func (m *GymcardDAO) GetCustomerGymById(customerCardId string) (CustomerGym, error) {
+	var customerGym []CustomerGym
+	sql := `SELECT
+	a.*,
+	b.card_image_url,
+	c.card_share_info,
+	c.card_use_instruction,
+	c.card_use_rule
+FROM
+	ta_customer_gym a
+INNER JOIN ta_card_image b ON a.gym_card_id = b.gym_card_id
+INNER JOIN ta_card_share C oN a.gym_card_id = c.gym_card_id
+WHERE
+	a.customer_gym_id = '` + customerCardId + `' and a.status >` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql).Find(&customerGym)
+	return customerGym[0], err
+}

models/model/ta_card_image.go

 type TaCardImage struct {
 	CardImageId  string `xorm:"not null pk VARCHAR(64)"`
 	GymCardId    string `xorm:"VARCHAR(64)"`
-	CardId       string `xorm:"VARCHAR(64)"`
 	CardImageUrl string `xorm:"TEXT"`
 	Status       int    `xorm:"SMALLINT(6)"`
 	Sort         int    `xorm:"INT(11)"`

models/model/ta_card_share.go

 type TaCardShare struct {
 	CardShareId        string `xorm:"not null pk VARCHAR(64)"`
 	GymCardId          string `xorm:"VARCHAR(64)"`
-	CardId             string `xorm:"VARCHAR(64)"`
 	CardShareInfo      string `xorm:"TEXT"`
 	CardUseRule        string `xorm:"TEXT"`
 	CardUseInstruction string `xorm:"TEXT"`

models/model/ta_coupon_card2.go

-package model
-
-import (
-	"time"
-)
-
-type TaCouponCard2 struct {
-	CardId           string    `xorm:"not null pk VARCHAR(64)"`
-	CardTypeId       string    `xorm:"VARCHAR(64)"`
-	SendType         int       `xorm:"comment('0案场 1渠道') SMALLINT(6)"`
-	VideoUrl         string    `xorm:"TEXT"`
-	CoverUrl         string    `xorm:"TEXT"`
-	Price            float32   `xorm:"FLOAT(64)"`
-	StartDate        time.Time `xorm:"DATETIME"`
-	EndDate          time.Time `xorm:"DATETIME"`
-	ShareDescription string    `xorm:"VARCHAR(255)"`
-	RuleDescription  string    `xorm:"VARCHAR(400)"`
-	UseDescription   string    `xorm:"TEXT"`
-	TotalCount       int       `xorm:"INT(11)"`
-	SentCount        int       `xorm:"INT(11)"`
-	UsedCount        int       `xorm:"INT(11)"`
-	Status           int       `xorm:"comment('0未发布 1发布 2过期') SMALLINT(6)"`
-	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_coupon_card_target2.go

-package model
-
-type TaCouponCardTarget2 struct {
-	TargetId   string `xorm:"not null pk VARCHAR(64)"`
-	CardId     string `xorm:"VARCHAR(64)"`
-	TargetName string `xorm:"VARCHAR(255)"`
-}

models/model/ta_customer_gym.go

 	EndDate         time.Time `xorm:"DATETIME"`
 	Status          int       `xorm:"SMALLINT(6)"`
 	ReceiveDate     time.Time `xorm:"DATETIME"`
-	VerifyDate      time.Time `xorm:"DATETIME"`
 	GymType         string    `xorm:"VARCHAR(64)"`
 	CaseId          string    `xorm:"VARCHAR(64)"`
 	OrgId           string    `xorm:"VARCHAR(64)"`

models/model/ta_gym_card.go

 )
 
 type TaGymCard struct {
-	GymCardId        string    `xorm:"not null pk VARCHAR(64)"`
-	GymTypeId        string    `xorm:"VARCHAR(64)"`
-	GymCardName      string    `xorm:"VARCHAR(128)"`
-	Price            float32   `xorm:"FLOAT(8,2)"`
-	VideoUrl         string    `xorm:"TEXT"`
-	CoverUrl         string    `xorm:"TEXT"`
-	SentType         int       `xorm:"comment('0案场 1渠道') SMALLINT(6)"`
-	StartDate        time.Time `xorm:"DATETIME"`
-	EndDate          time.Time `xorm:"DATETIME"`
-	ValidDays        int       `xorm:"INT(11)"`
-	ShareDescription string    `xorm:"VARCHAR(255)"`
-	RuleDescription  string    `xorm:"VARCHAR(255)"`
-	UseDescription   string    `xorm:"TEXT"`
-	TotalCount       int       `xorm:"INT(11)"`
-	SentCount        int       `xorm:"INT(11)"`
-	UsedCount        int       `xorm:"INT(11)"`
-	Status           int       `xorm:"comment('0未发布 1已发布 2已过期') SMALLINT(6)"`
-	CaseId           string    `xorm:"VARCHAR(64)"`
-	OrgId            string    `xorm:"VARCHAR(64)"`
-	CreateDate       time.Time `xorm:"DATETIME"`
+	GymCardId   string    `xorm:"not null pk VARCHAR(64)"`
+	GymTypeId   string    `xorm:"VARCHAR(64)"`
+	GymCardName string    `xorm:"VARCHAR(128)"`
+	Price       float32   `xorm:"FLOAT(8,2)"`
+	SentType    int       `xorm:"comment('0案场 1渠道') SMALLINT(6)"`
+	StartDate   time.Time `xorm:"DATETIME"`
+	EndDate     time.Time `xorm:"DATETIME"`
+	ValidDays   int       `xorm:"INT(11)"`
+	TotalCount  int       `xorm:"INT(11)"`
+	SentCount   int       `xorm:"INT(11)"`
+	UsedCount   int       `xorm:"INT(11)"`
+	Status      int       `xorm:"comment('0未发布 1已发布 2已过期') SMALLINT(6)"`
+	CaseId      string    `xorm:"VARCHAR(64)"`
+	OrgId       string    `xorm:"VARCHAR(64)"`
+	CreateDate  time.Time `xorm:"DATETIME"`
 }

models/model/ta_vip_card_child.go

 	VipCardChildCode string    `xorm:"VARCHAR(255)"`
 	Status           int       `xorm:"SMALLINT(6)"`
 	CustomerId       string    `xorm:"VARCHAR(64)"`
-	CustomerTel      string    `xorm:"DECIMAL(13)"`
+	CustomerTel      string    `xorm:"VARCHAR(50)"`
 	CreateDate       time.Time `xorm:"DATETIME"`
 	ActiveDate       time.Time `xorm:"DATETIME"`
+	Amount           string    `xorm:"DECIMAL(8,2)"`
+	SalesId          string    `xorm:"VARCHAR(64)"`
+	SalesName        string    `xorm:"VARCHAR(50)"`
 }

models/model/td_coupon_card_type.go → models/model/td_coupon_type.go

 package model
 
-type TdCouponCardType struct {
+type TdCouponType struct {
 	CouponTypeId   string `xorm:"not null pk VARCHAR(64)"`
 	CouponTypeName string `xorm:"VARCHAR(128)"`
 	OrgId          string `xorm:"VARCHAR(64)"`

models/system/role.go

 }
 
 // GetRoleCount 获取角色总数
-func (m *RoleDAO) GetRoleCount(caseids, name, caseid string) (int, error) {
+func (m *RoleDAO) GetRoleCount(name string) (int, error) {
 	var roles []model.SysRole
-	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL))
 	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, name, caseid string, page int, pageSize int) ([]model.SysRole, error) {
+func (m *RoleDAO) GetRoleList(name string, page int, pageSize int) ([]model.SysRole, error) {
 	var roles []model.SysRole
-	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL)).And("case_id in ('" + strings.Replace(caseids, ",", "','", -1) + "')")
+	dao := m.db.Where("status>" + strconv.Itoa(models.STATUS_DEL))
 	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
 }

models/system/user.go

 	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 
+		group by a.user_id) c on user.user_id = c.user_id where user.user_id != '0' and
 		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user.user_id in 
 		(select user_id from sys_user_case where case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')))`
 
 	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 
+		group by a.user_id) c on user.user_id = c.user_id where user.user_id != '0' and
 		(status> ` + strconv.Itoa(models.STATUS_DEL) + ` and user_name like '%` + username + `%' and user.user_id in 
 		(select user_id from sys_user_case where case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')))`
 

models/verify/verify.go

 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strconv"
+	"strings"
 
 	"github.com/go-xorm/xorm"
 )
 }
 
 // GetCustomerCourseList 根据我的课程id获取我的课程详情
-func (m *VerifyDAO) GetCustomerCourseList(customerCourseId, caseid string, page int, pageSize int) ([]MyCourse, error) {
+func (m *VerifyDAO) GetCustomerCourseList(customerCourseId, caseids string, page int, pageSize int) ([]MyCourse, error) {
 	var courseList []MyCourse
 	sql := `SELECT
 	a.*,
 	LEFT JOIN td_cms_image_location f on b.location_id=f.location_id
 	WHERE DATE_FORMAT(a.start_date,'%Y-%m-%d') = DATE_FORMAT(NOW(),'%Y-%m-%d')
 	AND a.customer_course_id = '` + customerCourseId + `'
-	and b.case_id = '` + caseid + `'`
+	and b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')`
 	sql = sql + " limit " + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
 	err := m.db.Sql(sql).Find(&courseList)
 	return courseList, err
 }
 
 // GetCustomerCourseListCount 根据我的课程id获取我的课程详情数量
-func (m *VerifyDAO) GetCustomerCourseListCount(customerCourseId, caseid string) (int, error) {
+func (m *VerifyDAO) GetCustomerCourseListCount(customerCourseId, caseids string) (int, error) {
 	var courseList []MyCourse
 	sql := `SELECT
 	a.*,
 	INNER JOIN sys_case d ON d.case_id = a.case_id
 	WHERE DATE_FORMAT(a.start_date,'%Y-%m-%d') = DATE_FORMAT(NOW(),'%Y-%m-%d')
 	AND a.customer_course_id = '` + customerCourseId + `'
-	and b.case_id = '` + caseid + `'`
+	and b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')`
 	err := m.db.Sql(sql).Find(&courseList)
 	return len(courseList), err
 }
 }
 
 // GetCustomerCourseListByTel 根据客户电话获取我的课程详情
-func (m *VerifyDAO) GetCustomerCourseListByTel(tel, caseid string, page, pageSize int) ([]MyCourse, error) {
+func (m *VerifyDAO) GetCustomerCourseListByTel(tel, caseids string, page, pageSize int) ([]MyCourse, error) {
 	var courseList []MyCourse
 	sql := `SELECT
 	a.*,
 	d.case_name,
 	b.course_name,
 	c.detail_name,
-<<<<<<< HEAD
-	f.location_name,
-	b.customer_id
-=======
 	b.customer_id,
 	f.location_name
->>>>>>> 802c15c146846cf0ddc7fc7e0273f2683cea90f4
 	FROM
 	ta_customer_course_detail a
 	INNER JOIN ta_customer_course b ON a.customer_course_id = b.customer_course_id
 	LEFT JOIN td_cms_image_location f on b.location_id=f.location_id
 	WHERE DATE_FORMAT(a.start_date,'%Y-%m-%d') = DATE_FORMAT(NOW(),'%Y-%m-%d')
 	AND e.phone = '` + tel + `'
-	and b.case_id='` + caseid + `'`
+	and b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')`
 	sql = sql + " limit " + strconv.Itoa((page-1)*pageSize) + `, ` + strconv.Itoa(pageSize)
 
 	err := m.db.Sql(sql).Find(&courseList)
 }
 
 // GetCustomerCourseListByTelCount 根据客户电话获取我的课程详情数量
-func (m *VerifyDAO) GetCustomerCourseListByTelCount(tel, caseid string) (int, error) {
+func (m *VerifyDAO) GetCustomerCourseListByTelCount(tel, caseids string) (int, error) {
 	var courseList []MyCourse
 	sql := `SELECT
 	a.*,
 	INNER JOIN ta_customer e ON b.customer_id = e.customer_id
 	WHERE DATE_FORMAT(a.start_date,'%Y-%m-%d') = DATE_FORMAT(NOW(),'%Y-%m-%d')
 	AND e.phone = '` + tel + `'
-	and b.case_id='` + caseid + `'`
+	and b.case_id in ('` + strings.Replace(caseids, ",", "','", -1) + `')`
 	err := m.db.Sql(sql).Find(&courseList)
 	return len(courseList), err
 }

models/vipcard/vipcard.go

 }
 
 type VipChild struct {
-	model.TaVipCardChild `xorm:"extendes"`
-	CaesName             string
+	model.TaVipCardChild `xorm:"extends"`
+	CaseName             string
 	CustomerName         string
 }
 
 // GetVipCardList获取VIP卡列表
-func (m *VipcardDAO) GetVipCardList(caseid string, page int, pageSize int) ([]VipChild, error) {
+func (m *VipcardDAO) GetVipCardList(caseids, cardNo, sellerName, userName string, page int, pageSize int) ([]VipChild, error) {
 	var vipcards []VipChild
 	sql := `SELECT
 	vcc.*,
 	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
+	LEFT 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) + `') `
-	sql = sql + " order by vc.create_date desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa(pageSize)
+	vcc.status > ` + strconv.Itoa(models.STATUS_DEL) +
+		` AND sc.case_id IN ('` + strings.Replace(caseids, ",", "','", -1) + `') `
+
+	if cardNo != "" {
+		sql = sql + ` and vcc.vip_card_child_code like '%` + cardNo + `%'`
+	}
+
+	if sellerName != "" {
+		sql = sql + ` and tc.recommend_name like '%` + sellerName + `%'`
+	}
+
+	if userName != "" {
+		sql = sql + ` and tc.customer_name like '%` + userName + `%'`
+	}
+	sql = sql + " order by vc.create_date, vip_card_child_code desc limit " + strconv.Itoa((page-1)*pageSize) + ", " + strconv.Itoa(pageSize)
 	err := m.db.Sql(sql).Find(&vipcards)
 	return vipcards, err
 }
 
-func (m *VipcardDAO) GetCardCount(caseid string) (int, error) {
+func (m *VipcardDAO) GetCardCount(caseids, cardNo, sellerName, userName string) (int, error) {
 	var vipcards []VipChild
 	sql := `SELECT
 	vcc.*,
 	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
+	LEFT 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) + `') `
+	vcc.status > ` + strconv.Itoa(models.STATUS_DEL) +
+		` AND sc.case_id IN('` + strings.Replace(caseids, ",", "','", -1) + `') `
+	if cardNo != "" {
+		sql = sql + ` and vcc.vip_card_child_code like '%` + cardNo + `%'`
+	}
+
+	if sellerName != "" {
+		sql = sql + ` and tc.recommend_name like '%` + sellerName + `%'`
+	}
+
+	if userName != "" {
+		sql = sql + ` and tc.customer_name like '%` + userName + `%'`
+	}
 	err := m.db.Sql(sql).Find(&vipcards)
 	return len(vipcards), err
 
 func (m *VipcardDAO) AddVipChildCard(vipChild model.TaVipCardChild) (*model.TaVipCardChild, error) {
 	vipChild.CreateDate = time.Now()
 	vipChild.VipCardChildId = utils.GetGUID()
-	vipChild.Status = models.STATUS_NORMAL
+	vipChild.Status = models.STATUS_READY
 	_, err := m.db.Insert(vipChild)
 	return &vipChild, err
 }
 		"customer_id",
 		"customer_tel",
 		"active_date",
+		"status",
+		"sales_id",
+		"sales_name",
 	}
 	_, err := m.db.Cols(cols...).Where("vip_card_child_id = ?", vipChild.VipCardChildId).Update(vipChild)
 	return err

npm-debug.log

+0 info it worked if it ends with ok
+1 verbose cli [ 'D:\\Application\\Node\\node.exe',
+1 verbose cli   'C:\\Users\\Administrator\\AppData\\Roaming\\npm\\node_modules\\npm\\bin\\npm-cli.js',
+1 verbose cli   'run',
+1 verbose cli   'build' ]
+2 info using npm@4.0.5
+3 info using node@v8.2.1
+4 verbose stack Error: ENOENT: no such file or directory, open 'E:\GoProject\src\spaceofcheng\services\package.json'
+5 verbose cwd E:\GoProject\src\spaceofcheng\services
+6 error Windows_NT 10.0.17134
+7 error argv "D:\\Application\\Node\\node.exe" "C:\\Users\\Administrator\\AppData\\Roaming\\npm\\node_modules\\npm\\bin\\npm-cli.js" "run" "build"
+8 error node v8.2.1
+9 error npm  v4.0.5
+10 error path E:\GoProject\src\spaceofcheng\services\package.json
+11 error code ENOENT
+12 error errno -4058
+13 error syscall open
+14 error enoent ENOENT: no such file or directory, open 'E:\GoProject\src\spaceofcheng\services\package.json'
+15 error enoent ENOENT: no such file or directory, open 'E:\GoProject\src\spaceofcheng\services\package.json'
+15 error enoent This is most likely not a problem with npm itself
+15 error enoent and is related to npm not being able to find a file.
+16 verbose exit [ -4058, true ]

routers/common.go

 		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("/user/tel/:tel", &user.UserController{}, "get:GetUserByTel"),
 
 		// 用户类型
 		beego.NSRouter("/usertype", &user.UserController{}, "get:GetUserTypes"),
 		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"),
+		beego.NSRouter("/case/conf/:caseid", &cases.CaseController{}, "get:GetCaseConf"),
+		beego.NSRouter("/case/open/:caseid", &cases.CaseController{}, "put:OpenCaseCoffee"),
+		beego.NSRouter("/case/close/:caseid", &cases.CaseController{}, "put:CloseCaseCoffee"),
 
 		// casekey 案场钥匙
 		beego.NSRouter("/case/key", &cases.CaseController{}, "get:GetKeyList"),
 
 		// vipcard VIP卡
 		beego.NSRouter("/vipcard", &vipcard.VipcardController{}, "get:GetVipList"),
+		beego.NSRouter("/vipcard/:code", &vipcard.VipcardController{}, "get:GetVipByCode"),
 		beego.NSRouter("/vipcard", &vipcard.VipcardController{}, "post:AddVipCard"),
 		beego.NSRouter("/vipcard/:vipCardChildCode", &vipcard.VipcardController{}, "put:UserCharge"),
 
 		beego.NSRouter("/order/online/goods", &goods.GoodsController{}, "get:GetOnlineOrder"),
 		beego.NSRouter("/order/goods/record/:recordid", &goods.GoodsController{}, "get:GetOrdersByRecord"),
 
+		beego.NSRouter("/order/goods/finish/:id", &goods.GoodsController{}, "put:FinishMake"),
+		beego.NSRouter("/order/goods/cancel/:id", &goods.GoodsController{}, "put:CancelMake"),
+
 		// 文件
 		beego.NSRouter("/file", &controllers.BaseController{}, "post:FileUpload"),
 
 		// 会员
 		beego.NSRouter("/customer", &customer.CustomerController{}, "get:CustWXList"),
+		beego.NSRouter("/customer/tel/:tel", &customer.CustomerController{}, "get:CustByTel"),
 
 		// 系统相关
 		beego.NSRouter("/system/init", &user.UserController{}, "get:GetEnvVars"),
 
 		// 签到
 		beego.NSRouter("/case/signin", &cases.SigninController{}, "get:GetSigninWhere"),
+
+		// websocket
+		beego.NSRouter("/websocket/:grps/:id", &controllers.BaseController{}, "get:Ws"),
 	)
 }

routers/guest.go

 		beego.NSRouter("/wxsignup", &customer.CustomerController{}, "post:SignUp"),
 
 		// 登录
-		beego.NSRouter("/signin", &user.UserController{}, "post:SignIn"))
+		beego.NSRouter("/signin", &user.UserController{}, "post:SignIn"),
+
+		beego.NSRouter("/websocket/:grps/:id", &controllers.BaseController{}, "get:Ws"),
+	)
 }

routers/wechat.go

 		// 下单
 		beego.NSRouter("/order/goods", &goods.GoodsController{}, "post:PostOrder"),
 		beego.NSRouter("/order/course", &course.CourseController{}, "post:PostOrder"),
+
+		// 课程
+		beego.NSRouter("/course/user", &course.CourseController{}, "get:GetCustomerCourse"),
+		beego.NSRouter("/course/user/:id", &course.CourseController{}, "get:GetCustomerCourseByID"),
+
+		// 商品订单
+		beego.NSRouter("/goods/user", &goods.GoodsController{}, "get:GetCustomerOrders"),
+
+		// 案场订单数量
+		beego.NSRouter("/goods/case/:caseid", &goods.GoodsController{}, "get:GetCaseOrdersNum"),
 	)
 }

service/cases/cases.go

 }
 
 const (
-	CONFTYPE_COFFEE = "coffee"
+	CONFTYPE_GOODS = "goods"
 )
 
 // GetCases 获取案场列表
 		// 新增案场配置信息
 		var conf = model.SysCaseConf{
 			CaseId:   newInfo.CaseId,
-			ConfType: CONFTYPE_COFFEE,
+			ConfType: CONFTYPE_GOODS,
 		}
 		_, err = s.dao.SaveCaseConf(conf)
 	} else {
 	}
 	return conf, nil
 }
+
+// UpdateCaseConf 修改案场配置信息
+func (s *CaseServ) UpdateCaseConf(caseid, conftype string, status int) error {
+	var conf = model.SysCaseConf{
+		CaseId:   caseid,
+		ConfType: conftype,
+		Status:   status,
+	}
+	err := s.dao.UpdateCaseConf(conf)
+	return err
+}

service/cases/key.go

 func (s *CaseServ) GetKeysByCase(caseid, num string, page, pageSize int) (map[string]interface{}, error) {
 	cases := s.ctx.Get("cases").([]model.SysUserCase)
 	isdict := false
-	for _, value := range cases {
-		if caseid == value.CaseId {
-			isdict = true
+	if caseid != "" {
+		for _, value := range cases {
+			if caseid == value.CaseId {
+				isdict = true
+			}
 		}
-	}
 
-	if !isdict {
-		return nil, utils.LogError("您没有该案场的权限！")
+		if !isdict {
+			return nil, utils.LogError("您没有该案场的权限！")
+		}
 	}
 
 	if pageSize == 0 {

service/cases/record.go

 
 import (
 	"errors"
+	"spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service"
 	"spaceofcheng/services/utils"
 	}
 	return newinfo, nil
 }
+
+// GetRecordByID 获取月记录信息
+func (s *CaseServ) GetRecordByID(recordid string) (*cases.CaseRecord, error) {
+	record, err := s.dao.GetRecordByID(recordid)
+	if err != nil {
+		utils.LogError("获取月记录失败: " + err.Error())
+		return nil, errors.New("获取月记录失败")
+	}
+	return record, nil
+}

service/course/course.go

 	if info.Status != course.STATUS_UNPUBLISH {
 		return utils.LogError("当前课程状态异常！请刷新后重试！")
 	}
+	// 获取课程已排课数量
+	num, err := s.dao.GetCourseDetailCount(courseid)
+	if err != nil {
+		utils.LogError("课程发布失败: " + err.Error())
+		return errors.New("课程发布失败")
+	}
+	if info.CourseNum > num {
+		return errors.New("请先进行排课，再发布课程！")
+	}
 	err = s.dao.CoursePublic(courseid)
 	if err != nil {
 		utils.LogError("课程发布失败: " + err.Error())
 }
 
 // GetCourseSchedule 获取课程排期
-func (s *CourseServ) GetCourseSchedule(name, caseids, date string, page, pageSize int) (map[string]interface{}, error) {
+func (s *CourseServ) GetCourseSchedule(name, caseids, courseid, date string, page, pageSize int) (map[string]interface{}, error) {
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
 	if date == "" {
 		return nil, utils.LogError("请先选择需要排课的日期！")
 	}
-	list, err := s.dao.GetCourseSchedule(name, caseids, date, page, pageSize)
+
+	list, err := s.dao.GetCourseSchedule(name, caseids, courseid, date, page, pageSize)
 	if err != nil {
 		utils.LogError("获取课程排期失败: " + err.Error())
 		return nil, errors.New("获取课程排期失败")
 	}
-	total, err := s.dao.GetCourseScheduleCount(name, caseids, date)
+	total, err := s.dao.GetCourseScheduleCount(name, caseids, courseid, date)
 	if err != nil {
 		utils.LogError("获取课程排期失败: " + err.Error())
 		return nil, errors.New("获取课程排期失败")
 }
 
 // GetDetails 获取所有排课
-func (s *CourseServ) GetDetails(caseid, date string) ([]course.DetailInfo, error) {
-	if caseid == "" {
+func (s *CourseServ) GetDetails(caseid, date, courseid string) ([]course.DetailInfo, error) {
+	if courseid == "" && caseid == "" {
 		return nil, utils.LogError("请先选择案场！")
 	}
 	if date == "" {
 		return nil, utils.LogError("请选择需要查看的月份！")
 	}
-	details, err := s.dao.GetDetails(caseid, date)
+	details, err := s.dao.GetDetails(caseid, date, courseid)
 	if err != nil {
 		utils.LogError("获取排期信息失败: " + err.Error())
 		return nil, errors.New("获取排期信息失败")
 	}
 	return list, err
 }
+
+// GetCustomerCourse 获取用户的课程信息
+func (s *CourseServ) GetCustomerCourse(page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	if page == 0 {
+		page = 1
+	}
+	cust := s.ctx.Get("customer").(model.TaCustomer)
+	list, err := s.dao.GetCustomerCourse(cust.CustomerId, page, pageSize)
+	if err != nil {
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
+	}
+	total, err := s.dao.GetCustomerCourseCount(cust.CustomerId)
+	if err != nil {
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
+	}
+
+	return map[string]interface{}{
+		"list":     list,
+		"pagesize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+
+// GetCustomerCourseByID 获取我的课程明细
+func (s *CourseServ) GetCustomerCourseByID(id string) (*course.CustomerCourse, error) {
+	info, err := s.dao.GetCustomerCourseByID(id)
+	if err != nil {
+		utils.LogError("获取课程信息失败: " + err.Error())
+		return nil, errors.New("获取课程信息失败")
+	}
+	return info, err
+}

service/course/order.go

 	cust := s.ctx.Get("customer").(model.TaCustomer)
 
 	// 校验人员
-	if cust.CustomerId != couseOrder.CustomerId {
-		return errors.New("下单人非当前人员")
-	}
+	couseOrder.CustomerId = cust.CustomerId
 	if cust.UserId != "" {
 		// 内部人员
 		// 如果是内部人员购买或者兑换课程, 卡券或者城币就从内部人员自己的账户走
 	if err != nil {
 		return err
 	}
-	if course.CourseDetail == nil || len(course.CourseDetail) > 0 {
+	if course.CourseDetail == nil || len(course.CourseDetail) == 0 {
 		return errors.New("定单课程尚未排课, 不能下单")
 	}
 
 		// TODO
 	}
 
-	// 课程价格, 即为订单价格
-	couseOrder.Price = course.Price
+	couseOrder.OrdersId = guid.NewGUIDString()
+	couseOrder.Price = course.Price // 课程价格, 即为订单价格
 	couseOrder.ActualAmount = course.Price
 	couseOrder.CourseName = course.CourseName
 	couseOrder.CourseNum = course.CourseNum
 	couseOrder.OrgId = org.OrgId
+	couseOrder.Status = models.STATUS_NORMAL
+
+	// 默认是已支付
+	couseOrder.IsPay = models.BOOL_TRUE
+
 	if cust.Name != "" {
 		couseOrder.CustomerName = cust.Name
 	} else {
 		return err
 	}
 
-	// 入库
-	if err := s.dao.SaveCourseOrder(couseOrder); err != nil {
-		utils.LogError("课程下单失败: " + err.Error())
-		return errors.New("下单失败, 请重试")
-	}
-
 	// 实际支付
 	actualAmount, _ := strconv.ParseFloat(couseOrder.ActualAmount, 64)
 
-	// 用户账户
+	// 用户账户  -- 内部人员也可以购买
 	if actualAmount > 0 {
 		couseOrder.PayType = models.CONSUME_COINCHG
 		account, err := s.custDAO.GetAccountByCust(cust.CustomerId)
 		if actualAmount > accMoney {
 			return errors.New("账户余额不足")
 		}
+
+		// 插入账户流水
+		if err := s.saveCustomerPayRec(account, couseOrder); err != nil {
+			utils.LogError("插入账户流水出错: " + err.Error())
+			return errors.New("写入账户流水出错")
+		}
+	}
+
+	// 入库
+	if err := s.SaveOrder(couseOrder, coupons, course); err != nil {
+		utils.LogError("课程下单失败: " + err.Error())
+		return errors.New("下单失败, 请重试")
 	}
 
 	return nil
 
 	// 默认城币购买
 	courseObtaimType := models.COURSE_GETBY_COINCHG
-	srcID := ""
 	if coupons != nil && len(coupons) > 0 {
 		for _, c := range coupons {
 			if c.CouponType == models.COURSE_COUPON_CARD {
 			} else if c.CouponType == models.COURSE_COUPON_COUPON {
 				courseObtaimType = models.COURSE_GETBY_COUPON
 			}
-
-			srcID = c.CouponId
 		}
 	}
 
 		JoinNum:          0,
 		CreateDate:       time.Now().Local(),
 		CourseObtaimType: courseObtaimType,
-		SourceId:         srcID,
+		SourceId:         order.OrdersId,
 		IsDone:           models.BOOL_FALSE,
 	}
 

service/customer/customer.go

 		}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
-		newCust, err := s.SaveNewCustomer(wxInfo, "", "", user.UserId)
+		newCust, err := s.SaveNewCustomer(wxInfo, "", "", user.Phone, user.UserId)
 		if err != nil {
 			utils.LogError(err.Error())
 			return nil, err
 		}
 
 		wxInfo := wxInfoRaw.(map[string]interface{})
-		newCust, err := s.SaveNewCustomer(wxInfo, caseID, userID, "")
+		newCust, err := s.SaveNewCustomer(wxInfo, caseID, userID, phone, "")
 		if err != nil {
 			utils.LogError(err.Error())
 			return nil, err
 }
 
 // SaveNewCustomer 新增客户
-func (s *CustomerServ) SaveNewCustomer(wxInfo map[string]interface{}, caseID, arID, userID string) (*model.TaCustomer, error) {
+func (s *CustomerServ) SaveNewCustomer(wxInfo map[string]interface{}, caseID, arID, phone, userID string) (*model.TaCustomer, error) {
 	if caseID == "" && arID == "" && userID == "" {
 		return nil, errors.New("新增信息失败, 无法确认人员类型")
 	}
 		sexInt = 1 // 默认男性
 	}
 
+	org := s.ctx.Get("org").(model.SysOrg)
+
 	cust := model.TaCustomer{
 		CustomerName: nickyName,
 		Name:         nickyName,
 		Sex:          sexInt,
 		Headimgurl:   headimgurl,
+		Phone:        phone,
+		OrgId:        org.OrgId,
 	}
 
 	// 校验案场信息
 
 	return &cust, nil
 }
+
+// GetCustUserByTel 根据电话查询用户信息
+func (s *CustomerServ) GetCustUserByTel(tel string) (*model.TaCustomer, error) {
+	customer, err := s.dao.GetCustomerByPhone(tel)
+	if err != nil {
+		return nil, err
+	}
+	return customer, nil
+}

service/goods/goods.go

 
 // GetGoodsListPageNavi 获取商品列表
 // 前端 - 非统计部分
-func (s *GoodsServ) GetGoodsListPageNavi(name, typeID, caseID string, page, pagesize int) ([]goods.GoodsWithSpec, int64, error) {
+func (s *GoodsServ) GetGoodsListPageNavi(name, typeID, caseids string, page, pagesize int) ([]goods.GoodsWithSpec, int64, error) {
 	if page < 1 {
 		page = 1
 	}
 
 	offset := (page - 1) * pagesize
 
-	res, cnt, err := s.dao.GetGoodsListPageNavi(strings.ToLower(name), typeID, caseID, []int{pagesize, offset})
+	res, cnt, err := s.dao.GetGoodsListPageNavi(strings.ToLower(name), typeID, caseids, []int{pagesize, offset})
 	if err != nil {
 		utils.LogError("获取商品列表失败: " + err.Error())
 		return nil, 0, errors.New("获取列表失败, 请重试")

service/goods/orders.go

 	"errors"
 	"math"
 	"spaceofcheng/services/models"
+	casemodel "spaceofcheng/services/models/cases"
 	"spaceofcheng/services/models/goods"
 	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+	"spaceofcheng/services/service/cases"
 	"spaceofcheng/services/utils"
 	"strconv"
 	"time"
+
+	"github.com/yl10/kit/guid"
 )
 
 // Orders 下单
 	info *model.TaGoodsOrders,
 	details []model.TaGoodsOrdersDetail,
 	coupons []model.TaGoodsOrdersCoupon) error {
+	// org := s.ctx.Get("org").(model.SysOrg)
+	cust := s.ctx.Get("customer").(model.TaCustomer)
+
+	info.OrdersId = guid.NewGUIDString()
+	info.MakeStatus = goods.MAKESTATUS_NOTSTARTED
+	info.UserId = cust.CustomerId
 
 	// 校验下单内容
 	if err := s.validOrdersInfo(info); err != nil {
 		return err
 	}
 
-	// 校验各种金额
-	if err := s.validBillCharges(info, details); err != nil {
-		return err
-	}
-
-	// 保存主订单
-	if err := s.dao.SaveOrders(info); err != nil {
+	// 校验案场信息
+	if err := s.validOrdersCase(info); err != nil {
 		return err
 	}
 
-	// 保存订单明细
-	if err := s.dao.SaveOrdersDetail(details, info.OrdersId); err != nil {
+	// 校验各种金额
+	if err := s.validBillCharges(info, details); err != nil {
 		return err
 	}
 
-	// 内部人员, 可以直接购买
 	if info.PayType == models.CONSUME_INNER {
-
+		// 内部人员, 可以直接购买
 		// TODO
-		// 通知后端有新订单 - websocket
-		// utils.SendMessage()
+	} else {
+		// 普通客户
 
-		return nil
-	}
+		account, err := s.custDAO.GetAccountByCust(info.UserId)
+		if err != nil {
+			utils.LogError("查询用户账户信息出错: " + err.Error())
+			return errors.New("查询用户账户信息出错")
+		}
 
-	account, err := s.custDAO.GetAccountByCust(info.UserId)
-	if err != nil {
-		utils.LogError("查询用户账户信息出错: " + err.Error())
-		return errors.New("查询用户账户信息出错")
-	}
+		// 如果是使用优惠券
+		if coupons != nil && len(coupons) > 0 {
+			info.PayType = models.CONSUME_COUPON
+
+			// TODO
+			// 校验优惠券相关
+			// 优惠券默认抵消全部金额
+			info.ActualAmount = "0.0"
+		} else {
+			// 如果是使用城币
+			info.PayType = models.CONSUME_COINCHG
+			accMoney, _ := strconv.ParseFloat(account.Amount, 64)
+			payMoney, _ := strconv.ParseFloat(info.Amount, 64)
+
+			if accMoney < payMoney {
+				return errors.New("账户余额不足")
+			}
 
-	// 如果是使用优惠券
-	if coupons != nil && len(coupons) > 0 {
-		info.PayType = models.CONSUME_COUPON
-		// TODO
-		// 校验优惠券相关
-	} else {
-		// 如果是使用城币
-		info.PayType = models.CONSUME_COINCHG
-		accMoney, _ := strconv.ParseFloat(account.Amount, 64)
-		payMoney, _ := strconv.ParseFloat(info.ActualAmount, 64)
+			info.ActualAmount = strconv.FormatFloat(payMoney, 'f', -1, 64)
+		}
+
+		// 保存优惠券使用记录
+		if coupons != nil && len(coupons) > 0 {
+			if err := s.dao.SaveOrdersCoupon(coupons, info); err != nil {
+				utils.LogError("保存优惠信息出错: " + err.Error())
+				return errors.New("保存优惠信息出错")
+			}
 
-		if accMoney < payMoney {
-			return errors.New("账户余额不足")
+			// TODO
+			// 核销优惠券
 		}
-	}
 
-	// 保存优惠券使用记录
-	if coupons != nil && len(coupons) > 0 {
-		if err := s.dao.SaveOrdersCoupon(coupons, info); err != nil {
-			utils.LogError("保存优惠信息出错: " + err.Error())
-			return errors.New("保存优惠信息出错")
+		// 如果是城币, 则插入用户账户消费记录
+		if info.PayType == models.CONSUME_COINCHG {
+			if err := s.saveCustomerPayRec(account, info); err != nil {
+				return err
+			}
 		}
+	}
 
-		// TODO
-		// 核销优惠券
+	// 保存主订单
+	if err := s.dao.SaveOrders(info); err != nil {
+		return err
 	}
 
-	// 如果是城币, 则插入用户账户消费记录
-	if info.PayType == models.CONSUME_COINCHG {
-		if err := s.saveCustomerPayRec(account, info); err != nil {
-			return err
-		}
+	// 保存订单明细
+	if err := s.dao.SaveOrdersDetail(details, info.OrdersId); err != nil {
+		return err
 	}
 
-	// TODO
 	// 通知后端有新订单 - websocket
-	// utils.SendMessage()
+	orderList, err := s.GetOnLineOrders(info.CaseId, false)
+	if err != nil {
+		utils.LogError("获取新单列表出错: " + err.Error())
+		return nil
+	}
+
+	msg := utils.Message{
+		To: utils.ClientID{
+			Groups: []string{info.CaseId},
+		},
+		Data: map[string]interface{}{
+			"refreshOnlineGoodsOrders": orderList,
+		},
+	}
+
+	utils.SendMessage(msg, utils.WsMessage)
 
 	return nil
 }
 		return errors.New("下单人状态不正确, 不能下单")
 	}
 
+	info.UserType = models.USERTYPE_CUSTOMER
+
 	// 如果是管理人员
 	if cust.UserId != "" {
 		// 内部人员
 
 	goodsAmount := float64(0.0)
 	for _, item := range details {
-		goods, err := s.dao.GetGoodsWithPriceByID(item.GoodsId, item.SpecId, caseID)
-		if err != nil {
-			utils.LogError("查询商品详情失败: " + err.Error())
-			return errors.New("校验商品信息失败")
+
+		var price float64
+		var goodsPrice float64
+
+		price, _ = strconv.ParseFloat(item.Price, 64)
+
+		// 商品无规格
+		if item.SpecId == "" {
+			goods, err := s.dao.GetGoodsByID(item.GoodsId)
+			if err != nil {
+				utils.LogError("查询商品详情失败: " + err.Error())
+				return errors.New("校验商品信息失败")
+			}
+
+			goodsPrice, _ = strconv.ParseFloat(goods.Price, 64)
+		} else {
+			goods, err := s.dao.GetGoodsWithPriceByID(item.GoodsId, item.SpecId, caseID)
+			if err != nil {
+				utils.LogError("查询商品详情失败: " + err.Error())
+				return errors.New("校验商品信息失败")
+			}
+
+			goodsPrice, _ = strconv.ParseFloat(goods.GoodsPrice, 64)
 		}
 
-		if goods.GoodsPrice != item.Price {
+		if math.Abs(price-goodsPrice) > 0.00001 {
 			return errors.New("商品金额计算错误")
 		}
 
 		// TODO 校验库存
 		// 商品暂时无库存
 
-		price, _ := strconv.ParseFloat(item.Price, 64)
 		goodsAmount += price * float64(item.Number)
 	}
 
 		return errors.New("商品金额计算错误")
 	}
 
+	// TODO
+	// 暂时实际支付为 0
+	info.ActualAmount = "0.0"
+
 	return nil
 }
 
 
 // GetOnLineOrders 获取订单列表
 // 管理端 - 在线订单
-func (s *GoodsServ) GetOnLineOrders(caseID string) ([]goods.OrdersWithGoods, error) {
-	if err := utils.NewAuthEngine(s.ctx).CheckCase(caseID); err != nil {
-		return nil, err
+func (s *GoodsServ) GetOnLineOrders(caseID string, checkRights ...bool) ([]goods.OrdersWithGoods, error) {
+	needRights := true
+	if checkRights != nil && len(checkRights) > 0 {
+		needRights = checkRights[0]
+	}
+
+	if needRights {
+		if err := utils.NewAuthEngine(s.ctx).CheckCase(caseID); err != nil {
+			return nil, err
+		}
 	}
 
 	makeStatus := []string{goods.MAKESTATUS_NOTSTARTED, goods.MAKESTATUS_DOING}
 	}
 	return orders, nil
 }
+
+// validOrdersCase 校验案场信息
+func (s *GoodsServ) validOrdersCase(info *model.TaGoodsOrders) error {
+	conf, err := s.caseDAO.GetConfByCase(info.CaseId, cases.CONFTYPE_GOODS)
+	if err != nil {
+		utils.LogError("获取配置信息失败： " + err.Error())
+		return errors.New("获取配置信息失败")
+	}
+
+	if conf == nil || conf.Status != models.STATUS_NORMAL {
+		return errors.New("当前案场已歇业！不允许下单！")
+	}
+
+	// 获取当月记录
+	record, err := s.caseDAO.GetRecordByCase(info.CaseId)
+	if err != nil {
+		utils.LogError("获取月记录失败: " + err.Error())
+		return errors.New("获取月记录失败")
+	}
+	if record != nil && record.IsOver == casemodel.ISNOOVER && record.LeftNum < info.OrdersNum {
+		return errors.New("超出案场限制的本月下单次数！不允许下单！")
+	}
+	return nil
+}
+
+// GetCustomerOrders 获取用户订单
+func (s *GoodsServ) GetCustomerOrders(page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	if page == 0 {
+		page = 1
+	}
+	cust := s.ctx.Get("customer").(model.TaCustomer)
+	list, err := s.dao.GetCustomerOrders(cust.CustomerId, page, pageSize)
+	if err != nil {
+		utils.LogError("获取订单信息失败: " + err.Error())
+		return nil, errors.New("获取订单信息失败")
+	}
+	total, err := s.dao.GetCustomerOrdersCount(cust.CustomerId)
+	if err != nil {
+		utils.LogError("获取订单信息失败: " + err.Error())
+		return nil, errors.New("获取订单信息失败")
+	}
+
+	return map[string]interface{}{
+		"list":     list,
+		"pagesize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+
+// GetCaseOrdersNum 获取案场订单数量
+func (s *GoodsServ) GetCaseOrdersNum(caseid string) (map[string]interface{}, error) {
+	total, err := s.dao.GetOrdersCountByCase(caseid)
+	if err != nil {
+		utils.LogError("获取案场订单数量失败: " + err.Error())
+		return nil, errors.New("获取案场信息失败")
+	}
+	monthtotal, err := s.dao.GetMonthOrdersCountByCase(caseid)
+	if err != nil {
+		utils.LogError("获取月案场订单数量失败: " + err.Error())
+		return nil, errors.New("获取案场信息失败")
+	}
+	return map[string]interface{}{
+		"total":      total,
+		"monthtotal": monthtotal,
+	}, nil
+}
+
+// FinishMake 完成制作
+func (s *GoodsServ) FinishMake(id string) error {
+	var orders = model.TaGoodsOrders{
+		OrdersId:   id,
+		MakeStatus: goods.MAKESTATUS_FINISHED,
+	}
+	err := s.dao.UpdateOrdersMake(orders)
+	return err
+}
+
+// CancelMake 取消制作
+func (s *GoodsServ) CancelMake(id string) error {
+	var orders = model.TaGoodsOrders{
+		OrdersId:   id,
+		MakeStatus: goods.MAKESTATUS_CANCEL,
+	}
+	err := s.dao.UpdateOrdersMake(orders)
+	return err
+}

service/gymcard/gymcard.go

+package gymcard
+
+import (
+	"errors"
+	"spaceofcheng/services/models/gymcard"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service"
+	"spaceofcheng/services/utils"
+)
+
+// GymcardServ 系统处理
+type GymcardServ struct {
+	ctx *utils.Context
+	dao *gymcard.GymcardDAO
+}
+
+// NewGymcardServ 初始化
+func NewGymcardServ(ctx *utils.Context) *GymcardServ {
+	return &GymcardServ{
+		ctx: ctx,
+		dao: gymcard.NewGymcardDAO(ctx),
+	}
+}
+func (s *GymcardServ) GetGymcardList(caseid string, page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	gymcard, err := s.dao.GetGymcard(caseid, page, pageSize)
+	if err != nil {
+		utils.LogError("获取健身卡列表失败：" + err.Error())
+		return nil, errors.New("获取健身卡列表失败")
+	}
+	total, err := s.dao.GetGymcardCount(caseid)
+	if err != nil {
+		utils.LogError("获取健身卡列表失败：" + err.Error())
+		return nil, errors.New("获取健身卡列表失败")
+	}
+	return map[string]interface{}{
+		"list":     gymcard,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+func (s *GymcardServ) GetCustomerGymBycustomerId(customerId string, page, pageSize int) (map[string]interface{}, error) {
+	if pageSize == 0 {
+		pageSize = service.PAGENUM
+	}
+	customerGym, err := s.dao.GetCustomerGymByCustomerId(customerId, page, pageSize)
+	if err != nil {
+		utils.LogError("获取健身卡列表失败：" + err.Error())
+		return nil, errors.New("获取健身卡列表失败")
+	}
+	total, err := s.dao.GetCustomerGymCountByCustomerId(customerId)
+	if err != nil {
+		utils.LogError("获取健身卡列表失败：" + err.Error())
+		return nil, errors.New("获取健身卡列表失败")
+	}
+	return map[string]interface{}{
+		"list":     customerGym,
+		"pageSize": pageSize,
+		"pagenum":  total,
+		"page":     page,
+	}, nil
+}
+func (s *GymcardServ) GetGymcardDetailByIdZ(gymcardId string) (*gymcard.Gymcard, error) {
+	gymcard, err := s.dao.GetGymcardById(gymcardId)
+	if err != nil {
+		utils.LogError("获取健身卡详情失败" + err.Error())
+		return nil, errors.New("获取健身卡详情失败")
+	}
+	return gymcard, nil
+}
+
+func (s *GymcardServ) SaveGymcard(newGym gymcard.Gymcard) (*gymcard.Gymcard, error) {
+	var newGymCard model.TaGymCard
+	var cardGym model.TaGymCard
+	var err error
+	if newGym.GymCardId == "" {
+		newGymCard = newGym.TaGymCard
+		cardGym, err = s.dao.AddGymcard(newGymCard)
+		err = s.dao.AddGymcardImg(newGym.GymCardId, newGym.CardImageUrl)
+		newGym.TaGymCard = cardGym
+		err = s.dao.AddGymcardShare(newGym.GymCardId, newGym.CardShareInfo, newGym.CardUseRule, newGym.CardUseInstruction)
+	} else {
+		err = s.dao.EditGymcardImg(newGym.GymCardId, newGym.CardImageUrl)
+		err = s.dao.EditGymcardShare(newGym.GymCardId, newGym.CardShareInfo, newGym.CardUseRule, newGym.CardUseInstruction)
+	}
+	if err != nil {
+		utils.LogError("保存健身卡信息失败" + err.Error())
+		return nil, errors.New("保存健身卡信息失败")
+	}
+	return &newGym, nil
+}
+
+func (s *GymcardServ) SendGymCardToUser(customerId, gymcardId string) (*model.TaCustomerGym, error) {
+	var customerGym *model.TaCustomerGym
+	gymCard, err := s.dao.GetGymcardById(gymcardId)
+	if err != nil {
+		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+		return nil, errors.New("发送游泳健身卡给客户失败")
+	}
+	customerGym, err = s.dao.SendGymcardToCustomer(gymCard, customerId)
+	if err != nil {
+		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+		return nil, errors.New("发送游泳健身卡给客户失败")
+	}
+	return customerGym, nil
+
+}

service/message/cmscase.go

 	// }
 
 	if cmscase.CmsCaseId == "" {
+		org := s.ctx.Get("org").(model.SysOrg)
+		cmscase.OrgId = org.OrgId
 		newInfo, err = s.dao.AddCmsCase(cmscase)
 	} else {
 		err = s.dao.UpdateCmsCase(cmscase)

service/message/message.go

 // SaveCmsInfo 保存消息信息
 func (s *MessageServ) SaveCmsInfo(cmsinfo model.TaCmsInfo) (*model.TaCmsInfo, error) {
 	if cmsinfo.InfoId == "" {
+		org := s.ctx.Get("org").(model.SysOrg)
+		cmsinfo.OrgId = org.OrgId
 		newcmsinfo, err := s.dao.AddCmsInfo(cmsinfo)
 		if err != nil {
 			utils.LogError("保存信息失败: " + err.Error())

service/system/role.go

 }
 
 // GetRoleList 获取Role列表
-func (s *RoleServ) GetRoleList(caseids, name, caseid string, page, pageSize int) (map[string]interface{}, error) {
+func (s *RoleServ) GetRoleList(name 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, name, caseid, page, pageSize)
+	roles, err := s.dao.GetRoleList(name, page, pageSize)
 	if err != nil {
 		utils.LogError("获取角色列表失败: " + err.Error())
 		return nil, errors.New("获取角色列表失败")
 	}
-	total, err := s.dao.GetRoleCount(caseids, name, caseid)
+	total, err := s.dao.GetRoleCount(name)
 	if err != nil {
 		utils.LogError("获取角色列表失败: " + err.Error())
 		return nil, errors.New("获取角色列表失败")

service/user.go

 
 	return user, nil
 }
+
+// GetUserByTel 根据电话获取用户信息
+func (s *UserServ) GetUserByTel(tel string) (*model.SysUser, error) {
+	user, err := s.dao.GetUserByPhone(tel)
+	return user, err
+}

service/verify/verify.go

 }
 
 // GetCustomerCourseDetailById 根据ID获取当日可核销课程
-func (s *VerifyServ) GetCustomerCourseDetailById(id, caseid string, page, pageSize int) (map[string]interface{}, error) {
-	if err := utils.NewAuthEngine(s.ctx).CheckCase(caseid); err != nil {
-		return nil, err
-	}
+func (s *VerifyServ) GetCustomerCourseDetailById(id, caseids string, page, pageSize int) (map[string]interface{}, error) {
+	// if err := utils.NewAuthEngine(s.ctx).CheckCase(caseid); err != nil {
+	// 	return nil, err
+	// }
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
 	if page == 0 {
 		page = 1
 	}
-	customerDetail, err := s.dao.GetCustomerCourseList(id, caseid, page, pageSize)
+	customerDetail, err := s.dao.GetCustomerCourseList(id, caseids, page, pageSize)
 	if err != nil {
 		utils.LogError("获取列表失败: " + err.Error())
 		return nil, errors.New("获取列表失败")
 	}
 	customerId := customerDetail[0].CustomerId
-	total, err := s.dao.GetCustomerCourseListCount(id, caseid)
+	total, err := s.dao.GetCustomerCourseListCount(id, caseids)
 	if err != nil {
 		utils.LogError("获取列表失败: " + err.Error())
 		return nil, errors.New("获取列表失败")
 }
 
 // GetCustomerCourseDetailByTel根据电话号码获取当日可核销课程
-func (s *VerifyServ) GetCustomerCourseDetailByTel(tel, caseid string, page, pageSize int) (map[string]interface{}, error) {
-	if err := utils.NewAuthEngine(s.ctx).CheckCase(caseid); err != nil {
-		return nil, err
-	}
+func (s *VerifyServ) GetCustomerCourseDetailByTel(tel, caseids string, page, pageSize int) (map[string]interface{}, error) {
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
 	if page == 0 {
 		page = 1
 	}
-	customerDetail, err := s.dao.GetCustomerCourseListByTel(tel, caseid, page, pageSize)
+	customerDetail, err := s.dao.GetCustomerCourseListByTel(tel, caseids, page, pageSize)
 	if err != nil {
 		utils.LogError("获取列表失败: " + err.Error())
 		return nil, errors.New("获取列表失败")
 	}
 	customerId := customerDetail[0].CustomerId
-	total, err := s.dao.GetCustomerCourseListByTelCount(tel, caseid)
+	total, err := s.dao.GetCustomerCourseListByTelCount(tel, caseids)
 	if err != nil {
 		utils.LogError("获取列表失败: " + err.Error())
 		return nil, errors.New("获取列表失败")

service/vipcard/vipcard.go

 }
 
 // GetVipChild 获取VIP卡列表
-func (s *VipcardServ) GetVipChild(caseid string, page, pageSize int) (map[string]interface{}, error) {
+func (s *VipcardServ) GetVipChild(caseids, cardNo, sellerName, userName string, page, pageSize int) (map[string]interface{}, error) {
 	if pageSize == 0 {
 		pageSize = service.PAGENUM
 	}
 	if page == 0 {
 		page = 1
 	}
-	vipchild, err := s.dao.GetVipCardList(caseid, page, pageSize)
+	vipchild, err := s.dao.GetVipCardList(caseids, cardNo, sellerName, userName, page, pageSize)
 	if err != nil {
 		utils.LogError("获取VIP卡信息失败: " + err.Error())
 		return nil, errors.New("获取VIP卡信息失败")
 	}
-	total, err := s.dao.GetCardCount(caseid)
+	total, err := s.dao.GetCardCount(caseids, cardNo, sellerName, userName)
 	if err != nil {
 		utils.LogError("获取VIP卡信息失败: " + err.Error())
 		return nil, errors.New("获取VIP卡信息失败")
 		var vipChild model.TaVipCardChild
 		vipChild.VipCardId = vipcard.VipCardId
 		vipChild.VipCardChildCode = s.dao.GenerateChildCode()
+		vipChild.Amount = vipCard.CardAmount
 		_, err := s.dao.AddVipChildCard(vipChild)
 		if err != nil {
 			utils.LogError("创建VIP卡失败: " + err.Error())

utils/message.go

 type ClientID websocket.ClientID
 
 // Message 发送消息
-type Message websocket.Message
+type Message struct {
+	From ClientID    `json:"from"`
+	To   ClientID    `json:"to"`
+	Data interface{} `json:"data"`
+}
 
 // 消息类型
 const (
 
 // SendWs 发送 websocket
 func SendWs(message Message) {
-	msg := websocket.Message(message)
+	msg := websocket.Message{
+		From: websocket.ClientID(message.From),
+		To:   websocket.ClientID(message.To),
+		Data: message.Data,
+	}
+
 	websocket.Send(msg)
 }
 
 	default:
 	}
 }
+
+func init() {
+	go websocket.Run()
+}

utils/wechat.go

 	return wxClients[org]
 }
 
+// GetWxAppID 获取微信ID
+func GetWxAppID(org string) string {
+	return wxClients[org].GetAppID()
+}
+
 func init() {
 	wx.SetLogInst(defaultLogger)
 }