luckdraw bodycheck

controllers/bodycheck/bodycheck.go

@@ -0,0 +1,298 @@
+package bodycheck
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/bodycheck"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"time"
+
+	"github.com/astaxie/beego"
+
+	"github.com/astaxie/beego/config"
+	"github.com/zjxpcyc/wechat/wx"
+)
+
+// BodyCheckController 应用
+type BodyCheckController struct {
+	dao *bodycheck.BodycheckServ
+	controllers.BaseController
+	weixin *wx.Client
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *BodyCheckController) Constructor() {
+	c.dao = bodycheck.NewBodycheckServ(c.Context)
+	org := c.Context.Get("org").(model.SysOrg)
+	c.weixin = utils.WxClientFor(org.OrgId)
+}
+
+// GetCheckByUser 根据用户获取体检报告
+func (c *BodyCheckController) GetCheckByUser() {
+	code := c.GetString("code")
+	openid, err := c.weixin.GetOpenID(code)
+	if err != nil {
+		beego.Error("获取openid失败！", err.Error())
+		c.ResponseError(err)
+	}
+	// openid := "o5EGQ0ytw9JUpSa6N84ddo3CYFO4"
+	user, err := c.dao.GetUserByOpenID(openid)
+	if err != nil {
+		c.ResponseError(err)
+	}
+	if user == nil {
+		c.ResponseError(err)
+	}
+
+	bodyCheck, err := c.dao.GetBodyCheckByUser(user.CustomerId)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	if len(bodyCheck) == 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "没有查询到数据",
+		})
+	}
+	presentations, err := c.dao.GetPresentationByCheckID(bodyCheck[0].Id)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":   true,
+		"Message":  presentations,
+		"Info":     bodyCheck,
+		"UserInfo": user,
+	})
+}
+
+// PostCheckResult 测量结果返回
+func (c *BodyCheckController) PostCheckResult() {
+	r := c.Ctx.Request
+	defer r.Body.Close()
+	con, _ := ioutil.ReadAll(r.Body) //获取post的数据
+
+	var formVal map[string]interface{}
+	err := json.Unmarshal(con, &formVal)
+	if err != nil {
+		beego.Error(err)
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+
+	type CheckResult struct {
+		WechatAccount string
+		EquipmentId   string
+		CheckType     int
+		CheckDate     time.Time
+		CheckResult   string
+		ReportUrl     string
+		HMSReportUrl  string
+	}
+
+	var result = CheckResult{}
+
+	result.EquipmentId = formVal["EquipmentId"].(string)
+	result.WechatAccount = formVal["WechatAccount"].(string)
+	// result.CheckResult = formVal["CheckResult"].(string)
+	result.CheckResult = ""
+	result.ReportUrl = formVal["ReportUrl"].(string)
+	result.HMSReportUrl = formVal["HMSReportUrl"].(string)
+	result.CheckType = int(formVal["CheckType"].(float64))
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	loc, _ := time.LoadLocation("Local")
+	result.CheckDate, err = time.ParseInLocation("2006-01-02 15:04:05", formVal["CheckDate"].(string), loc)
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+
+	user, err := c.dao.GetUserByOpenID(result.WechatAccount)
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+
+	if user == nil || user.Id < 1 {
+		beego.Error("没有当前用户信息！")
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "没有当前用户信息！",
+		})
+	}
+	userid := user.Id
+
+	checkinfo, err := c.dao.GetCheckByUserAndEquipmentID(userid, result.EquipmentId)
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	if checkinfo == nil || checkinfo.Id < 1 || time.Now().Local().Format("2006-01-02") != checkinfo.CreateDate.Format("2006-01-02") {
+		caseEquipment, err := c.dao.GetCaseEquipment(result.EquipmentId)
+		if err != nil {
+			beego.Error(err.Error())
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": err.Error(),
+			})
+		}
+		if caseEquipment == nil || caseEquipment.Id < 1 {
+			beego.Error("设备未维护！")
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": "设备未维护！",
+			})
+		}
+		var checkNew = model.TaBodyCheck{}
+		checkNew.CaseId = caseEquipment.CaseId
+		checkNew.EquipmentId = result.EquipmentId
+		checkNew.UserId = userid
+		checkNew.ReportUrl = result.HMSReportUrl
+		checkNew.CreateDate = result.CheckDate
+		checkinfo, err = c.dao.SaveBodyCheckInfo(checkNew)
+
+		wxconf, _ := config.NewConfig("ini", "conf/wechat.conf")
+		messageTplID := wxconf.String("messageTplID")
+
+		c.weixin.SendTplMessage(result.WechatAccount, messageTplID, beego.AppConfig.String("resultURL"), map[string]wx.TplMessageData{
+			"first": wx.TplMessageData{
+				Value: "您的体检报告已生成",
+			},
+			"keyword1": wx.TplMessageData{
+				Value: strconv.Itoa(checkinfo.Id),
+			},
+			"keyword2": wx.TplMessageData{
+				Value: result.CheckDate.Format("2006-01-02 15:04"),
+			},
+			"remark": wx.TplMessageData{
+				Value: "",
+			},
+		})
+	}
+
+	presentation, err := c.dao.GetPresentation(checkinfo.Id, result.CheckType)
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	if presentation == nil || presentation.Id < 1 {
+		// 新增
+		var preNew = model.TaPresentation{}
+		preNew.CheckId = checkinfo.Id
+		preNew.CheckDate = result.CheckDate
+		preNew.CheckResult = result.CheckResult
+		preNew.CheckType = result.CheckType
+		preNew.ReportUrl = result.ReportUrl
+		presentation, err = c.dao.SavePresentation(preNew)
+		if err != nil {
+			beego.Error(err.Error())
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": err.Error(),
+			})
+		}
+	} else {
+		// 修改
+		presentation.CheckDate = result.CheckDate
+		presentation.CheckResult = result.CheckResult
+		presentation.ReportUrl = result.ReportUrl
+		err = c.dao.UpdatePresentation(presentation)
+		if err != nil {
+			beego.Error(err.Error())
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": err.Error(),
+			})
+		}
+		// 删除之前的记录
+		err = c.dao.DeletePresentionDetail(presentation.Id)
+		if err != nil {
+			beego.Error(err.Error())
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": err.Error(),
+			})
+		}
+	}
+
+	specs, err := c.dao.GetCheckSpecs()
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+
+	if len(formVal) > 0 {
+		var details []model.TaPresentationDetail
+		for k, v := range formVal {
+			if k != "WechatAccount" && k != "EquipmentId" && k != "CheckType" && k != "CheckDate" && k != "CheckResult" && k != "ReportUrl" && k != "HMSReportUrl" && k != "WXID" {
+				var detail model.TaPresentationDetail
+				detail.CheckName = k
+				switch vx := v.(type) {
+				case string:
+					detail.CheckVal = vx
+				case float64:
+					detail.CheckVal = strconv.FormatFloat(vx, 'f', 2, 64)
+				}
+
+				detail.PresentationId = presentation.Id
+				var specName = ""
+				for _, spec := range specs {
+					if spec.SortName == k {
+						specName = spec.Name
+						break
+					}
+				}
+				detail.SpecName = specName
+				details = append(details, detail)
+			}
+		}
+		if len(details) > 0 {
+			err := c.dao.SavePresentationDetail(details)
+			if err != nil {
+				beego.Error(err.Error())
+				c.ResponseJson(map[string]interface{}{
+					"Status":  false,
+					"Message": err.Error(),
+				})
+			}
+		}
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":  true,
+		"Message": "",
+	})
+}

controllers/bodycheck/wechat.go

