services/service/customer/customer.go

package customer

import (
	"encoding/json"
	"errors"
	"math/rand"
	"spaceofcheng/services/models"
	"spaceofcheng/services/models/card"
	"spaceofcheng/services/models/cases"
	"spaceofcheng/services/models/coupon"
	"spaceofcheng/services/models/customer"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/models/system"
	"spaceofcheng/services/service"
	"spaceofcheng/services/service/events"
	"spaceofcheng/services/utils"
	"strconv"
	"strings"
	"time"
)

// CustomerServ 系统处理
type CustomerServ struct {
	ctx       *utils.Context
	dao       *customer.CustomerDAO
	casedao   *cases.CaseDAO
	userdao   *system.UserDAO
	carddao   *card.CardDAO
	coupondao *coupon.CouponDAO
}

// NewCustomerServ 初始化
func NewCustomerServ(ctx *utils.Context) *CustomerServ {
	return &CustomerServ{
		ctx:       ctx,
		dao:       customer.NewCustomerDAO(ctx),
		casedao:   cases.NewCaseDAO(ctx),
		userdao:   system.NewUserDAO(ctx),
		carddao:   card.NewCardDAO(ctx),
		coupondao: coupon.NewCouponDAO(ctx),
	}
}

// GetCustWithWXList 获取客户列表
func (s *CustomerServ) GetCustWithWXList(phone, username, recommendname, begindate, enddate, caseids string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}
	cust, err := s.dao.CustWithWXList(phone, username, recommendname, begindate, enddate, caseids, page, pageSize)
	if err != nil {
		utils.LogError("获取客户列表失败: " + err.Error())
		return nil, errors.New("获取客户列表失败")
	}
	total, err := s.dao.CustWithWXListCount(phone, username, recommendname, begindate, enddate, caseids)
	if err != nil {
		utils.LogError("获取客户列表失败: " + err.Error())
		return nil, errors.New("获取客户列表失败")
	}
	return map[string]interface{}{
		"list":     cust,
		"pageSize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// GetCustWithWXByID 获取客户列表
func (s *CustomerServ) GetCustWithWXByID(custID string) (*customer.CustWithWX, error) {
	cust, err := s.dao.GetCustWithWXByID(custID)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}

	if cust.Status != models.STATUS_NORMAL {
		return nil, errors.New("用户状态异常")
	}

	return cust, nil
}

// GetCustUserByOpenID 根据openid获取用户信息
func (s *CustomerServ) GetCustUserByOpenID(openid string) (*customer.CustWithWX, error) {
	cust, err := s.dao.GetCustWithWXByOpenID(openid)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}
	if cust != nil && cust.MapUser != "" {
		caseinfo, err := s.userdao.GetUserBelongCase(cust.MapUser)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}
		cust.BelongCaseId = caseinfo.CaseId
		cust.BelongCaseStatus = caseinfo.Status
	}

	return cust, nil
}

// GetCustUserByID 获取用户信息(自定义内容)
func (s *CustomerServ) GetCustUserByID(userID string) (*UserProfile, error) {
	user, err := s.dao.GetUserByID(userID)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}

	if user.Status != models.STATUS_NORMAL {
		return nil, errors.New("用户状态异常")
	}

	userProfile := UserProfile{
		UserId:     user.UserId,
		UserName:   user.UserName,
		RealName:   user.RealName,
		Sex:        user.Sex,
		WorkNo:     user.WorkNo,
		Email:      user.Email,
		Phone:      user.Phone,
		Headimgurl: user.Headimgurl,
	}

	return &userProfile, nil
}

