feats

conf/log.conf

 [common]
-filename="E:\\GoProjects\\src\\spaceofcheng\\services\\log\\common.log"
+filename="E:\\GoProject\\src\\spaceofcheng\\services\\log\\common.log"
 # log level "emergency", "alert", "critical", "error", "warning", "notice", "info", "debug"
 level="debug"

controllers/card/card.go

 
 // GetCardWithCustomer 获取卡及领取信息
 func (c *CardController) GetCardWithCustomer() {
-	c.ResponseJSON("ok")
+	cardid := c.GetString(":id")
+	cardDetail, err := c.serv.GetCardWithCustomer(cardid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	c.ResponseJSON(cardDetail)
+}
+
+// GetCardByCustomer 获取我的卡信息
+func (c *CardController) GetCardByCustomer() {
+	cards, err := c.serv.GetCardByCustomer()
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	c.ResponseJSON(cards)
+}
+
+// GetCustomerCardByID 获取我的卡详情
+func (c *CardController) GetCustomerCardByID() {
+	id := c.GetString(":id")
+	card, err := c.serv.GetCustomerCardByID(id)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	c.ResponseJSON(card)
 }

controllers/coupon/coupon.go

 
 	c.ResponseJSON(coupons)
 }
+
+// GetCustomerCouponByID 获取我的优惠券详情
+func (c *CouponController) GetCustomerCouponByID() {
+	id := c.GetString(":id")
+	coupon, err := c.serv.GetCustomerCouponByID(id)
+	if err != nil {
+		c.ResponseError(err)
+	}
+
+	c.ResponseJSON(coupon)
+}

controllers/course/order.go

 	}
 
 	// 订单优惠券
-	coupons := c.GetString("coupons")
+	customercouponid := c.GetString("customercouponid")
 
 	//
 	var orderInfo model.TaCourseOrders
-	var orderCoupon []model.TaCourseOrdersCoupon
+	//	var orderCoupon []model.TaCourseOrdersCoupon
 
 	if err := json.Unmarshal([]byte(info), &orderInfo); err != nil {
 		utils.LogError("下单转换JSON失败: " + err.Error())
 		c.ResponseError(errors.New("下单数据格式不正确"))
 	}
 
-	if err := json.Unmarshal([]byte(coupons), &orderCoupon); err != nil {
-		utils.LogError("下单优惠转换JSON失败: " + err.Error())
-		c.ResponseError(errors.New("优惠数据格式不正确"))
-	}
+	// if err := json.Unmarshal([]byte(coupons), &orderCoupon); err != nil {
+	// 	utils.LogError("下单优惠转换JSON失败: " + err.Error())
+	// 	c.ResponseError(errors.New("优惠数据格式不正确"))
+	// }
 	cust := c.Context.Get("customer").(model.TaCustomer)
 
 	if cust.Phone == "" {
 		)
 	}
 