@@ -0,0 +1,177 @@
+package bodycheck
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"strings"
+
+	"github.com/astaxie/beego"
+	"github.com/astaxie/beego/config"
+)
+
+// WechatInfo 微信接入
+func (c *BodyCheckController) WechatInfo() {
+	// signature := c.GetString("signature")
+	// timestamp := c.GetString("timestamp")
+	// nonce := c.GetString("nonce")
+	echostr := c.GetString("echostr")
+	c.ResponseRaw([]byte(echostr))
+}
+
+// GetQrcodeURL 获取二维码信息
+func (c *BodyCheckController) GetQrcodeURL() {
+	EquipmentID := c.GetString("EquipmentId")
+	qrcodePrefix := beego.AppConfig.String("qrcodePrefix")
+	qrcode, err := c.weixin.GetTempStrQRCode(qrcodePrefix + EquipmentID)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":    true,
+		"Message":   "",
+		"QrcodeUrl": qrcode,
+	})
+}
+
+// WxReceive 微信消息接收
+func (c *BodyCheckController) WxReceive() {
+	r := c.Ctx.Request
+	defer r.Body.Close()
+	con, _ := ioutil.ReadAll(r.Body) //获取post的数据
+	val, err := c.weixin.TransformMessage(string(con))
+	if err != nil {
+		beego.Error(err.Error())
+		c.ResponseRaw([]byte(""))
+	}
+
+	if val["MsgType"] == "event" {
+		qrcodePrefix := beego.AppConfig.String("qrcodePrefix")
+		if (val["Event"] == "subscribe" && strings.Contains(val["EventKey"], "qrscene_"+qrcodePrefix)) || val["Event"] == "SCAN" {
+			EquipmentID := strings.Split(val["EventKey"], qrcodePrefix)[1]
+			messagetxt, err := c.scanDo(val, EquipmentID)
+			if err != nil {
+				beego.Error(err.Error())
+				c.ResponseRaw([]byte(""))
+			}
+			c.ResponseRaw(messagetxt)
+		}
+	}
+	c.ResponseRaw([]byte(""))
+}
+
+func (c *BodyCheckController) scanDo(val map[string]string, EquipmentID string) ([]byte, error) {
+	if val["FromUserName"] == "" {
+		return nil, errors.New("openid为空")
+	}
+
+	user, err := c.weixin.GetUserDetail(val["FromUserName"])
+	if err != nil {
+		return nil, err
+	}
+
+	// 判断用户是否存在
+	getUser, err := c.dao.GetUserByOpenID(user["openid"].(string))
+	if err != nil {
+		return nil, err
+	}
+	name := user["nickname"].(string)
+	name = UnicodeEmojiCode(name)
+	user["nickname"] = name
+	if getUser == nil || getUser.Id < 1 {
+		// 新增用户
+		var newUser = model.CustomerUser{}
+		newUser.Username = name
+		newUser.WcNickname = name
+		sex := int(user["sex"].(float64))
+		if sex == 2 {
+			sex = 1
+		} else {
+			sex = 0
+		}
+		newUser.Sex = sex
+		newUser.OpenId = user["openid"].(string)
+		newUser.Icon = user["headimgurl"].(string)
+		newUser.UserType = 4
+		newUser.ActualBalance = "0.00"
+		newUser.GiftBalance = "0.00"
+		_, err = c.dao.SaveUser(newUser)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	type WechatInfo struct {
+		EquipmentId    string
+		WXID           int
+		WechatUserInfo map[string]interface{}
+	}
+	wxconf, _ := config.NewConfig("ini", "conf/wechat.conf")
+	user["wechataccount"] = user["openid"].(string)
+	user["wechatofficial"] = wxconf.String("appid")
+	var userinfo = WechatInfo{}
+	userinfo.EquipmentId = EquipmentID
+	userinfo.WechatUserInfo = user
+	userinfo.WXID = 1
+
+	apiPrefix := beego.AppConfig.String("postwechatInfo")
+
+	b, err := json.Marshal(userinfo)
+	if err != nil {
+		return nil, err
+	}
+
+	body := bytes.NewBuffer([]byte(b))
+	beego.Error(body)
+	res, err := http.Post(apiPrefix, "application/json;charset=utf-8", body)
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	result, err := ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	var postResult struct {
+		Status  bool
+		Message string
+	}
+	if err = json.Unmarshal(result, &postResult); err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+
+	if !postResult.Status {
+		beego.Error(postResult.Message)
+		return nil, errors.New(postResult.Message)
+	}
+
+	messagetxt, err := c.weixin.ResponseMessageText(user["openid"].(string), beego.AppConfig.String("followText"))
+	if err != nil {
+		beego.Error(err)
+		return nil, err
+	}
+	return messagetxt, nil
+}
+
+// UnicodeEmojiCode 过滤表情
+func UnicodeEmojiCode(s string) string {
+	ret := ""
+	rs := []rune(s)
+	for i := 0; i < len(rs); i++ {
+		if len(string(rs[i])) == 4 {
+			// u := `[\u` + strconv.FormatInt(int64(rs[i]), 16) + `]`
+			ret += ""
+		} else {
+			ret += string(rs[i])
+		}
+	}
+	return ret
+}

controllers/coupon/coupon.go

@@ -6,10 +6,10 @@ import (
 	"net/http"
 	"spaceofcheng/services/controllers"
 	cpModel "spaceofcheng/services/models/coupon"
+	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/coupon"
 	"spaceofcheng/services/utils"
 	"strings"
-	"tolet/models/model"
 )
 
 // CouponController 商品

controllers/gymcard/gymcard.go

@@ -119,18 +119,18 @@ func (c *GymcardController) SendGymToCustomer() {
 	c.ResponseJSON(customerGym)
 }
 
-// SendGymToCustomer 后台发卡给客户
-func (c *GymcardController) BackSendGymToCustomer() {
-	gymcardId := c.GetString(":gymcardId")
-	customerId := c.GetString(":customerId")
-	sysUser := c.Context.Get("user").(model.SysUser)
-	userId := sysUser.UserId
-	customerGym, err := c.dao.BackSendGymCardToUser(gymcardId, userId, customerId)
-	if err != nil {
-		c.ResponseError(err)
-	}
-	c.ResponseJSON(customerGym)
-}
+// // SendGymToCustomer 后台发卡给客户
+// func (c *GymcardController) BackSendGymToCustomer() {
+// 	gymcardId := c.GetString(":gymcardId")
+// 	customerId := c.GetString(":customerId")
+// 	sysUser := c.Context.Get("user").(model.SysUser)
+// 	userId := sysUser.UserId
+// 	customerGym, err := c.dao.BackSendGymCardToUser(gymcardId, userId, customerId)
+// 	if err != nil {
+// 		c.ResponseError(err)
+// 	}
+// 	c.ResponseJSON(customerGym)
+// }
 
 // VerifyCustomerGymcard 核销客户健身卡
 func (c *GymcardController) VerifyCustomerGymcard() {

controllers/luckdraw/luckdraw.go

@@ -0,0 +1,357 @@
+package luckdraw
+
+import (
+	"spaceofcheng/services/controllers"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/service/luckdraw"
+	"strconv"
+)
+
+// LuckdrawController 应用
+type LuckdrawController struct {
+	dao *luckdraw.LuckdrawServ
+	controllers.BaseController
+}
+
+// Constructor 初始化 Controller
+// @Title Constructor
+// @Description 初始化 Controller, 系统自动调用
+func (c *LuckdrawController) Constructor() {
+	c.dao = luckdraw.NewLuckdrawServ(c.Context)
+	org := c.Context.Get("org").(model.SysOrg)
+}
+
+// GetUserByCode 根据code获取用户信息
+func (c *LuckDrawController) GetUserByCode() {
+	custID := 0
+	encodeUser, _ := c.GetInt("from")
+	if encodeUser != 0 {
+		encodeUser = helper.IntXOR(encodeUser, 97)
+		enStr := strconv.Itoa(encodeUser)
+		enStr = enStr[:len(enStr)-3]
+
+		custID, _ = strconv.Atoi(enStr)
+	}
+
+	code := c.GetString("code")
+	if c.openid == "" && code == "" && custID == 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "401-" + c.weixin.GetAppID(),
+		})
+	}
+
+	var user *model.CustomerUser
+	if custID != 0 {
+		var err error
+		user, err = c.bodydao.GetCustomerByID(custID)
+		if err != nil {
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": helper.LogError("获取用户信息失败", err.Error()).Error(),
+			})
+		}
+
+		c.openid = user.OpenId
+	}
+
+	if c.openid == "" {
+		openid, err := c.weixin.GetOpenID(code)
+		if err != nil {
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": helper.LogError("获取微信 OpenId 失败", err.Error()).Error(),
+			})
+		}
+
+		c.openid = openid
+		c.SetSession("openid", openid)
+	}
+
+	if user == nil {
+		var err error
+		user, err = c.bodydao.GetUserByOpenID(c.openid)
+		if err != nil {
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": helper.LogError("获取用户信息失败", err.Error()).Error(),
+			})
+		}
+	}
+
+	if user == nil || user.Tel == "" {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  true,
+			"Message": 406,
+		})
+	}
+
+	luckdrawid, _ := c.GetInt("luckdrawid")
+	record, err := c.dao.GetUserLuckDrawByLuckDraw(user.Id, luckdrawid)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取用户抽奖信息失败", err.Error()).Error(),
+		})
+	}
+	var detail *model.TaPrizeDetail
+	if record != nil {
+		detail, err = c.dao.GetDetailByRecord(record.Id)
+		if err != nil {
+			c.ResponseJson(map[string]interface{}{
+				"Status":  false,
+				"Message": helper.LogError("获取用户抽奖信息失败", err.Error()).Error(),
+			})
+		}
+	}
+
+	c.ResponseJson(map[string]interface{}{
+		"Status": true,
+		"Message": map[string]interface{}{
+			"user":   user,
+			"record": record,
+			"detail": detail,
+		},
+	})
+}
+
+// GetLuckDraw 获取抽奖信息
+func (c *LuckDrawController) GetLuckDraw() {
+	id, _ := c.GetInt(":id")
+	luckdraw, err := c.dao.GetLuckDraw(id)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取抽奖信息失败", err.Error()).Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":  true,
+		"Message": luckdraw,
+	})
+}
+
+// LuckDraw 抽奖
+func (c *LuckDrawController) LuckDraw() {
+	if c.openid == "" {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "401-" + c.weixin.GetAppID(),
+		})
+	}
+
+	id, _ := c.GetInt(":id")
+	user, err := c.bodydao.GetUserByOpenID(c.openid)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取用户信息失败", err.Error()).Error(),
+		})
+	}
+
+	prize, detail, err := c.dao.LuckDraw(id, user)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": err.Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status": true,
+		"Message": map[string]interface{}{
+			"prize":  prize,
+			"detail": detail,
+		},
+	})
+}
+
+// GetRecordByLuckDraw 获取抽奖记录
+func (c *LuckDrawController) GetRecordByLuckDraw() {
+	id, _ := c.GetInt("id")
+	records, err := c.dao.GetRecordByLuckDraw(id)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取抽奖记录失败", err.Error()).Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":  true,
+		"Message": records,
+	})
+}
+
+// GetUserLuckDraw 获取用户的抽奖记录
+func (c *LuckDrawController) GetUserLuckDraw() {
+	userid, _ := c.GetInt("userid")
+	records, err := c.dao.GetUserLuckDraw(userid)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取用户抽奖记录失败", err.Error()).Error(),
+		})
+	}
+	c.ResponseJson(map[string]interface{}{
+		"Status":  true,
+		"Message": records,
+	})
+}
+
+// GetRecordByID 根据ID获取中奖记录信息
+func (c *LuckDrawController) GetRecordByID() {
+	id, _ := c.GetInt(":id")
+	record, err := c.dao.GetRecordByID(id)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取中奖记录失败", err.Error()).Error(),
+		})
+	}
+
+	caseAddress, err := c.dao.GetCaseAddressByLuckDarw(record.LuckdrawId)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("获取案场信息失败", err.Error()).Error(),
+		})
+	}
+
+	if caseAddress == "" {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "无案场, 或案场地址没有维护",
+		})
+	}
+
+	prize, err := c.dao.GetPrizeByID(record.PrizeId)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": helper.LogError("校验奖品记录失败", err.Error()).Error(),
+		})
+	}
+
+	c.ResponseJson(map[string]interface{}{
+		"Status": true,
+		"Message": map[string]interface{}{
+			"record":      record,
+			"prize":       prize,
+			"caseAddress": caseAddress,
+		},
+	})
+}
+
+func (c *LuckDrawController) SaveShareRecord() {
+	if c.openid == "" {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": "401-" + c.weixin.GetAppID(),
+		})
+	}
+
+	errPrefix := "logerror-"
+
+	id, _ := c.GetInt(":id")
+
+	fromID, _ := c.GetInt("from")
+	if fromID == 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + "没有分享人ID",
+		})
+	}
+
+	from, err := c.bodydao.GetCustomerByID(fromID)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("获取分享人信息失败", err.Error()).Error(),
+		})
+	}
+
+	if from == nil || from.Id == 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("分享人信息不存在").Error(),
+		})
+	}
+
+	current, err := c.bodydao.GetUserByOpenID(c.openid)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("获取当前人员信息失败", err.Error()).Error(),
+		})
+	}
+
+	if current == nil || current.Id == 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + "系统错误, 无当前人员信息",
+		})
+	}
+
+	// 自己分享给自己
+	if from.Id == current.Id {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + "本人分享内容无效",
+		})
+	}
+
+	luckdraw, err := c.dao.GetLuckDrawByID(id)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("获取抽奖信息失败", err.Error()).Error(),
+		})
+	}
+
+	if luckdraw == nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("没有找到 id ("+strconv.Itoa(id)+") 对应的抽奖信息").Error(),
+		})
+	}
+
+	existsRec, err := c.dao.GetLuckDrawShareData(from.Id, current.Id, luckdraw.Id, luckdraw.CaseId)
+	if err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("获取已有分享信息失败", err.Error()).Error(),
+		})
+	}
+
+	if existsRec != nil && len(existsRec) > 0 {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + "已分享记录, 再次分享无效",
+		})
+	}
+
+	shareDt := model.TaShareLuckyRecord{
+		FromCustomerId:     from.Id,
+		FromCustomerName:   from.Username,
+		FromCustomerWxname: from.WcNickname,
+		FromCustomerTel:    from.Tel,
+		ToCustomerId:       current.Id,
+		ToCustomerName:     current.Username,
+		ToCustomerWxname:   current.WcNickname,
+		ToCustomerTel:      current.Tel,
+		CaseId:             luckdraw.CaseId,
+		LuckydrawId:        luckdraw.Id,
+		LuckydrawName:      luckdraw.Name,
+	}
+
+	if err := c.dao.SaveLuckDrawShareData(&shareDt); err != nil {
+		c.ResponseJson(map[string]interface{}{
+			"Status":  false,
+			"Message": errPrefix + helper.LogError("保存分享记录失败", err.Error()).Error(),
+		})
+	}
+
+	c.ResponseJson(map[string]interface{}{
+		"Status":  true,
+		"Message": "ok",
+	})
+}