// BindWechatUser 绑定微信用户
func (s *CustomerServ) BindWechatUser(userMap *model.TaUserMapping, phone string) (*model.TaCustomer, error) {
	user, err := s.dao.GetUserByPhone(phone)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}
	if user == nil {
		return nil, errors.New("您不是系统人员，无法登录")
	}

	cust, err := s.dao.GetCustomerByPhone(phone)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}

	if cust == nil {
		wxInfo := utils.WechatUser{}
		if err := json.Unmarshal([]byte(userMap.AccountInfo), &wxInfo); err != nil {
			utils.LogError("解析用户微信映射信息失败: " + err.Error())
			return nil, errors.New("系统数据异常")
		}

		// 更新用户手机号码信息及userid信息
		customer, err := s.dao.GetCustWithWXByOpenID(wxInfo.OpenID)
		if err != nil {
			utils.LogError("查询用户失败: " + err.Error())
			return nil, errors.New("校验用户数据失败")
		}

		newCust := model.TaCustomer{
			CustomerId: customer.CustomerId,
			Phone:      user.Phone,
			UserId:     user.UserId,
		}
		err = s.dao.UpdateCustomer(&newCust, []string{
			"phone",
			"user_id",
		})
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}

		cust = &newCust
	} else {
		if cust.Status != models.STATUS_NORMAL {
			return nil, errors.New("用户状态不正确")
		}
	}

	// triggerRegiteEvent 触发注册事件
	// evtEngID := utils.EngineIDBy(cust.OrgId, cust.RecommendCase)
	// utils.EventEngineBus(evtEngID).EmitEvent(events.EvtRegiste, *cust)

	// if cust.CustomerId == userMap.UserId {
	// 	return cust, nil
	// }

	// 更新用户映射信息
	userMap.UserId = cust.CustomerId
	if err := s.dao.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
		utils.LogError("更新用户映射信息失败:" + err.Error())
		return nil, errors.New("映射用户信息失败")
	}

	return cust, nil
}
func (s *CustomerServ) GenerateCustomerBarcode() string {
	temp1 := "63"
	temp2 := time.Now().Local().Format("060102")
	temp3 := strconv.Itoa(rand.Intn(9) * 87)
	if len(temp3) < 3 {
		temp3 += strconv.Itoa(rand.Intn(9))
	}
	temp4 := strconv.Itoa(rand.Intn(9))
	temp5, _ := models.GetSeqID(temp2)
	minus := 4 - len(temp5)
	if minus < 0 {
		minus = 0
		temp5 = temp5[0:4]
	}
	temp5 = strings.Repeat("0", minus) + temp5
	code := temp1 + temp2 + temp3 + temp4 + temp5
	return code
}

// BindWechatCust 绑定微信用户
func (s *CustomerServ) BindWechatCust(userMap *model.TaUserMapping, phone, recommendCode, name string) (*model.TaCustomer, error) {
	cust, err := s.dao.GetCustomerByPhone(phone)
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}
	if cust != nil {
		return nil, errors.New("当前手机号已被绑定或者注册")
	}

	// 用户不存在, 则新增
	wxInfo := utils.WechatUser{}
	if err := json.Unmarshal([]byte(userMap.AccountInfo), &wxInfo); err != nil {
		utils.LogError("解析用户微信映射信息失败: " + err.Error())
		return nil, errors.New("系统数据异常")
	}

	// 更新用户手机号码信息及userid信息
	customer, err := s.dao.GetCustWithWXByOpenID(wxInfo.OpenID)
	if err != nil {
		return nil, utils.LogError("获取用户信息失败", err.Error())
	}
	var barcode string
	newCust := customer.TaCustomer
	for i := 0; i < 10; i++ {
		barcode = s.GenerateCustomerBarcode()
		x, err := s.dao.IsBarcodeExist(barcode)
		if err != nil {
			return nil, errors.New("生成条形码失败")
		}
		if x <= 0 {
			break
		}
	}
	newCust.Barcode = barcode
	newCust.Phone = phone
	newCust.Name = name
	newCust.BindingDate = time.Now().Local()

	// 校验案场信息
	if recommendCode != "" {
		user, err := s.dao.GetSalesByRecommendCode(recommendCode)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}
		userCase, err := s.dao.GetSalesCaseById(user.UserId)
		cs, err := s.casedao.GetCaseByID(userCase.CaseId)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}

		if cs == nil || cs.Status == models.STATUS_DEL {
			return nil, errors.New("系统无该推荐案场")
		}
		if cs.Status == 0 {
			return nil, errors.New("该案场暂未开放")
		}

		newCust.OrgId = cs.OrgId
		newCust.RecommendCase = cs.CaseId

		if user == nil || user.Status == models.STATUS_DEL {
			return nil, errors.New("系统无该推荐人")
		}

		newCust.OrgId = user.OrgId
		newCust.RecommendId = user.UserId
		newCust.RecommendName = user.RealName
	}

	// 校验推荐人
	// if userID != "" {
	// 	ar, err := s.dao.GetUserByID(userID)
	// 	if err != nil {
	// 		utils.LogError(err.Error())
	// 		return nil, err
	// 	}

	// 	if ar == nil || ar.Status == models.STATUS_DEL {
	// 		return nil, errors.New("系统无该推荐人")
	// 	}

	// 	newCust.OrgId = ar.OrgId
	// 	newCust.RecommendId = ar.UserId
	// 	newCust.RecommendName = ar.RealName
	// }

	err = s.dao.UpdateCustomer(&newCust, []string{
		"phone",
		"name",
		"recommend_id",
		"recommend_case",
		"recommend_name",
		"binding_date",
		"barcode",
	})
	if err != nil {
		utils.LogError(err.Error())
		return nil, err
	}

	cust = &newCust

	// triggerRegiteEvent 触发注册事件
	// if cust.RecommendCase != "" {
	evtEngID := utils.EngineIDBy(customer.OrgId, "")
	evtEngine := utils.EventEngineBus(evtEngID)
	evtEngine.EmitEvent(events.EvtRegiste, *cust)
	// }

	// 如果客户ID 与映射表中一致, 说明已经绑定过了
	if cust.CustomerId == userMap.UserId {
		return cust, nil
	}

	// 更新用户映射信息
	userMap.UserId = cust.CustomerId
	if err := s.dao.UpdateUserMapping(userMap, []string{"user_id"}); err != nil {
		utils.LogError("更新用户映射信息失败:" + err.Error())
		return nil, errors.New("映射用户信息失败")
	}

	return cust, nil
}