-	if err := c.serv.Orders(&orderInfo, orderCoupon); err != nil {
+	if err := c.serv.Orders(&orderInfo, customercouponid); err != nil {
 		c.ResponseError(err)
 	}
 

controllers/luckdrawlist/luckdrawlist.go

+package luckdrawlist
+
+import (
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/luckdrawlist"
+)
+
+// LuckdrawlistController 信息
+type LuckdrawlistController struct {
+	dao *luckdrawlist.LuckdrawlistServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *LuckdrawlistController) Constructor() {
+	c.dao = luckdrawlist.NewLuckdrawlistServ(c.Context)
+}
+func (c *LuckdrawlistController) GetLuckdrawList() {
+	caseid := c.GetString("caseid")
+	page, _ := c.GetInt("page")
+	pagesize, _ := c.GetInt("pagesize")
+	if page < 0 {
+		page = 1
+	}
+
+	if pagesize <= 0 {
+		pagesize = 10
+	}
+	list, total, err := c.dao.GetLuckdrawList(caseid, page, pagesize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(map[string]interface{}{
+		"list":     list,
+		"page":     page,
+		"pagesize": pagesize,
+		"pagenum":  total,
+	})
+}
+
+func (c *LuckdrawlistController) GetLuckShareList() {
+	caseid := c.GetString("caseid")
+	page, _ := c.GetInt("page")
+	pagesize, _ := c.GetInt("pagesize")
+	if page < 0 {
+		page = 1
+	}
+
+	if pagesize <= 0 {
+		pagesize = 10
+	}
+	toPhone := c.GetString(":toPhone")
+	fromPhone := c.GetString(":fromPhone")
+	list, total, err := c.dao.GetLuckShareList(caseid, fromPhone, toPhone, page, pagesize)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(map[string]interface{}{
+		"list":     list,
+		"page":     page,
+		"pagesize": pagesize,
+		"pagenum":  total,
+	})
+
+}
+
+func (c *LuckdrawlistController) GetVerifyList() {
+	luckdrawId := c.GetString(":luckdrawId")
+	luckdraw, err := c.dao.GetVerifyList(luckdrawId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON(luckdraw)
+}
+
+func (c *LuckdrawlistController) VerifyLuckdraw() {
+	sysUser := c.Context.Get("user").(model.SysUser)
+	userId := sysUser.UserId
+	luckdrawId := c.GetString("luckdrawId")
+	err := c.dao.VerifyLuckdraw(luckdrawId, userId)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	c.ResponseJSON("核销成功")
+
+}

log/common.log

-2018/09/14 10:52:50 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 10:52:51 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 10:58:25 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 10:58:26 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 10:58:27 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:02:26 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:04:11 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:05:15 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:08:22 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:15:49 [E] 解析 Token 失败: token contains an invalid number of segments
-2018/09/14 11:15:51 [E] 解析 Token 失败: token contains an invalid number of segments
-2018/09/14 11:16:16 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:16:17 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:17:36 [E] 用户没有设置默认案场
-2018/09/14 11:17:44 [E] 用户没有设置默认案场
-2018/09/14 11:17:48 [E] 用户没有设置默认案场
-2018/09/14 11:36:01 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:47:35 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 11:47:36 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 13:33:00 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 13:40:39 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 13:40:40 [E] 保存用户映射信息失败: Error 1205: Lock wait timeout exceeded; try restarting transaction
-2018/09/14 15:01:53 [E] 用户没有设置默认案场

models/bodychecklist/bodychecklist.go

 	ta_body_check a
 	INNER JOIN ta_customer b ON a.user_id = b.customer_id
 	INNER JOIN sys_case c ON c.case_id = a.case_id
-	where and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
+	where %s and  a.status > ` + strconv.Itoa(models.STATUS_DEL)
 	if phone != "" {
 		sql += `and b.phone = '` + phone + `'`
 	}

models/card/card.go

 	return card, nil
 }
 
+// CustomerCardWithShare 我的卡券关联分享信息
+type CustomerCardWithShare struct {
+	model.TaCouponCard `xorm:"extends"`
+	Share              *model.TaExperienceCardShare
+}
+
 // GetCardByCustomer 获取我的体验卡
-func (m *CardDAO) GetCardByCustomer(orgid, customerid string) ([]model.TaCustomerCard, error) {
-	var cards []model.TaCustomerCard
-	err := m.db.Where("status>?", models.STATUS_DEL).And("customer_id=?", customerid).And("org_id=?", orgid).Find(&cards)
+func (m *CardDAO) GetCardByCustomer(orgid, customerid string) ([]CustomerCardWithShare, error) {
+	var cards []CustomerCardWithShare
+	sql := `select * from ta_customer_card where status>? and customer_id=? and org_id=?`
+	err := m.db.Sql(sql, models.STATUS_DEL, customerid, orgid).Find(&cards)
+	if err != nil {
+		return nil, err
+	}
+	for inx, card := range cards {
+		share, err := m.GetCardShareByCardID(card.CardId)
+		if err != nil {
+			utils.LogError("获取体验卡失败: " + err.Error())
+			return nil, errors.New("获取体验卡失败")
+		}
+		cards[inx].Share = share
+	}
 	return cards, err
 }
+
+// GetCustomerCardByID 获取我的体验卡详情
+func (m *CardDAO) GetCustomerCardByID(id string) (*CustomerCardWithShare, error) {
+	if id == "" {
+		return nil, errors.New("无优惠券信息")
+	}
+	var customerCard = new(CustomerCardWithShare)
+	sql := `select * from ta_customer_card where status>? and customer_card_id=?`
+	_, err := m.db.Sql(sql, models.STATUS_DEL, id).Get(customerCard)
+
+	share, err := m.GetCardShareByCardID(customerCard.CardId)
+	if err != nil {
+		utils.LogError("获取体验卡失败: " + err.Error())
+		return nil, errors.New("获取体验卡失败")
+	}
+	customerCard.Share = share
+	return customerCard, err
+}

models/coupon/coupon.go

 	return coupons, err
 }
 
-// GetCustomerCouponByID 获取我的优惠券想想
-func (m *CouponDAO) GetCustomerCouponByID(id string) (*model.TaCustomerCoupon, error) {
+// CustomerCouponWithShare 我的卡券关联分享信息
+type CustomerCouponWithShare struct {
+	model.TaCustomerCoupon `xorm:"extends"`
+	Share                  *model.TaCouponShare
+}
+
+// GetCustomerCouponByID 获取我的优惠券详情
+func (m *CouponDAO) GetCustomerCouponByID(id string) (*CustomerCouponWithShare, error) {
 	if id == "" {
 		return nil, errors.New("无优惠券信息")
 	}
-	var customerCoupon = new(model.TaCustomerCoupon)
-	_, err := m.db.Where("customer_coupon_id=?", id).Get(&customerCoupon)
+	var customerCoupon = new(CustomerCouponWithShare)
+	sql := `select * from ta_customer_coupon where customer_coupon_id=?`
+	_, err := m.db.Sql(sql, id).Get(customerCoupon)
+	if 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
+	}
+	customerCoupon.Share = share
 	return customerCoupon, err
 }
 
 	var customerCoupon = model.TaCustomerCoupon{
 		CustomerCouponId: id,
 		UseDate:          time.Now(),
+		Status:           models.STATUS_READY,
 	}
 	var cols = []string{
-		"area_name",
-		"area_icon",
-		"area_icon_white",
-		"order",
-		"case_id",
+		"use_date",
+		"status",
 	}
 	_, err := m.db.Cols(cols...).Where("customer_coupon_id=?", id).Update(customerCoupon)
 	return err

models/course/order.go

 package course
 
 import (
+	"errors"
+	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
 	"strings"
 	_, err := m.db.Insert(details)
 	return err
 }
+
+// SaveOrdersCoupon 保存订单优惠券
+func (m *CourseDAO) SaveOrdersCoupon(coupon *model.TaCourseOrdersCoupon, order *model.TaCourseOrders) error {
+	if order.OrdersId == "" {
+		return errors.New("内部错误, 订单事务顺序出错")
+	}
+	coupon.OrdersCouponId = utils.GetGUID()
+	coupon.Status = models.STATUS_NORMAL
+	coupon.CreateDate = time.Now().Local()
+	if _, err := m.db.Insert(coupon); err != nil {
+		return err
+	}
+	return nil
+}

models/goods/orders.go

 }
 
 // SaveOrdersCoupon 保存订单优惠券
-func (m *GoodsDAO) SaveOrdersCoupon(coupons *model.TaGoodsOrdersCoupon, order *model.TaGoodsOrders) error {
+func (m *GoodsDAO) SaveOrdersCoupon(coupon *model.TaGoodsOrdersCoupon, order *model.TaGoodsOrders) error {
 	if order.OrdersId == "" {
 		return errors.New("内部错误, 订单事务顺序出错")
 	}
-
-	if _, err := m.db.Insert(coupons); err != nil {
+	coupon.OrdersCouponId = utils.GetGUID()
+	coupon.Status = models.STATUS_NORMAL
+	coupon.CreateDate = time.Now().Local()
+	if _, err := m.db.Insert(coupon); err != nil {
 		return err
 	}
 

models/gymcard/gymcard.go

 }
 
 // GetCustomerGymById 根据id获取用户健身卡详情
-func (m *GymcardDAO) GetCustomerGymById(customerCardId string) (CustomerGym, error) {
+func (m *GymcardDAO) GetCustomerGymById(customerCardId string) (*CustomerGym, error) {
 	var customerGym []CustomerGym
 	sql := `SELECT
 	a.*,
 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
+	if err != nil {
+		return nil, err
+	}
+	if len(customerGym) > 0 {
+		return &customerGym[0], nil
+	}
+	return nil, err
 }
 
 // AddGiveRecord 新增赠送记录

models/luckdrawlist/luckdrawlist.go

 package luckdrawlist
 
 import (
+	"fmt"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/utils"
+	"strings"
+	"time"
 
 	"github.com/go-xorm/xorm"
 )
 	CustomerName           string
 	Phone                  string
 }
+
+func (m *LuckdrawDAO) GetLuckdrawList(filters []string, limit []int) ([]Luckdraw, int64, error) {
+	var luckdraw []Luckdraw
+	filterString := ""
+	if len(filters) > 0 {
+		filterString = strings.Join(filters, " and ")
+		filterString += " and "
+	}
+	sql := `SELECT
+	a.* ,
+	c.case_name,
+	b.name AS ActivityName,
+	d.name,
+	d.customer_name,
+	d.phone
+FROM
+	ta_luckdraw_record a
+	LEFT JOIN ta_luckdraw b ON a.luckdraw_id = b.id
+	LEFT JOIN sys_case c ON a.case_id = c.case_id
+	LEFT JOIN ta_customer d ON a.user_id = d.customer_id
+	where %s 1=1 `
+	sql += ` order by a.create_date desc `
+	total, err := utils.NewPageNaviEngine(m.ctx).GetPageList(&luckdraw, fmt.Sprintf(sql, filterString), limit)
+	if err != nil {
+		return nil, 0, err
+	}
+	return luckdraw, total, err
+
+}
+
+func (m *LuckdrawDAO) GetLuckShareList(fromPhone, toPhone string, filters []string, limit []int) ([]model.TaShareLuckyRecord, int64, error) {
+	var luckShare []model.TaShareLuckyRecord
+	filterString := ""
+	if len(filters) > 0 {
+		filterString = strings.Join(filters, " and ")
+		filterString += " and "
+	}
+	sql := `select * from ta_share_lucky_record where %s 1=1`
+	if fromPhone != "" {
+		sql += ` and from_customer_tel = ` + fromPhone
+	}
+	if toPhone != "" {
+		sql += ` and to_customer_tel = ` + toPhone
+	}
+	sql += ` order by a.create_date desc `
+	total, err := utils.NewPageNaviEngine(m.ctx).GetPageList(&luckShare, fmt.Sprintf(sql, filterString), limit)
+	if err != nil {
+		return nil, 0, err
+	}
+	return luckShare, total, err
+}
+
+func (m *LuckdrawDAO) GetLuckdrawById(luckdrawId string) (*Luckdraw, error) {
+	var luckdraw []Luckdraw
+	sql := `SELECT
+	a.*,
+	c.case_name,
+	b.NAME AS ActivityName,
+	d.NAME,
+	d.customer_name,
+	d.phone 
+FROM
+	ta_luckdraw_record a
+	INNER JOIN ta_luckdraw b ON a.luckdraw_id = b.id
+	INNER JOIN sys_case c ON a.case_id = c.case_id
+	INNER JOIN ta_customer d ON a.user_id = d.customer_id
+	INNER JOIN ta_luckdraw_prize e ON e.id = a.prize_id 
+WHERE
+	 DATE_FORMAT( e.verification_start, '%Y-%m-%d' ) <= DATE_FORMAT( NOW( ), '%Y-%m-%d' )
+	 AND DATE_FORMAT( e.verification_end, '%Y-%m-%d' ) >= DATE_FORMAT( NOW( ), '%Y-%m-%d' )
+	 AND a.id = '` + luckdrawId + `'`
+	err := m.db.Sql(sql).Find(&luckdraw)
+	if err != nil {
+		return nil, err
+	}
+	if len(luckdraw) > 0 {
+		return &luckdraw[0], err
+	}
+	return nil, nil
+}
+
+func (m *LuckdrawDAO) VerifyLuckdraw(luckdrawId int) error {
+	var luckdraw = model.TaLuckdrawRecord{
+		Id:           luckdrawId,
+		WriteoffDate: time.Now(),
+		Status:       1,
+	}
+	var cols = []string{
+		"writeoff_date",
+		"status",
+	}
+	_, err := m.db.Cols(cols...).Where("id = ?", luckdraw.Id).Update(luckdraw)
+	return err
+}
+
+func (m *LuckdrawDAO) AddWriteoffRecord(luckdraw *Luckdraw, userId string) error {
+	var luckWriteoff model.TaLuckdrawWriteoff
+	luckWriteoff.CaseId = luckdraw.CaseId
+	luckWriteoff.LuckdrawId = luckdraw.LuckdrawId
+	luckWriteoff.OrgId = luckdraw.OrgId
+	luckWriteoff.RecordId = luckdraw.Id
+	luckWriteoff.Status = 0
+	luckWriteoff.WriteoffDate = time.Now()
+	luckWriteoff.WriteoffUser = userId
+	_, err := m.db.Insert(luckWriteoff)
+	return err
+
+}

models/model/ta_luckdraw_record.go

 	LuckdrawId   int       `xorm:"INT(11)"`
 	PrizeId      int       `xorm:"INT(11)"`
 	PrizeName    string    `xorm:"VARCHAR(50)"`
-	UserId       int       `xorm:"INT(11)"`
+	UserId       string    `xorm:"VARCHAR(64)"`
 	UserName     string    `xorm:"VARCHAR(50)"`
 	UserHeadImg  string    `xorm:"TEXT"`
 	CreateDate   time.Time `xorm:"DATETIME"`
 	Status       int       `xorm:"SMALLINT(6)"`
 	WriteoffDate time.Time `xorm:"DATETIME"`
 	OrgId        string    `xorm:"VARCHAR(64)"`
-	CaseId       int       `xorm:"INT(11)"`
+	CaseId       string    `xorm:"VARCHAR(64)"`
 }