controllers/verify/verify.go

@@ -5,6 +5,7 @@ import (
 	"spaceofcheng/services/models"
 	"spaceofcheng/services/models/model"
 	"spaceofcheng/services/service/verify"
+	"time"
 )
 
 // CaseController 信息
@@ -70,11 +71,20 @@ func (c *VerifyController) VerifyCourse() {
 			c.ResponseError(err)
 		}
 		if customerCard.VerifyStatus == models.VERIFY_USEABLE {
-			customerCard.VerifyStatus = models.VERIFY_USED
-			err := c.dao.UpdateCustomerCard(customerCard)
-			if err != nil {
-				c.ResponseError(err)
+			if customerCard.EndDate.After(time.Now()) {
+				customerCard.VerifyStatus = models.VERIFY_LATE
+				err := c.dao.UpdateCustomerCard(customerCard)
+				if err != nil {
+					c.ResponseError(err)
+				}
+			} else {
+				customerCard.VerifyStatus = models.VERIFY_USED
+				err := c.dao.UpdateCustomerCard(customerCard)
+				if err != nil {
+					c.ResponseError(err)
+				}
 			}
+
 		}
 	}
 	err = c.dao.UpdateCustomerCourse(customerCourse)

models/bodycheck/bodycheck.go

@@ -24,7 +24,7 @@ func NewDAO(ctx *utils.Context) *DAO {
 }
 
 // GetBodyCheckByUser 根据用户信息获取体检信息