// SaveNewCustomer 新增客户
func (s *CustomerServ) SaveNewCustomer(wxInfo map[string]interface{}, caseID, arID, phone, userID string) (*model.TaCustomer, error) {
	// if caseID == "" && arID == "" && userID == "" {
	// 	return nil, errors.New("新增信息失败, 无法确认人员类型")
	// }

	// 微信相关字段
	nickyName := wxInfo["nickname"].(string)

	// sex := wxInfo["sex"].(string)
	var sexInt int
	switch val := wxInfo["sex"].(type) {
	case string:
		sexInt, _ = strconv.Atoi(val)
	case float64:
		sexInt = int(val)
	default:
		sexInt = 1
	}
	if sexInt == 0 {
		sexInt = 1 // 默认男性
	}
	headimgurl := wxInfo["headimgurl"].(string)

	org := s.ctx.Get("org").(model.SysOrg)

	cust := model.TaCustomer{
		CustomerName: nickyName,
		Name:         nickyName,
		Sex:          sexInt,
		Headimgurl:   headimgurl,
		Phone:        phone,
		OrgId:        org.OrgId,
	}

	// 校验案场信息
	if caseID != "" {
		cs, err := s.casedao.GetCaseByID(caseID)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}

		if cs == nil || cs.Status == models.STATUS_DEL {
			return nil, errors.New("系统无该推荐案场")
		}

		cust.OrgId = cs.OrgId
		cust.RecommendCase = cs.CaseId
	}

	// 校验推荐人
	if arID != "" {
		ar, err := s.dao.GetUserByID(arID)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}

		if ar == nil || ar.Status == models.STATUS_DEL {
			return nil, errors.New("系统无该推荐人")
		}

		cust.OrgId = ar.OrgId
		cust.RecommendId = ar.UserId
		cust.RecommendName = ar.RealName
	}

	// 系统用户
	if userID != "" {
		user, err := s.dao.GetUserByID(userID)
		if err != nil {
			utils.LogError(err.Error())
			return nil, err
		}

		if user != nil && user.Status != models.STATUS_DEL {
			cust.CustomerId = userID
		}
	}

	if err := s.dao.SaveCustomer(&cust); err != nil {
		utils.LogError("更新客户信息失败: " + err.Error())
		return nil, errors.New("更新客户信息失败")
	}

	account := new(model.TaCustomerAccount)
	account.CustomerId = cust.CustomerId
	account.CustomerName = cust.CustomerName
	account.OrgId = cust.OrgId
	account.Amount = "0"
	account.Points = "0"
	account.PayedAmount = "0"
	account.PayedPoints = "0"

	if err := s.dao.SaveAccount(account); err != nil {
		utils.LogError("插入账户信息失败: " + err.Error())
		return nil, errors.New("更新客户信息失败")
	}

	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
}

// GetCustomerInfo 获取客户个人信息
func (s *CustomerServ) GetCustomerInfo() (map[string]interface{}, error) {
	customer := s.ctx.Get("customer").(model.TaCustomer)
	org := s.ctx.Get("org").(model.SysOrg)
	account, err := s.dao.GetAccountByCust(customer.CustomerId)
	if err != nil {
		utils.LogError("获取用户账户信息失败：", err)
		return nil, err
	}
	card, err := s.carddao.GetCustomerNoCardByCustomer(customer.CustomerId, org.OrgId)
	if err != nil {
		utils.LogError("获取用户卡信息失败：", err)
		return nil, err
	}
	coupon, err := s.coupondao.GetNoCouponByCustomer(org.OrgId, customer.CustomerId)
	if err != nil {
		utils.LogError("获取用户卡信息失败：", err)
		return nil, err
	}
	balance, err := s.dao.GetCustomerVipAmount(customer.CustomerId)
	return map[string]interface{}{
		"account":    account,
		"cardsnum":   len(card),
		"couponnum":  len(coupon),
		"vipbalance": balance,
	}, nil
}

// EditUserMapping 更新用户map信息
func (s *CustomerServ) EditUserMapping(userMap *model.TaUserMapping) (*model.TaUserMapping, error) {
	err := models.EditUserMapping(userMap)
	return userMap, err
}