models/model/ta_luckdraw_writeoff.go

 	LuckdrawId   int       `xorm:"INT(11)"`
 	RecordId     int       `xorm:"INT(11)"`
 	WriteoffDate time.Time `xorm:"DATETIME"`
-	WriteoffUser int       `xorm:"INT(11)"`
+	WriteoffUser string    `xorm:"VARCHAR(64)"`
 	Status       int       `xorm:"SMALLINT(6)"`
 	OrgId        string    `xorm:"VARCHAR(64)"`
-	CaseId       int       `xorm:"INT(11)"`
+	CaseId       string    `xorm:"VARCHAR(64)"`
 }

models/model/ta_share_lucky_record.go

 
 type TaShareLuckyRecord struct {
 	Id                 int       `xorm:"not null pk autoincr INT(11)"`
-	FromCustomerId     int       `xorm:"INT(11)"`
+	FromCustomerId     string    `xorm:"VARCHAR(64)"`
 	FromCustomerName   string    `xorm:"VARCHAR(32)"`
 	FromCustomerWxname string    `xorm:"VARCHAR(64)"`
 	FromCustomerTel    string    `xorm:"VARCHAR(32)"`
-	ToCustomerId       int       `xorm:"INT(11)"`
+	ToCustomerId       string    `xorm:"VARCHAR(64)"`
 	ToCustomerName     string    `xorm:"VARCHAR(32)"`
 	ToCustomerWxname   string    `xorm:"VARCHAR(64)"`
 	ToCustomerTel      string    `xorm:"VARCHAR(32)"`
 	CreateDate         time.Time `xorm:"DATETIME"`
-	CaseId             int       `xorm:"INT(11)"`
+	CaseId             string    `xorm:"VARCHAR(64)"`
 	Status             int       `xorm:"SMALLINT(6)"`
 	LuckydrawId        int       `xorm:"INT(11)"`
 	LuckydrawName      string    `xorm:"VARCHAR(128)"`

routers/common.go

 
 import (
 	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/controllers/bodychecklist"
 	"spaceofcheng/services/controllers/card"
 	"spaceofcheng/services/controllers/cases"
 	"spaceofcheng/services/controllers/channel"
 	"spaceofcheng/services/controllers/customer"
 	"spaceofcheng/services/controllers/goods"
 	"spaceofcheng/services/controllers/gymcard"
+	"spaceofcheng/services/controllers/luckdrawlist"
 	"spaceofcheng/services/controllers/marketing"
 	"spaceofcheng/services/controllers/message"
 	"spaceofcheng/services/controllers/system"
 		beego.NSRouter("/gymcard", &gymcard.GymcardController{}, "post:SaveGymcard"),
 		beego.NSRouter("/gymcard", &gymcard.GymcardController{}, "put:SaveGymcard"),
 		beego.NSRouter("/gymcard/:customerGymId", &gymcard.GymcardController{}, "put:VerifyCustomerGymcard"),
+		// luckdrawlist 抽奖
+		beego.NSRouter("luckdrawlist", &luckdrawlist.LuckdrawlistController{}, "get:GetLuckdrawList"),
+		beego.NSRouter("luckdrawlist/:toPhone/:fromPhone", &luckdrawlist.LuckdrawlistController{}, "get:GetLuckShareList"),
+		beego.NSRouter("luckdrawlist/:luckdrawId", &luckdrawlist.LuckdrawlistController{}, "get:GetVerifyList"),
+		beego.NSRouter("luckdrawlist/:luckdrawId", &luckdrawlist.LuckdrawlistController{}, "put:VerifyLuckdraw"),
+		// bodychecklist 体检列表
+		beego.NSRouter("bodychecklist", &bodychecklist.BodychecklistController{}, "get:GetBodyCheckList"),
 		// role 角色
 		beego.NSRouter("/role", &system.RoleController{}, "get:GetRoleList"),
 		beego.NSRouter("/role/:roleid", &system.RoleController{}, "get:GetRoleByID"),

routers/wechat.go

 		beego.NSRouter("/customer", &customer.CustomerController{}, "get:GetCustWXByID"),
 		beego.NSRouter("/customer/user", &user.UserController{}, "get:GetUserCustomer"),
 		beego.NSRouter("/customer/coupon", &coupon.CouponController{}, "get:GetCouponByCustomer"),
-		// beego.NSRouter("/customer/card", &card.CardController{}, "get:GetCardByCustomer"),
+		beego.NSRouter("/customer/card", &card.CardController{}, "get:GetCardByCustomer"),
+		beego.NSRouter("/customer/coupon/:id", &coupon.CouponController{}, "get:GetCustomerCouponByID"),
+		beego.NSRouter("/customer/card/:id", &card.CardController{}, "get:GetCustomerCardByID"),
 
 		// 下单
 		beego.NSRouter("/order/goods", &goods.GoodsController{}, "post:PostOrder"),

service/card/card.go

 	return card, nil
 }
 
-// GetCardWithCustomer 获取优惠券明细
+// GetCardWithCustomer 获取体验卡明细
 func (s *CardServ) GetCardWithCustomer(cardid string) (*card.CaseUsableCard, error) {
 	if cardid == "" {
 		return nil, errors.New("没有卡信息！")
 	}
 	cardDetail, err := s.dao.GetCardDetail(cardid)
 	if err != nil {
-		utils.LogError("获取优惠券失败: " + err.Error())
-		return nil, errors.New("获取优惠券失败")
+		utils.LogError("获取体验卡失败: " + err.Error())
+		return nil, errors.New("获取体验卡失败")
 	}
 	return cardDetail, nil
 }
 
-// GetCardByCustomer 获取我的优惠券
-func (s *CardServ) GetCardByCustomer() ([]model.TaCustomerCard, error) {
+// GetCardByCustomer 获取我的体验卡
+func (s *CardServ) GetCardByCustomer() ([]card.CustomerCardWithShare, error) {
 	org := s.ctx.Get("org").(model.SysOrg)
 	customer := s.ctx.Get("customer").(model.TaCustomer)
 	cards, err := s.dao.GetCardByCustomer(org.OrgId, customer.CustomerId)
 	}
 	return cards, nil
 }
+
+// GetCustomerCardByID 获取我的体验卡详情
+func (s *CardServ) GetCustomerCardByID(id string) (*card.CustomerCardWithShare, error) {
+	card, err := s.dao.GetCustomerCardByID(id)
+	if err != nil {
+		utils.LogError("获取体验卡失败: " + err.Error())
+		return nil, errors.New("获取体验卡失败")
+	}
+	return card, nil
+}

service/coupon/coupon.go

 	}
 	return coupons, nil
 }