-func (m *DAO) GetBodyCheckByUser(userID int) ([]model.TaBodyCheck, error) {
+func (m *DAO) GetBodyCheckByUser(userID string) ([]model.TaBodyCheck, error) {
 	var bodychecks []model.TaBodyCheck
 	var err error
 	err = m.db.Where("user_id=?", userID).And("status=?", 1).Desc("create_date").Find(&bodychecks)
@@ -39,7 +39,7 @@ func (m *DAO) GetCheckSpecs() ([]model.TdCheckSpec, error) {
 }
 
 // GetCheckByUserAndEquipmentID 根据用户与设备ID获取体检信息
-func (m *DAO) GetCheckByUserAndEquipmentID(userID int, EquipmentID string) (*model.TaBodyCheck, error) {
+func (m *DAO) GetCheckByUserAndEquipmentID(userID string, EquipmentID string) (*model.TaBodyCheck, error) {
 	var check []model.TaBodyCheck
 	err := m.db.Where("user_id=?", userID).And("equipment_id=?", EquipmentID).And("status=?", 1).Desc("create_date").Find(&check)
 	if err != nil {
@@ -82,9 +82,9 @@ func (m *DAO) GetUserByOpenID(openid string) (*model.TaCustomer, error) {
 }
 
 // GetCustomerByID 根据客户ID 获取用户信息
-func (m *DAO) GetCustomerByID(id int) (*model.TaCustomer, error) {
+func (m *DAO) GetCustomerByID(id string) (*model.TaCustomer, error) {
 	var cust model.TaCustomer
-	_, err := m.db.Where("id=?", id).Get(&cust)
+	_, err := m.db.Where("customer_id=?", id).Get(&cust)
 	return &cust, err
 }
 

models/luckdraw/luckdraw.go

@@ -0,0 +1,445 @@
+package luckdraw
+
+import (
+	"spaceofcheng/services/models"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+	"strconv"
+	"time"
+
+	"github.com/go-xorm/xorm"
+)
+
+const (
+	StatusNormal = 1
+)
+
+// DAO 当前数据库操作对象
+type DAO struct {
+	ctx *utils.Context
+	db  *xorm.Session
+}
+
+// NewDAO 初始化DAO
+func NewDAO(ctx *utils.Context) *DAO {
+	return &DAO{
+		ctx: ctx,
+		db:  ctx.DB,
+	}
+}
+
+const (
+	STATUS_NOWRITROFF = 0
+)
+
+// LuckDraw 抽奖记录
+type LuckDraw struct {
+	model.TaLuckdraw `xorm:"extends"`
+	Prizes           []model.TaLuckdrawPrize
+}
+
+// GetLuckDraw 获取抽奖信息
+func (m *DAO) GetLuckDraw(id int) (*LuckDraw, error) {
+	if id == 0 {
+		return nil, utils.LogError("不存在抽奖信息！")
+	}
+
+	luckdraw, err := m.GetLuckDrawByID(id)
+	if err != nil {
+		return nil, err
+	}
+	prizes, err := m.GetPrizes(id)
+	if err != nil {
+		return nil, err
+	}
+	luckdraw.Prizes = prizes
+	return luckdraw, nil
+}
+
+// LuckDraw 抽奖
+func (m *DAO) LuckDraw(id int, user *model.TaCustomer) (*model.TaLuckdrawPrize, *model.TaPrizeDetail, error) {
+	luckdraw, err := m.GetLuckDrawByID(id)
+	if err != nil {
+		return nil, nil, utils.LogError("获取抽奖信息失败！", err)
+	}
+	if luckdraw.Status != models.STATUS_NORMAL {
+		return nil, nil, utils.LogError("当前抽奖活动状态异常！")
+	}
+	if time.Now().Before(luckdraw.BeginDate) {
+		return nil, nil, utils.LogError("活动还未开始！")
+	}
+	if time.Now().After(luckdraw.EndDate) {
+		return nil, nil, utils.LogError("活动已结束！")
+	}
+	if user.Phone != "" {
+		sysuser, err := m.GetUserByTel(user.Phone)
+		if err != nil {
+			return nil, nil, utils.LogError("获取信息失败！", err)
+		}
+		if sysuser != nil {
+			return nil, nil, utils.LogError("内部人员不允许进行抽奖！")
+		}
+	}
+	userluckdraws, err := m.GetUserRecordByLuckDraw(user.CustomerId, id)
+	if err != nil {
+		return nil, nil, utils.LogError("获取用户抽奖信息失败！", err)
+	}
+	if len(userluckdraws) > 0 {
+		return nil, nil, utils.LogError("您已参与过此次抽奖，不允许重复抽奖！")
+	}
+	prizes, err := m.GetPrizeStock(id)
+	if err != nil {
+		return nil, nil, utils.LogError("获取奖项失败！", err)
+	}
+	if len(prizes) == 0 {
+		err = m.UpdateLuckDrawEndDate(luckdraw.Id)
+		if err != nil {
+			return nil, nil, utils.LogError("操作失败，请刷新后重试！", err)
+		}
+		return nil, nil, utils.LogError("活动已结束！")
+	}
+	prize, err := m.GetWinning(prizes)
+	if err != nil {
+		return nil, nil, utils.LogError("获取奖项失败！", err)
+	}
+
+	details, err := m.GetPrizeDetail(prize.Id)
+	if err != nil {
+		return nil, nil, utils.LogError("获取奖项详情失败！", err)
+	}
+
+	// 保存中奖记录
+	var record = model.TaLuckdrawRecord{}
+	record.OrgId = luckdraw.OrgId
+	record.CaseId = luckdraw.CaseId
+	record.PrizeId = prize.Id
+	record.PrizeName = prize.PrizeName
+	record.UserId = user.CustomerId
+	record.UserName = user.Name
+	record.UserHeadImg = user.Headimgurl
+	record.LuckdrawId = luckdraw.Id
+	newrecord, err := m.SaveRecord(record)
+	var detail = model.TaPrizeDetail{}
+	if len(details) > 0 {
+		// 更新中奖纪录明细
+		details[0].ReceiveId = newrecord.Id
+		err = m.UpdatePrizeDetail(details[0])
+		if err != nil {
+			return nil, nil, utils.LogError("操作失败！", err)
+		}
+		detail = details[0]
+		// 奖项自动核销，走卡券核销流程
+		err = m.PrizeWriteOff(newrecord.Id, user.CustomerId)
+		if err != nil {
+			return nil, nil, utils.LogError("操作失败！", err)
+		}
+	}
+	// 更新库存
+	if prize.IsReality == 1 {
+		prize.Remainder = prize.Remainder - 1
+		err = m.UpdateStock(prize)
+		if err != nil {
+			return nil, nil, err
+		}
+		stockprizes, err := m.GetPrizeStock(id)
+		if err != nil {
+			return nil, nil, utils.LogError("操作失败，请刷新后重试！", err)
+		}
+		if len(stockprizes) == 0 {
+			// 更新活动截止时间
+			err = m.UpdateLuckDrawEndDate(luckdraw.Id)
+		}
+	}
+
+	return prize, &detail, err
+}
+
+// PrizeWriteOff 奖品核销
+func (m *DAO) PrizeWriteOff(recordid int, userid string) error {
+	record, err := m.GetRecordByID(recordid)
+	if err != nil {
+		return err
+	}
+	var writeoff = model.TaLuckdrawWriteoff{}
+	writeoff.LuckdrawId = record.LuckdrawId
+	writeoff.CaseId = record.CaseId
+	writeoff.OrgId = record.OrgId
+	writeoff.RecordId = record.Id
+	writeoff.WriteoffUser = userid
+	_, err = m.SaveWirteOff(writeoff)
+	if err != nil {
+		return err
+	}
+	err = m.UpdateRecord(record)
+	return err
+}
+
+// GetWinning 获取中奖信息
+func (m *DAO) GetWinning(prizes []model.TaLuckdrawPrize) (*model.TaLuckdrawPrize, error) {
+	pList := make([]map[string]interface{}, 0)
+	now := time.Now().Local()
+
+	for _, prize := range prizes {
+		// 有剩余的 并且 未过期的
+		if prize.Remainder > 0 && now.Before(prize.VerificationEnd) {
+			p := map[string]interface{}{
+				"prize": prize,
+				"prob":  prize.Probability,
+			}
+
+			pList = append(pList, p)
+		}
+	}
+
+	if len(pList) == 0 {
+		return nil, utils.LogError("所有奖品已抽完")
+	}
+
+	thePrize := utils.LuckyDraw(pList).(model.TaLuckdrawPrize)
+
+	return &thePrize, nil
+}
+
+// GetLuckDrawByID 获取抽奖信息
+func (m *DAO) GetLuckDrawByID(id int) (*LuckDraw, error) {
+	var luckdraws []LuckDraw
+	sql := `select * from ta_luckdraw where id= ?`
+	err := m.db.SQL(sql, id).Find(&luckdraws)
+	if err != nil {
+		return nil, err
+	}
+	if len(luckdraws) > 0 {
+		return &luckdraws[0], nil
+	}
+	return nil, nil
+}
+
+// GetCaseAddressByLuckDarw 获取案场地址
+func (m *DAO) GetCaseAddressByLuckDarw(luckdraw int) (string, error) {
+	sql := `
+		SELECT
+			t.address
+		FROM
+			sys_case t
+		INNER JOIN ta_luckdraw s ON t.case_id = s.case_id
+		WHERE
+			s.id = ?
+	`
+
+	res, err := m.db.Query(sql, luckdraw)
+	if err != nil {
+		return "", err
+	}
+
+	if res == nil || len(res) == 0 {
+		return "", nil
+	}
+
+	return string(res[0]["address"]), nil
+}
+
+// UpdateLuckDrawEndDate 更新活动结束时间
+func (m *DAO) UpdateLuckDrawEndDate(id int) error {
+	var luckdraw = model.TaLuckdraw{
+		Id:      id,
+		EndDate: time.Now(),
+	}
+	cols := []string{
+		"end_date",
+	}
+	_, err := m.db.Update(luckdraw, cols, "id=?", id)
+	return err
+}
+
+// GetPrizes 获取奖品信息
+func (m *DAO) GetPrizes(luckdrawid int) ([]model.TaLuckdrawPrize, error) {
+	var prizes []model.TaLuckdrawPrize
+	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status=?", models.STATUS_NORMAL).Find(&prizes)
+	return prizes, err
+}
+
+// UpdateStock 修改库存
+func (m *DAO) UpdateStock(prize *model.TaLuckdrawPrize) error {
+	cols := []string{
+		"remainder",
+	}
+	_, err := m.db.Update(prize, cols, "id=?", prize.Id)
+	return err
+}
+
+// GetPrizeStock 判断奖项库存
+func (m *DAO) GetPrizeStock(luckdrawid int) ([]model.TaLuckdrawPrize, error) {
+	var prizes []model.TaLuckdrawPrize
+	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status=?", models.STATUS_NORMAL).And("(remainder>0 or is_reality=0)").Find(&prizes)
+	return prizes, err
+}
+
+// GetPrizeByID 根据id获取奖品信息
+func (m *DAO) GetPrizeByID(id int) (model.TaLuckdrawPrize, error) {
+	var prize = model.TaLuckdrawPrize{}
+	_, err := m.db.Where("id=?", id).Get(&prize)
+	return prize, err
+}
+
+// SaveRecord 保存抽奖记录
+func (m *DAO) SaveRecord(record model.TaLuckdrawRecord) (*model.TaLuckdrawRecord, error) {
+	record.CreateDate = time.Now()
+	record.Status = STATUS_NOWRITROFF
+	_, err := m.db.Insert(&record)
+	return &record, err
+}
+
+// GetPrizeDetail 获取未领取的奖品详情
+func (m *DAO) GetPrizeDetail(prizeid int) ([]model.TaPrizeDetail, error) {
+	var details []model.TaPrizeDetail
+	err := m.db.Where("prize_id=?", prizeid).And("status=?", STATUS_NOWRITROFF).Find(&details)
+	return details, err
+}
+
+// UpdatePrizeDetail 更新库存明细为已领取
+func (m *DAO) UpdatePrizeDetail(detail model.TaPrizeDetail) error {
+	detail.Status = models.STATUS_NORMAL
+	detail.ReceiveDate = time.Now()
+	cols := []string{
+		"status",
+		"receive_id",
+		"receive_date",
+	}
+	_, err := m.db.Update(detail, cols, "id=?", detail.Id)
+	return err
+}
+
+// UpdateRecord 核销更新抽奖记录表
+func (m *DAO) UpdateRecord(record *model.TaLuckdrawRecord) error {
+	record.Status = models.STATUS_NORMAL
+	record.WriteoffDate = time.Now()
+	cols := []string{
+		"status",
+		"writeoff_date",
+	}
+	_, err := m.db.Update(record, cols, "id=?", record.Id)
+	return err
+}
+
+// SaveWirteOff 保存核销信息
+func (m *DAO) SaveWirteOff(writeoff model.TaLuckdrawWriteoff) (*model.TaLuckdrawWriteoff, error) {
+	writeoff.Status = models.STATUS_NORMAL
+	writeoff.WriteoffDate = time.Now()
+	_, err := m.db.Insert(&writeoff)
+	return &writeoff, err
+}
+
+// GetUserRecordByLuckDraw 获取用户的抽奖信息
+func (m *DAO) GetUserRecordByLuckDraw(userid string, luckdrawid int) ([]model.TaLuckdrawRecord, error) {
+	var records []model.TaLuckdrawRecord
+	err := m.db.Where("user_id=?", userid).And("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&records)
+	return records, err
+}
+
+// GetUserLuckDrawByLuckDraw 获取用户的抽奖信息
+func (m *DAO) GetUserLuckDrawByLuckDraw(userid string, luckdrawid int) (*model.TaLuckdrawRecord, error) {
+	var records []model.TaLuckdrawRecord
+	err := m.db.Where("user_id=?", userid).And("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&records)
+	if err != nil {
+		return nil, err
+	}
+	if len(records) > 0 {
+		return &records[0], nil
+	}
+	return nil, nil
+}
+
+// GetDetailByRecord 获取detail
+func (m *DAO) GetDetailByRecord(recordid int) (*model.TaPrizeDetail, error) {
+	var details []model.TaPrizeDetail
+	err := m.db.Where("receive_id=?", recordid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Find(&details)
+	if err != nil {
+		return nil, err
+	}
+	if len(details) > 0 {
+		return &details[0], nil
+	}
+	return nil, nil
+}
+
+// UserRecord 用户抽奖信息
+type UserRecord struct {
+	model.TaLuckdrawRecord `xorm:"extends"`
+	Url                    string
+}
+
+// GetUserLuckDraw 获取用户的抽奖信息
+func (m *DAO) GetUserLuckDraw(userid string) ([]UserRecord, error) {
+	var records []UserRecord
+	sql := `select a.*,b.url from ta_luckdraw_record a left join ta_prize_detail b on a.id=b.receive_id where a.user_id=? and a.status>` + strconv.Itoa(models.STATUS_DEL)
+	err := m.db.Sql(sql, userid).Find(&records)
+	return records, err
+}
+
+// GetRecordByLuckDraw 抽奖记录
+func (m *DAO) GetRecordByLuckDraw(luckdrawid int) ([]model.TaLuckdrawRecord, error) {
+	var records []model.TaLuckdrawRecord
+	err := m.db.Where("luckdraw_id=?", luckdrawid).And("status>" + strconv.Itoa(models.STATUS_DEL)).Desc("create_date").Find(&records)
+	return records, err
+}
+
+// GetRecordByID 获取抽奖记录明细
+func (m *DAO) GetRecordByID(id int) (*model.TaLuckdrawRecord, error) {
+	var record model.TaLuckdrawRecord
+	_, err := m.db.Where("id=?", id).Get(&record)
+	return &record, err
+}
+
+// GetUserByOpenID 根据 openid 获取用户人员信息
+func (m *DAO) GetUserByOpenID(openid string) (*model.SysUser, error) {
+	var users []model.SysUser
+	err := m.db.Where("open_id=?", openid).Find(&users)
+	if err != nil {
+		return nil, err
+	}
+	if len(users) > 0 {
+		return &users[0], nil
+	}
+	return nil, nil
+}
+
+// GetUserByTel 根据 Tel 获取用户人员信息
+func (m *DAO) GetUserByTel(tel string) (*model.SysUser, error) {
+	var users = model.SysUser{}
+	has, err := m.db.Where("phone=?", tel).Get(&users)
+	if err != nil {
+		return nil, err
+	}
+	if !has {
+		return nil, nil
+	}
+	return &users, nil
+}
+
+// SaveLuckDrawShareData 保存用户分享信息
+func (m *DAO) SaveLuckDrawShareData(dt *model.TaShareLuckyRecord) error {
+	dt.CreateDate = time.Now().Local()
+	dt.Status = StatusNormal
+
+	if _, err := m.db.Insert(dt); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetLuckDrawShareData 获取用户分享内容
+func (m *DAO) GetLuckDrawShareData(luckID int, from, to, caseID string) ([]model.TaShareLuckyRecord, error) {
+	var dts []model.TaShareLuckyRecord
+
+	if err := m.db.Where("from_customer_id=?", from).
+		And("to_customer_id=?", to).
+		And("luckydraw_id=?", luckID).
+		And("case_id=?", caseID).
+		And("status=?", StatusNormal).
+		Find(&dts); err != nil {
+		return nil, err
+	}
+
+	return dts, nil
+}

models/model/ta_luckdraw.go

@@ -12,7 +12,7 @@ type TaLuckdraw struct {
 	BeginDate    time.Time `xorm:"DATETIME"`
 	EndDate      time.Time `xorm:"DATETIME"`
 	OrgId        string    `xorm:"VARCHAR(64)"`
-	CaseId       int       `xorm:"INT(11)"`
+	CaseId       string    `xorm:"VARCHAR(64)"`
 	CreateDate   time.Time `xorm:"DATETIME"`
 	CreateUser   string    `xorm:"VARCHAR(64)"`
 	Remark       string    `xorm:"TEXT"`

routers/wechat.go

@@ -1,6 +1,7 @@
 package routers
 
 import (
+	"spaceofcheng/services/controllers/bodycheck"
 	"spaceofcheng/services/controllers/card"
 	"spaceofcheng/services/controllers/coupon"
 	"spaceofcheng/services/controllers/course"
@@ -68,5 +69,10 @@ func getWechatRoutes() beego.LinkNamespace {
 		beego.NSRouter("/card/detail/:id", &card.CardController{}, "get:GetCardWithCustomer"),
 		beego.NSRouter("/card/:id", &card.CardController{}, "post:ReceiveCard"),
 		beego.NSRouter("/channel/card/:id", &card.CardController{}, "post:ChannelReceiveCard"),
+
+		// 体检
+		beego.NSRouter("/GetCheckByUser", &bodycheck.BodyCheckController{}, "get:GetCheckByUser"),
+		beego.NSRouter("/PostCheckResult", &bodycheck.BodyCheckController{}, "post:PostCheckResult"),
+		beego.NSRouter("/GetQrcodeURL", &bodycheck.BodyCheckController{}, "get:GetQrcodeURL"),
 	)
 }

service/bodycheck/bodycheck.go

@@ -20,7 +20,7 @@ func NewBodycheckServ(ctx *utils.Context) *BodycheckServ {
 		dao: bodycheck.NewDAO(ctx),
 	}
 }
-func (s *BodycheckServ) GetBodyCheckByUser(userID int) ([]model.TaBodyCheck, error) {
+func (s *BodycheckServ) GetBodyCheckByUser(userID string) ([]model.TaBodyCheck, error) {
 	bodychecks, err := s.dao.GetBodyCheckByUser(userID)
 	if err != nil {
 		utils.LogError("查询用户体检信息失败: " + err.Error())
@@ -36,7 +36,7 @@ func (s *BodycheckServ) GetCheckSpecs() ([]model.TdCheckSpec, error) {
 	}
 	return specs, nil
 }
-func (s *BodycheckServ) GetCheckByUserAndEquipmentID(userID int, EquipmentID string) (*model.TaBodyCheck, error) {
+func (s *BodycheckServ) GetCheckByUserAndEquipmentID(userID string, EquipmentID string) (*model.TaBodyCheck, error) {
 	check, err := s.dao.GetCheckByUserAndEquipmentID(userID, EquipmentID)
 	if err != nil {
 		utils.LogError("根据用户与设备ID获取体检信息失败: " + err.Error())

service/gymcard/gymcard.go

@@ -196,34 +196,37 @@ func (s *GymcardServ) SendGymCardToUser(gymcardId, sysuserId string) (*model.TaC
 	return customerGym, nil
 }
 
-// SendGymCardToUser 后台给客户发卡
-func (s *GymcardServ) BackSendGymCardToUser(gymcardId, sysuserId, customerId string) (*model.TaCustomerGym, error) {
-	var customerGym *model.TaCustomerGym
-	var sysuser *model.SysUser
-	gymCard, err := s.dao.GetGymcardById(gymcardId)
-	if err != nil {
-		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
-		return nil, errors.New("发送游泳健身卡给客户失败")
-	}
-	sysuser, err = s.cdao.GetUserByID(sysuserId)
-	if err != nil {
-		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
-		return nil, errors.New("发送游泳健身卡给客户失败")
-	}
-	gymCard.SentCount = gymCard.SentCount + 1
-	customerGym, err = s.dao.SendGymcardToCustomer(&gymCard.TaGymCard, customerId, sysuserId, sysuser.RealName)
-	if err != nil {
-		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
-		return nil, errors.New("发送游泳健身卡给客户失败")
-	}
+// // SendGymCardToUser 后台给客户发卡
+// func (s *GymcardServ) BackSendGymCardToUser(gymcardId, sysuserId, customerId string) (*model.TaCustomerGym, error) {
+// 	var customerGym *model.TaCustomerGym
+// 	var sysuser *model.SysUser
+// 	gymCard, err := s.dao.GetGymcardById(gymcardId)
+// 	if err != nil {
+// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+// 		return nil, errors.New("发送游泳健身卡给客户失败")
+// 	}
+// 	if gymCard.TotalCount-gymCard.SentCount < 1 {
+// 		return nil, errors.New("健身卡剩余数量不足！")
+// 	}
+// 	sysuser, err = s.cdao.GetUserByID(sysuserId)
+// 	if err != nil {
+// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+// 		return nil, errors.New("发送游泳健身卡给客户失败")
+// 	}
+// 	gymCard.SentCount = gymCard.SentCount + 1
+// 	customerGym, err = s.dao.SendGymcardToCustomer(&gymCard.TaGymCard, customerId, sysuserId, sysuser.RealName,)
+// 	if err != nil {
+// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+// 		return nil, errors.New("发送游泳健身卡给客户失败")
+// 	}
 
-	err = s.dao.EditGymcard(&gymCard.TaGymCard)
-	if err != nil {
-		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
-		return nil, errors.New("发送游泳健身卡给客户失败")
-	}
-	return customerGym, nil
-}
+// 	err = s.dao.EditGymcard(&gymCard.TaGymCard)
+// 	if err != nil {
+// 		utils.LogError("发送游泳健身卡给客户失败" + err.Error())
+// 		return nil, errors.New("发送游泳健身卡给客户失败")
+// 	}
+// 	return customerGym, nil
+// }
 
 // UpdateCustomerGym 核销游泳健身卡
 func (s *GymcardServ) UpdateCustomerGym(customerGymId, caseid string) error {

service/luckdraw/luckdraw.go

@@ -0,0 +1,237 @@
+package luckdraw
+
+import (
+	"errors"
+	"spaceofcheng/services/models/luckdraw"
+	"spaceofcheng/services/models/model"
+	"spaceofcheng/services/utils"
+)
+
+// LuckdrawServ 系统处理
+type LuckdrawServ struct {
+	ctx *utils.Context
+	dao *luckdraw.DAO
+}
+
+// NewLuckdrawServ 初始化
+func NewLuckdrawServ(ctx *utils.Context) *LuckdrawServ {
+	return &LuckdrawServ{
+		ctx: ctx,
+		dao: luckdraw.NewDAO(ctx),
+	}
+}
+
+func (s *LuckdrawServ) GetLuckDraw(id int) (*luckdraw.LuckDraw, error) {
+	luck, err := s.dao.GetLuckDraw(id)
+	if err != nil {
+		return nil, err
+	}
+	return luck, nil
+}
+func (s *LuckdrawServ) LuckDraw(id int, user *model.TaCustomer) (*model.TaLuckdrawPrize, *model.TaPrizeDetail, error) {
+	prize, prizeDetail, err := s.dao.LuckDraw(id, user)
+	if err != nil {
+		return nil, nil, err
+	}
+	return prize, prizeDetail, nil
+}
+func (s *LuckdrawServ) PrizeWriteOff(recordid int, userid string) error {
+	err := s.dao.PrizeWriteOff(recordid, userid)
+	if err != nil {
+		utils.LogError("奖品核销失败: " + err.Error())
+		return errors.New("奖品核销失败")
+	}
+	return nil
+}
+func (s *LuckdrawServ) GetWinning(prizes []model.TaLuckdrawPrize) (*model.TaLuckdrawPrize, error) {
+	prize, err := s.dao.GetWinning(prizes)
+	if err != nil {
+		return nil, err
+	}
+	return prize, nil
+}
+func (s *LuckdrawServ) GetLuckDrawByID(id int) (*luckdraw.LuckDraw, error) {
+	luck, err := s.dao.GetLuckDrawByID(id)
+	if err != nil {
+		utils.LogError("获取抽奖信息失败: " + err.Error())
+		return nil, errors.New("获取抽奖信息失败")
+	}
+	return luck, nil
+}
+func (s *LuckdrawServ) GetCaseAddressByLuckDarw(luckdraw int) (string, error) {
+	address, err := s.dao.GetCaseAddressByLuckDarw(luckdraw)
+	if err != nil {
+		utils.LogError("获取案场地址失败: " + err.Error())
+		return "", errors.New("获取案场地址失败")
+	}
+	return address, nil
+}
+func (s *LuckdrawServ) UpdateLuckDrawEndDate(id int) error {
+	err := s.dao.UpdateLuckDrawEndDate(id)
+	if err != nil {
+		utils.LogError("更新活动结束时间失败: " + err.Error())
+		return errors.New("更新活动结束时间失败")
+	}
+	return nil
+}
+func (s *LuckdrawServ) GetPrizes(luckdrawid int) ([]model.TaLuckdrawPrize, error) {
+	prize, err := s.dao.GetPrizes(luckdrawid)
+	if err != nil {
+		utils.LogError("获取奖品信息失败: " + err.Error())
+		return nil, errors.New("获取奖品信息失败")
+	}
+	return prize, nil
+}
+func (s *LuckdrawServ) UpdateStock(prize *model.TaLuckdrawPrize) error {
+	err := s.dao.UpdateStock(prize)
+	if err != nil {
+		utils.LogError("修改库存失败: " + err.Error())
+		return errors.New("修改库存失败")
+	}
+	return nil
+}
+func (s *LuckdrawServ) GetPrizeStock(luckdrawid int) ([]model.TaLuckdrawPrize, error) {
+	prize, err := s.dao.GetPrizeStock(luckdrawid)
+	if err != nil {
+		utils.LogError("判断奖项库存失败: " + err.Error())
+		return nil, errors.New("判断奖项库存失败")
+	}
+	return prize, nil
+}
+func (s *LuckdrawServ) GetPrizeByID(id int) (model.TaLuckdrawPrize, error) {
+	prize, err := s.dao.GetPrizeByID(id)
+	if err != nil {
+		utils.LogError("根据id获取奖品信息失败: " + err.Error())
+		return prize, errors.New("根据id获取奖品信息失败")
+	}
+	return prize, nil
+}
+func (s *LuckdrawServ) SaveRecord(record model.TaLuckdrawRecord) (*model.TaLuckdrawRecord, error) {
+	newRecord, err := s.dao.SaveRecord(record)
+	if err != nil {
+		utils.LogError("保存抽奖记录失败: " + err.Error())
+		return nil, errors.New("保存抽奖记录失败")
+	}
+	return newRecord, nil
+
+}
+func (s *LuckdrawServ) GetPrizeDetail(prizeid int) ([]model.TaPrizeDetail, error) {
+	detail, err := s.dao.GetPrizeDetail(prizeid)
+	if err != nil {
+		utils.LogError("获取未领取的奖品详情失败: " + err.Error())
+		return nil, errors.New("获取未领取的奖品详情失败")
+	}
+	return detail, nil
+}
+
+func (s *LuckdrawServ) UpdatePrizeDetail(detail model.TaPrizeDetail) error {
+	err := s.dao.UpdatePrizeDetail(detail)
+	if err != nil {
+		utils.LogError("更新库存明细为已领取失败: " + err.Error())
+		return errors.New("更新库存明细为已领取失败")
+	}
+	return nil
+}
+func (s *LuckdrawServ) UpdateRecord(record *model.TaLuckdrawRecord) error {
+	err := s.dao.UpdateRecord(record)
+	if err != nil {
+		utils.LogError("核销更新抽奖记录表失败: " + err.Error())
+		return errors.New("核销更新抽奖记录表失败")
+	}
+	return nil
+}
+func (s *LuckdrawServ) SaveWirteOff(writeoff model.TaLuckdrawWriteoff) (*model.TaLuckdrawWriteoff, error) {
+	newWriteoff, err := s.dao.SaveWirteOff(writeoff)
+	if err != nil {
+		utils.LogError("保存核销信息失败: " + err.Error())
+		return nil, errors.New("保存核销信息失败")
+	}
+	return newWriteoff, nil
+}
+func (s *LuckdrawServ) GetUserRecordByLuckDraw(userid string, luckdrawid int) ([]model.TaLuckdrawRecord, error) {
+	record, err := s.dao.GetUserRecordByLuckDraw(userid, luckdrawid)
+	if err != nil {
+		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
+		return nil, errors.New("获取用户的抽奖信息失败")
+	}
+	return record, nil
+}
+func (s *LuckdrawServ) GetUserLuckDrawByLuckDraw(userid string, luckdrawid int) (*model.TaLuckdrawRecord, error) {
+	record, err := s.dao.GetUserLuckDrawByLuckDraw(userid, luckdrawid)
+	if err != nil {
+		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
+		return nil, errors.New("获取用户的抽奖信息失败")
+	}
+	return record, nil
+}
+func (s *LuckdrawServ) GetDetailByRecord(recordid int) (*model.TaPrizeDetail, error) {
+	detail, err := s.dao.GetDetailByRecord(recordid)
+	if err != nil {
+		utils.LogError("获取detail失败: " + err.Error())
+		return nil, errors.New("获取detail失败")
+	}
+	return detail, nil
+
+}
+func (s *LuckdrawServ) GetUserLuckDraw(userid string) ([]luckdraw.UserRecord, error) {
+	record, err := s.dao.GetUserLuckDraw(userid)
+	if err != nil {
+		utils.LogError("获取用户的抽奖信息失败: " + err.Error())
+		return nil, errors.New("获取用户的抽奖信息失败")
+	}
+	return record, nil
+
+}
+func (s *LuckdrawServ) GetRecordByLuckDraw(luckdrawid int) ([]model.TaLuckdrawRecord, error) {
+	record, err := s.dao.GetRecordByLuckDraw(luckdrawid)
+	if err != nil {
+		utils.LogError("获取抽奖记录失败: " + err.Error())
+		return nil, errors.New("获取抽奖记录失败")
+	}
+	return record, nil
+
+}
+func (s *LuckdrawServ) GetRecordByID(id int) (*model.TaLuckdrawRecord, error) {
+	record, err := s.dao.GetRecordByID(id)
+	if err != nil {
+		utils.LogError("获取抽奖记录明细失败: " + err.Error())
+		return nil, errors.New("获取抽奖记录明细失败")
+	}
+	return record, nil
+}
+func (s *LuckdrawServ) GetUserByOpenID(openid string) (*model.SysUser, error) {
+	user, err := s.dao.GetUserByOpenID(openid)
+	if err != nil {
+		utils.LogError("根据 openid 获取用户人员信息失败: " + err.Error())
+		return nil, errors.New("根据 openid 获取用户人员信息失败")
+	}
+	return user, nil
+
+}
+func (s *LuckdrawServ) GetUserByTel(tel string) (*model.SysUser, error) {
+	user, err := s.dao.GetUserByTel(tel)
+	if err != nil {
+		utils.LogError("根据 tel 获取用户人员信息失败: " + err.Error())
+		return nil, errors.New("根据 tel 获取用户人员信息失败")
+	}
+	return user, nil
+
+}
+
+func (s *LuckdrawServ) SaveLuckDrawShareData(dt *model.TaShareLuckyRecord) error {
+	err := s.dao.SaveLuckDrawShareData(dt)
+	if err != nil {
+		utils.LogError("保存用户分享信息失败: " + err.Error())
+		return errors.New("保存用户分享信息失败")
+	}
+	return nil
+
+}
+func (s *LuckdrawServ) GetLuckDrawShareData(luckID int, from, to, caseID string) ([]model.TaShareLuckyRecord, error) {
+	share, err := s.dao.GetLuckDrawShareData(luckID, from, to, caseID)
+	if err != nil {
+		utils.LogError("获取抽奖分享失败: " + err.Error())
+		return nil, errors.New("获取抽奖分享失败")
+	}
+	return share, nil
+}

service/verify/verify.go

@@ -115,9 +115,9 @@ func (s *VerifyServ) UpdateCustomerCourseDetail(customerDetail *model.TaCustomer
 	customerDetail.VerifyDate = time.Now()
 	customerDetail.VerifyUser = userid
 	if time.Now().After(customerDetail.EndDate) {
-		customerDetail.VerifyStatus = "late"
+		customerDetail.VerifyStatus = models.VERIFY_LATE
 	} else {
-		customerDetail.VerifyStatus = "used"
+		customerDetail.VerifyStatus = models.VERIFY_USED
 	}
 	err = s.dao.UpdateCustomerCourseDetail(customerDetail)
 	if err != nil {

utils/rand.go

@@ -0,0 +1,64 @@
+package utils
+
+import (
+	"math/rand"
+	"reflect"
+	"time"
+)
+
+var rnd = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// Shuffle 随机数组
+func Shuffle(arr interface{}) interface{} {
+	newSeed()
+
+	v := reflect.ValueOf(arr)
+
+	arrLen := v.Len()
+	res := reflect.MakeSlice(v.Type(), arrLen, arrLen)
+	reflect.Copy(res, v)
+
+	for i := 0; i < arrLen; i++ {
+		m := rnd.Intn(arrLen)
+		n := arrLen - m - 1
+
+		swp := res.Index(m)
+		res.Index(m).Set(res.Index(n))
+		res.Index(n).Set(swp)
+	}
+
+	return res.Interface()
+}
+
+// LuckyDraw 抽奖
+func LuckyDraw(pList []map[string]interface{}) interface{} {
+	// 奖池
+	pool := make([]interface{}, 0)
+
+	// 生成奖池
+	for _, it := range pList {
+		prize := it["prize"]
+		prob := it["prob"].(int)
+
+		for i := 0; i < prob; i++ {
+			pool = append(pool, prize)
+		}
+	}
+
+	poolLen := len(pool)
+	if poolLen == 0 {
+		return nil
+	}
+
+	// 打乱奖池 - 打乱两次, 以使其更混乱, 更随机
+	pool = Shuffle(pool).([]interface{})
+
+	newSeed()
+	inx := rnd.Intn(poolLen)
+	return pool[inx]
+}
+
+func newSeed() {
+	seed := time.Now().UnixNano() + int64(rnd.Intn(1000)*1000)
+	rnd.Seed(seed)
+}