services/service/cases/key.go

package cases

import (
	"errors"
	"spaceofcheng/services/models/cases"
	"spaceofcheng/services/models/model"
	"spaceofcheng/services/service"
	"spaceofcheng/services/utils"
	"strconv"
	"time"

	"github.com/astaxie/beego"
)

// GetKeysByCase 根据案场获取钥匙信息
func (s *CaseServ) GetKeysByCase(caseids, num string, page, pageSize int) (map[string]interface{}, error) {
	if pageSize == 0 {
		pageSize = service.PAGENUM
	}

	keys, err := s.dao.GetKeysByCase(caseids, num, page, pageSize)
	if err != nil {
		utils.LogError("获取钥匙信息失败: " + err.Error())
		return nil, errors.New("获取钥匙信息失败")
	}

	total, err := s.dao.GetKeysCountByCase(caseids, num)
	if err != nil {
		utils.LogError("获取钥匙信息失败: " + err.Error())
		return nil, errors.New("获取钥匙信息失败")
	}

	for index, key := range keys {
		use, err := s.dao.GetCurrentKey(key.KeyId)
		if err != nil {
			utils.LogError("获取钥匙信息失败: " + err.Error())
			return nil, errors.New("获取钥匙信息失败")
		}
		if use != nil {
			keys[index].CustomerId = use.CustomerId
			keys[index].CustomerName = use.CustomerName
		}
	}

	return map[string]interface{}{
		"list":     keys,
		"pagesize": pageSize,
		"pagenum":  total,
		"page":     page,
	}, nil
}

// AddKeys 保存钥匙
func (s *CaseServ) AddKeys(orgid, caseid string, beginnum, endnum int) error {
	if caseid == "" {
		return utils.LogError("请先选择案场！")
	}
	if endnum < beginnum {
		return utils.LogError("锁柜编号起始编号不能大于截止编号！")
	}

	keys, err := s.dao.GetKeyByNum(caseid, beginnum, endnum)
	if err != nil {
		utils.LogError("保存钥匙信息失败: " + err.Error())
		return errors.New("保存钥匙信息失败")
	}
	if len(keys) > 0 {
		return utils.LogError("锁柜编号存在重复！请检查后再试！")
	}
	for i := beginnum; i <= endnum; i++ {
		key := model.TaCaseKey{
			OrgId:      orgid,
			CaseId:     caseid,
			LockNum:    strconv.Itoa(i),
			LockNo:     i,
			KeyId:      utils.GetGUID(),
			Status:     cases.STATUS_UNLOCK,
			CreateDate: time.Now(),
		}
		_, err := s.dao.AddKey(key)
		if err != nil {
			utils.LogError("保存钥匙信息失败: " + err.Error())
			return errors.New("保存钥匙信息失败")
		}
	}
	return nil
}

// LockKeyByPhone 根据手机号绑定钥匙
func (s *CaseServ) LockKeyByPhone(phone, keyId string) error {
	customer, err := s.customerdao.GetCustomerByPhone(phone)
	if err != nil {
		utils.LogError("根据手机号绑定钥匙失败: " + err.Error())
		return errors.New("根据手机号绑定钥匙失败")
	}
	if customer == nil {
		return errors.New("非注册用户不可绑定")
	}
	count, err1 := s.dao.CustomerIsBind(customer.CustomerId)
	if err1 != nil {
		utils.LogError("绑定钥匙失败: " + err1.Error())
		return errors.New("绑定钥匙失败")
	}
	if count > 0 {
		return errors.New("用户已绑定钥匙，不可重复绑定")
	}
	err = s.dao.BindKeyToUser(keyId, customer.CustomerId, customer.CustomerName)
	if err != nil {
		utils.LogError("根据手机号绑定钥匙失败: " + err.Error())
		return errors.New("根据手机号绑定钥匙失败")
	}
	err = s.dao.UpdateKeyState(keyId, 1)
	if err != nil {
		utils.LogError("根据手机号绑定钥匙失败: " + err.Error())
		return errors.New("根据手机号绑定钥匙失败")
	}
	return nil

}

// UnLockKey 解锁
func (s *CaseServ) UnLockKey(keyid string) error {
	err := s.dao.UnLockKey(keyid)
	if err != nil {
		utils.LogError("解锁钥匙失败: " + err.Error())
		return errors.New("解锁钥匙失败")
	}
	err = s.dao.UpdateKeyState(keyid, 0)
	if err != nil {
		utils.LogError("解锁钥匙失败: " + err.Error())
		return errors.New("解锁钥匙失败")
	}
	return nil
}

// LockKey 绑定钥匙
func (s *CaseServ) LockKey(keyId, customerId, customerName string) error {
	count, err := s.dao.CustomerIsBind(customerId)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	if count > 0 {
		return errors.New("用户已绑定钥匙，不可重复绑定")
	}
	err = s.dao.BindKeyToUser(keyId, customerId, customerName)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	err = s.dao.UpdateKeyState(keyId, 1)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	return nil
}

// LockKeyVerify 二维码核销绑定钥匙
func (s *CaseServ) LockKeyVerify(keyId, customerId string) error {
	customer, err := s.customerdao.GetCustomerByID(customerId)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	beego.Error("------------------------------------")
	beego.Error(customer)
	beego.Error("------------------------------------")
	if customer == nil {
		return errors.New("无效客户")
	}
	count, err := s.dao.CustomerIsBind(customerId)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	if count > 0 {
		return errors.New("用户已绑定钥匙，不可重复绑定")
	}
	err = s.dao.BindKeyToUser(keyId, customerId, customer.CustomerName)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	err = s.dao.UpdateKeyState(keyId, 1)
	if err != nil {
		utils.LogError("绑定钥匙失败: " + err.Error())
		return errors.New("绑定钥匙失败")
	}
	return nil

}

// DelKey 刪除
func (s *CaseServ) DelKey(keyid string) error {
	use, err := s.dao.GetCurrentKey(keyid)
	if err != nil {
		utils.LogError("刪除钥匙失败: " + err.Error())
		return errors.New("刪除钥匙失败")
	}

	if use != nil {
		return utils.LogError("当前锁柜未解锁！请先解锁再删除！")
	}

	err = s.dao.DelKey(keyid)
	return nil
}