+
+// GetCustomerCouponByID 获取我的优惠券详情
+func (s *CouponServ) GetCustomerCouponByID(id string) (*coupon.CustomerCouponWithShare, error) {
+	coupon, err := s.dao.GetCustomerCouponByID(id)
+	if err != nil {
+		utils.LogError("获取优惠券失败: " + err.Error())
+		return nil, errors.New("获取优惠券失败")
+	}
+	return coupon, nil
+}
+
+//

service/course/course.go

 	"errors"
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/cases"
+	"spaceofcheng/services/models/coupon"
 	"spaceofcheng/services/models/course"
 	"spaceofcheng/services/models/customer"
 	"spaceofcheng/services/models/model"
 
 // CourseServ 系统处理
 type CourseServ struct {
-	ctx     *utils.Context
-	dao     *course.CourseDAO
-	casedao *cases.CaseDAO
-	custDAO *customer.CustomerDAO
-	userDAO *system.UserDAO
+	ctx       *utils.Context
+	dao       *course.CourseDAO
+	casedao   *cases.CaseDAO
+	custDAO   *customer.CustomerDAO
+	userDAO   *system.UserDAO
+	couponDAO *coupon.CouponDAO
 }
 
 // NewCourseServ 初始化
 func NewCourseServ(ctx *utils.Context) *CourseServ {
 	return &CourseServ{
-		ctx:     ctx,
-		dao:     course.NewCourseDAO(ctx),
-		casedao: cases.NewCaseDAO(ctx),
-		custDAO: customer.NewCustomerDAO(ctx),
-		userDAO: system.NewUserDAO(ctx),
+		ctx:       ctx,
+		dao:       course.NewCourseDAO(ctx),
+		casedao:   cases.NewCaseDAO(ctx),
+		custDAO:   customer.NewCustomerDAO(ctx),
+		userDAO:   system.NewUserDAO(ctx),
+		couponDAO: coupon.NewCouponDAO(ctx),
 	}
 }
 
 		return nil, utils.LogError("请选择课程标签！")
 	}
 	if course.CourseId == "" {
+		org := s.ctx.Get("org").(model.SysOrg)
+		course.OrgId = org.OrgId
 		newInfo, err = s.dao.AddCourse(course)
 		if err != nil {
 			utils.LogError("保存课程信息失败: " + err.Error())

service/course/order.go

 // Orders 下单
 func (s *CourseServ) Orders(
 	couseOrder *model.TaCourseOrders,
-	coupons []model.TaCourseOrdersCoupon,
+	customercouponid string,
 ) error {
 	org := s.ctx.Get("org").(model.SysOrg)
 	cust := s.ctx.Get("customer").(model.TaCustomer)
 		return errors.New("定单课程尚未排课, 不能下单")
 	}
 
-	if coupons != nil && len(coupons) > 0 {
-		// 校验卡券, 同时进行卡券的注销或者已使用的更新操作
-		// TODO
-	}
-
 	couseOrder.OrdersId = guid.NewGUIDString()
 	couseOrder.Price = course.Price // 课程价格, 即为订单价格
 	couseOrder.ActualAmount = course.Price
 		couseOrder.CustomerName = cust.CustomerName
 	}
 
-	// 校验金额
-	if err := s.validBillCharges(couseOrder, coupons); err != nil {
-		return err
+	account, err := s.custDAO.GetAccountByCust(cust.CustomerId)
+	if err != nil {
+		utils.LogError("查询用户账户信息出错: " + err.Error())
+		return errors.New("查询用户账户信息出错")
 	}
+	accMoney, _ := strconv.ParseFloat(account.Amount, 64)
+
+	if customercouponid != "" {
+		// 校验卡券, 同时进行卡券的注销或者已使用的更新操作
+		// TODO
+		couseOrder.PayType = models.CONSUME_COUPON
+
+		// 优惠券校验
+		customerCoupon, err := s.couponDAO.GetCustomerCouponByID(customercouponid)
+		if err != nil {
+			utils.LogError("查询优惠券信息失败: " + err.Error())
+			return errors.New("查询优惠券信息失败")
+		}
+		if customerCoupon == nil || customerCoupon.CustomerCouponId == "" {
+			return errors.New("优惠券无效！")
+		}
+		if customerCoupon.Status != models.STATUS_NORMAL || !customerCoupon.UseDate.IsZero() {
+			return errors.New("优惠券已被使用！请重新选择优惠券！")
+		}
+
+		// 根据id获取优惠券信息
+		coupon, err := s.couponDAO.GetCouponInfoByCustomerCouponID(customercouponid)
+		if err != nil {
+			utils.LogError("查询优惠券信息失败: " + err.Error())
+			return errors.New("查询优惠券信息失败")
+		}
+
+		// 判断优惠券是否可以抵用商品
+		var isdy = false
+		if coupon.IsAll == 1 {
+			isdy = true
+			couseOrder.CouponAmount = couseOrder.Price
+		} else {
+			for _, target := range coupon.Targets {
+				if target.TargetId == course.CourseId {
+					isdy = true
+				}
+			}
+			couseOrder.CouponAmount = coupon.Price
+		}
+		if !isdy {
+			return errors.New("优惠券不可抵用该课程")
+		}
+		var ordersCoupon = model.TaCourseOrdersCoupon{
+			OrdersId:   couseOrder.OrdersId,
+			CouponId:   coupon.CouponId,
+			CouponName: coupon.CouponName,
+			UsedAmount: couseOrder.CouponAmount,
+		}
+		if err := s.dao.SaveOrdersCoupon(&ordersCoupon, couseOrder); err != nil {
+			utils.LogError("保存优惠信息出错: " + err.Error())
+			return errors.New("保存优惠信息出错")
+		}
+
+		// 优惠券核销
+		err = s.couponDAO.VerifyCustomerCoupon(customercouponid)
+		if err != nil {
+			utils.LogError("优惠券核销出错: " + err.Error())
+			return errors.New("优惠券核销出错")
+		}
+	} else {
+		couseOrder.PayType = models.CONSUME_COINCHG
+	}
+
+	couponAmount, _ := strconv.ParseFloat(couseOrder.CouponAmount, 64)
+	payMoney, _ := strconv.ParseFloat(couseOrder.Price, 64)
+	payMoney = payMoney - couponAmount
+
+	couseOrder.ActualAmount = strconv.FormatFloat(payMoney, 'f', -1, 64)
+
+	// 校验金额
+	// if err := s.validBillCharges(couseOrder, coupons); err != nil {
+	// 	return err
+	// }
 
 	// 实际支付
-	actualAmount, _ := strconv.ParseFloat(couseOrder.ActualAmount, 64)
+	actualAmount := payMoney
 
 	// 用户账户  -- 内部人员也可以购买
 	if actualAmount > 0 {
-		couseOrder.PayType = models.CONSUME_COINCHG
-		account, err := s.custDAO.GetAccountByCust(cust.CustomerId)
-		if err != nil {
-			utils.LogError("查询用户账户信息出错: " + err.Error())
-			return errors.New("查询用户账户信息出错")
-		}
-		accMoney, _ := strconv.ParseFloat(account.Amount, 64)
 
 		if actualAmount > accMoney {
 			return errors.New("账户余额不足")
 	}
 
 	// 入库
-	if err := s.SaveOrder(couseOrder, coupons, course); err != nil {
+	if err := s.SaveOrder(couseOrder, course); err != nil {
 		utils.LogError("课程下单失败: " + err.Error())
 		return errors.New("下单失败, 请重试")
 	}
 }
 
 // SaveOrder 保存订单明细
-func (s *CourseServ) SaveOrder(order *model.TaCourseOrders, coupons []model.TaCourseOrdersCoupon, course *course.CourseDetail) error {
+func (s *CourseServ) SaveOrder(order *model.TaCourseOrders, course *course.CourseDetail) error {
 	// 订单信息
 	if err := s.dao.SaveCourseOrder(order); err != nil {
 		utils.LogError("课程下单失败: " + err.Error())
 	}
 
 	// 默认城币购买
-	courseObtaimType := models.COURSE_GETBY_COINCHG
-	if coupons != nil && len(coupons) > 0 {
-		for _, c := range coupons {
-			if c.CouponType == models.COURSE_COUPON_CARD {
-				courseObtaimType = models.COURSE_GETBY_CARD
-			} else if c.CouponType == models.COURSE_COUPON_COUPON {
-				courseObtaimType = models.COURSE_GETBY_COUPON
-			}
-		}
-	}
+	// courseObtaimType := models.COURSE_GETBY_COINCHG
+	// if coupons != nil && len(coupons) > 0 {
+	// 	for _, c := range coupons {
+	// 		if c.CouponType == models.COURSE_COUPON_CARD {
+	// 			courseObtaimType = models.COURSE_GETBY_CARD
+	// 		} else if c.CouponType == models.COURSE_COUPON_COUPON {
+	// 			courseObtaimType = models.COURSE_GETBY_COUPON
+	// 		}
+	// 	}
+	// }
 
 	// 我的课程信息
 	custCourse := model.TaCustomerCourse{
 		CourseNum:        course.CourseNum,
 		JoinNum:          0,
 		CreateDate:       time.Now().Local(),
-		CourseObtaimType: courseObtaimType,
+		CourseObtaimType: order.PayType,
 		SourceId:         order.OrdersId,
 		IsDone:           models.BOOL_FALSE,
 	}

service/goods/orders.go

 		// 如果是使用优惠券
 		if customercouponid != "" {
 			info.PayType = models.CONSUME_COUPON
+
+			// 优惠券校验
+			customerCoupon, err := s.couponDAO.GetCustomerCouponByID(customercouponid)
+			if err != nil {
+				utils.LogError("查询优惠券信息失败: " + err.Error())
+				return errors.New("查询优惠券信息失败")
+			}
+			if customerCoupon == nil || customerCoupon.CustomerCouponId == "" {
+				return errors.New("优惠券无效！")
+			}
+			if customerCoupon.Status != models.STATUS_NORMAL || !customerCoupon.UseDate.IsZero() {
+				return errors.New("优惠券已被使用！请重新选择优惠券！")
+			}
+
 			// 根据id获取优惠券信息
 			coupon, err := s.couponDAO.GetCouponInfoByCustomerCouponID(customercouponid)
 			if err != nil {
 				utils.LogError("查询优惠券信息失败: " + err.Error())
 				return errors.New("查询优惠券信息失败")
 			}
-			// 优惠券校验
-			// s.couponDAO.GetCustomerCouponByID
 			// 遍历优惠券可抵用的商品
 			var dyGoods = model.TaGoodsOrdersDetail{
 				Price:   "0.0",
 				GoodsId: "",
 			}
 			for _, detail := range details {
-				for _, target := range coupon.Targets {
-					if target.TargetId == detail.GoodsId {
-						dyprice, _ := strconv.ParseFloat(dyGoods.Price, 64)
-						detailprice, _ := strconv.ParseFloat(detail.Price, 64)
-						if dyprice < detailprice {
-							dyGoods = detail
+				if coupon.IsAll == 1 {
+					dyprice, _ := strconv.ParseFloat(dyGoods.Price, 64)
+					detailprice, _ := strconv.ParseFloat(detail.Price, 64)
+					if dyprice < detailprice {
+						dyGoods = detail
+					}
+				} else {
+					for _, target := range coupon.Targets {
+						if target.TargetId == detail.GoodsId {
+							dyprice, _ := strconv.ParseFloat(dyGoods.Price, 64)
+							detailprice, _ := strconv.ParseFloat(detail.Price, 64)
+							if dyprice < detailprice {
+								dyGoods = detail
+							}
 						}
 					}
 				}
 					return errors.New("优惠券核销出错")
 				}
 			} else {
-				info.CouponAmount = "0.0"
+				return errors.New("优惠券不可抵用商品")
 			}
 		} else {
 			// 如果是使用城币

service/gymcard/gymcard.go

 	"spaceofcheng/services/utils"
 	"strings"
 	"time"
-
-	"github.com/astaxie/beego"
 )
 
 // GymcardServ 系统处理
 		utils.LogError("获取健身卡详情失败" + err.Error())
 		return nil, errors.New("获取健身卡详情失败")
 	}
-	return &customerGym, err
+	return customerGym, err
 }
 
 // SaveGymcard 保存游泳健身卡
 		utils.LogError("保存健身卡信息失败" + err.Error())
 		return nil, errors.New("保存健身卡信息失败")
 	}
-	beego.Error("-------------------------------------")
-	beego.Error(newGym)
-	beego.Error("-------------------------------------")
 	return &newGym, nil
 }
 

service/luckdrawlist/luckdrawlist.go

+package luckdrawlist
+
+import (
+	"errors"
+	"spaceofcheng/services/models/luckdrawlist"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"strings"
+)
+
+// LuckdrawlistServ 系统处理
+type LuckdrawlistServ struct {
+	ctx *utils.Context
+	dao *luckdrawlist.LuckdrawDAO
+}
+
+// NewLuckdrawlistServ 初始化
+func NewLuckdrawlistServ(ctx *utils.Context) *LuckdrawlistServ {
+	return &LuckdrawlistServ{
+		ctx: ctx,
+		dao: luckdrawlist.NewLuckdrawDAO(ctx),
+	}
+}
+func (s *LuckdrawlistServ) GetLuckShareList(caseID, fromPhone, toPhone string, pagenavi ...int) ([]model.TaShareLuckyRecord, int64, error) {
+	filters := []string{}
+	if caseID != "" {
+		if err := utils.NewAuthEngine(s.ctx).CheckCase(caseID); err != nil {
+			return nil, 0, err
+		}
+
+		filters = []string{
+			"case_id='" + caseID + "'",
+		}
+	} else {
+		casesRaw := s.ctx.Get("cases")
+		if casesRaw == nil {
+			return nil, 0, errors.New("请设置过滤案场")
+		}
+
+		cases := casesRaw.([]model.SysUserCase)
+		caseIDs := []string{}
+		for _, cs := range cases {
+			caseIDs = append(caseIDs, cs.CaseId)
+		}
+
+		filters = []string{
+			"case_id in ('" + strings.Join(caseIDs, "','") + "')",
+		}
+	}
+
+	limit := utils.GetPageNaviLimit(pagenavi...)
+	res, total, err := s.dao.GetLuckShareList(fromPhone, toPhone, filters, limit)
+	if err != nil {
+		utils.LogError("查询卡列表失败: " + err.Error())
+		return nil, 0, errors.New("查询卡列表失败")
+	}
+
+	return res, total, nil
+
+}
+
+func (s *LuckdrawlistServ) GetLuckdrawList(caseID string, pagenavi ...int) ([]luckdrawlist.Luckdraw, int64, error) {
+	filters := []string{}
+	if caseID != "" {
+		if err := utils.NewAuthEngine(s.ctx).CheckCase(caseID); err != nil {
+			return nil, 0, err
+		}
+
+		filters = []string{
+			"case_id='" + caseID + "'",
+		}
+	} else {
+		casesRaw := s.ctx.Get("cases")
+		if casesRaw == nil {
+			return nil, 0, errors.New("请设置过滤案场")
+		}
+
+		cases := casesRaw.([]model.SysUserCase)
+		caseIDs := []string{}
+		for _, cs := range cases {
+			caseIDs = append(caseIDs, cs.CaseId)
+		}
+
+		filters = []string{
+			"case_id in ('" + strings.Join(caseIDs, "','") + "')",
+		}
+	}
+
+	limit := utils.GetPageNaviLimit(pagenavi...)
+	res, total, err := s.dao.GetLuckdrawList(filters, limit)
+	if err != nil {
+		utils.LogError("查询抽奖列表失败: " + err.Error())
+		return nil, 0, errors.New("查询抽奖列表失败")
+	}
+
+	return res, total, nil
+
+}
+
+func (s *LuckdrawlistServ) GetVerifyList(luckdrawId string) (*luckdrawlist.Luckdraw, error) {
+	luckdraw, err := s.dao.GetLuckdrawById(luckdrawId)
+	if err != nil {
+		utils.LogError("查询抽奖列表失败: " + err.Error())
+		return nil, errors.New("查询抽奖列表失败")
+	}
+	return luckdraw, nil
+
+}
+
+func (s *LuckdrawlistServ) VerifyLuckdraw(luckdrawId, userId string) error {
+	luckdraw, err := s.dao.GetLuckdrawById(luckdrawId)
+
+	luckdrawIdInt, err := strconv.Atoi(luckdrawId)
+	if err != nil {
+		utils.LogError("核销失败: " + err.Error())
+		return errors.New("核销失败")
+	}
+	err = s.dao.VerifyLuckdraw(luckdrawIdInt)
+	if err != nil {
+		utils.LogError("核销失败: " + err.Error())
+		return errors.New("核销失败")
+	}
+	err = s.dao.AddWriteoffRecord(luckdraw, userId)
+	if err != nil {
+		utils.LogError("核销失败: " + err.Error())
+		return errors.New("核销失败")
+	}
+	return nil
+
+}