genepoint_service/src/dashoo.cn/genepoint_srv/business/converseService/converseService.go

package converseService

import (
	"crypto/md5"
	"fmt"
	"github.com/Unknwon/com"
	"github.com/gogf/gf/os/glog"
	"log"
	"strconv"
	"strings"
	"time"

	"github.com/go-xorm/xorm"

	"dashoo.cn/utils"
	. "dashoo.cn/utils/db"
)

const CU = 1
const EE = 1
const POS = 1
const LTU = 1
const GROUP = 1
const TABLE_TAST = "sample_storage_task"
const TABLE_SAMPLE_APPLY = "bank_apply_main"
const TABLE_DETAIL = "bank_apply_detail"
const TABLE_SHELF = "bank_shelf"
const TABLE_BOX = "bank_box"
const TABLE_EQUIPMENT = "bank_equipment"
const TABLE_DEVICE_DATA = "GenePoint_Device_Report_Data"
const TABLE_SAMPLE = "bank_sample"
const TABLE_APPLY_DETAIL = "bank_apply_detail"
const STATUS_LOCKED = "1"
const STATUS_UNLOCK = "0"
const RK_PASS = "2"
const CK_PASS_ONHOLD = "3" //保留位置
const CK_PASS_DONE = "4"   //已归档

type ConverseService struct {
	ServiceBase
}

type ConverseSessionService struct {
	SessionBase
}

func GetConverseService(xormEngine *xorm.Engine) *ConverseService {
	s := new(ConverseService)
	s.DBE = xormEngine
	return s
}

func GetConverseSessionService(session *xorm.Session) *ConverseSessionService {
	s := new(ConverseSessionService)
	s.Session = session
	return s
}

//建立会话
func (this *ConverseService) GetSessionSetupRequest(utc string) *RequestEntity {
	var request = "session_setup"
	var reqData RequestData
	reqData.Key = this.GetKeyBaseOnTime(utc)
	reqData.Client = "lims"
	var entity = this.GetRequestEntity(request, utc, reqData)
	return entity
}

//生成请求报文
func (this *ConverseService) GetRequestEntity(request string, utc string, data RequestData) *RequestEntity {
	var entity RequestEntity
	entity.Request = request
	entity.Time = utc
	entity.Data = data
	return &entity
}

// 获取身份验证key
// key的信息按照生物样本存储系统分配的私钥字符串+请求报文中的time字段的值进行MD5加密
func (this *ConverseService) GetKeyBaseOnTime(utc string) string {
	privateKey := "ZGlzdHJp23Yn4V06b3I6OGQ5NjllZWY2ZWNhZDNjMjlhM2E2MjkyODBlNjg2Y2YwYzNmNWQ1YTg2YWZmM2Nh3MTIwMjB3454jOTIzYWRjNmM5M4g"
	unencoded := privateKey + utc
	byte := md5.Sum([]byte(unencoded))
	encode := fmt.Sprintf("%x", byte)
	resultKey := strings.ToUpper(encode)
	return resultKey
}

//查询库存冻存盒信息
func (this *ConverseService) CheckStockRackInfo(cu int, rack_id string, utc string) *RequestEntity {
	var request = "stock_rack"
	var data RequestData
	data.Rack_id = rack_id
	data.Cu = cu
	entity := this.GetRequestEntity(request, utc, data)
	return entity
}

//查询库存冻存管信息
func (this *ConverseService) CheckStockTubeInfo(cu int, rack_id, tube_id, utc string) *RequestEntity {
	var request = "stock_rack_tube"
	var data RequestData
	data.Rack_id = rack_id
	data.Tube_id = tube_id
	data.Cu = cu
	entity := this.GetRequestEntity(request, utc, data)
	return entity
}

//任务撤销
func (this *ConverseService) CancelTast(utc string, task_id string) *RequestEntity {
	var request = "task_change"
	var data RequestData
	data.Task_id = task_id
	data.Status = 1
	entity := this.GetRequestEntity(request, utc, data)
	return entity
}

//扫描新任务
func (this *ConverseService) ScanNewTaskDetail() []Sample_Storage_Task {
	var tasks []Sample_Storage_Task
	where := "statuscode = 0"
	this.GetEntitysByWhere(TABLE_TAST, where, &tasks)
	return tasks
}


// 获取申请单创建人
func (this *ConverseService)GetOperUser(EntryNo string)(user string ){

	// 获取当前任务的操作人
	sql := " select  a.UserName from   base_user a left join   bank_apply_main b  on a.id = b.CreateUserId  where b.EntryNo ='"+EntryNo +"' "
	this.DBE.SQL(sql).Get(&user)
	return user
}




//新任务数量
func (this *ConverseService) GetNewTaskBasic() []Sample_Storage_Task {
	//var count64 int64
	var tasks []Sample_Storage_Task
	//sql := "SELECT COUNT(DISTINCT(task_id)) FROM sample_storage_task WHERE status = 0"
	sql := "SELECT task_id, task_type, statuscode FROM " + TABLE_TAST + " GROUP BY task_id, task_type HAVING statuscode = 0"
	err := this.DBE.SQL(sql).Find(&tasks)
	if err != nil {
		log.Println(err)
	}
	//if len(resultsSlice) > 0 {
	//	results := resultsSlice[0]
	//	for _, value := range results {
	//		count64, _ = strconv.ParseInt(string(value), 10, 64)
	//		//LogError(err)
	//		break
	//	}
	//}
	//intSTr := strconv.FormatInt(count64,10)
	//count,_ := strconv.Atoi(intSTr)

	return tasks
}

////冻存管位置格式转换
//func TransPositionToNo(boxType int, position string) int{
//	co := strings.Split(position,";")
//	x, _ := strconv.Atoi(co[0])
//	y, _ := strconv.Atoi(co[1])
//	var no int
//	switch boxType {
//	case 101,102,103:
//		no = (y-1)*14+x
//		break
//	case 0 :
//		no = (y-1)*10+x
//	}
//	return no
//}

// 生成请求实体，根据任务类型获取requestName
func (this *ConverseService) GenerateRequestEntity(taskType int, task_id ,user string) *RequestEntity {
	var requestName string
	switch taskType {
	case 1:
		requestName = "rack_storing"
		break
	case 2:
		requestName = "rack_retrieving"
		break
	case 3, 8:
		requestName = "tube_storing"
		break
	case 4:
		requestName = "tube_retrieving"
		break
	case 5:
		requestName = "stock_rack"
		break
	case 6:
		requestName = "stock_rack_tube"
		break
	case 7:
		requestName = "task_change"
	}
	utc := time.Now().UTC().Format(time.RFC3339)
	var data RequestData
	if requestName != "stock_rack" && requestName != "stock_rack_tube" {
		data.Task_id = task_id
		data.Type = "begin"
		data.Operation_user = user

	}
	entity := this.GetRequestEntity(requestName, utc, data)
	return entity
}

// 按类型进行任务处理
func (this *ConverseService) HandleTaskDetail(taskType int, entity *RequestEntity, detail *Sample_Storage_Task) {
	switch taskType {
	case 1: //冻存盒 入库
		handleRackStore(entity, detail)
		break
	case 2: //冻存盒出库
		handleRackRetrieve(entity, detail)
		break
	case 3, 8: //冻存管入库
		handleTubeStore(entity, detail)
		break
	case 4: // 冻存管出库
		handleTubeRetrieve(entity, detail)
		break
	case 5: // 获取设备库存情况及冻存盒信息
		handleQueryRack(entity, detail)
		break
	case 6: // 根据冻存盒编号查询冻存管信息
		handleQueryTube(entity, detail)
		break
	case 7: // 任务变更通知
		handleTaskChange(entity, detail)
	}
}

//处理冻存盒入库任务信息
func handleRackStore(entity *RequestEntity, detail *Sample_Storage_Task) {
	var ones = make([]Single, 0)
	var exist bool

	if entity.Data.Task_data != nil {
		ones = entity.Data.Task_data.([]Single)
		for idx, value := range ones {
			if value.Rack_id == detail.BoxBarcode {
				var tube Tube
				tube.Id = detail.BarCode
				ones[idx].Tubes = append(ones[idx].Tubes, tube)
				exist = true
			}
		}
	}

	if !exist {
		var one Single
		one.Rack = detail.BoxType
		one.Tube = detail.TubeType
		one.Rack_id = detail.BoxBarcode
		//one.Source.Cu = CU
		one.Source.Cu = detail.Cu
		one.Source.Ee = EE
		one.Source.Pos = POS
		//one.Target.Cu = CU
		one.Target.Cu = detail.Cu
		one.Target.Unit = detail.Unit
		one.Target.Pos = detail.Pos
		one.Target.Ltu = detail.Ltu
		//one.Target.Group = 1
		one.Target.Group = detail.Group
		if detail.BarCode != "" {
			var tube Tube
			tube.Id = detail.BarCode
			one.Tubes = append(one.Tubes, tube)
		} else {
			one.Tubes = make([]Tube, 0) //tubes不能为空, 否则Genepoint系统报错
		}
		ones = append(ones, one)
	}
	entity.Data.Task_data = ones
}

//处理冻存盒出库任务信息
func handleRackRetrieve(entity *RequestEntity, detail *Sample_Storage_Task) {
	var ones []Single
	var one Single
	one.Tubes = make([]Tube, 0) //tubes不能为空, 否则Genepoint系统报错

	if entity.Data.Task_data != nil {
		//	ones = make([]Single, 0)
		//}else{
		ones = entity.Data.Task_data.([]Single)
	}
	one.Rack_id = detail.BoxBarcode
	one.Target.Cu = detail.Cu //todo
	one.Target.Ee = EE
	one.Target.Pos = POS
	ones = append(ones, one)
	entity.Data.Task_data = ones
}

//处理冻存管入库任务信息
func handleTubeStore(entity *RequestEntity, detail *Sample_Storage_Task) {
	var ones []Single
	var exist bool
	if entity.Data.Operation_mode == "" {
		entity.Data.Operation_mode = detail.OperaMode
	}

	// 盒子存在追加样本
	if entity.Data.Task_data != nil {
		ones = entity.Data.Task_data.([]Single)
		for idx, value := range ones {
			if value.Target.Rack_id == detail.BoxBarcode {
				var tube Tube
				if detail.OperaMode != "auto" {
					//tube.T_no = TransPositionToNo(detail.BoxType,detail.Position)
					//实际采用,暂时注释掉
					tube.T_no = detail.No
				}
				tube.Id = detail.BarCode
				ones[idx].Tubes = append(ones[idx].Tubes, tube)
				//value.Tubes = append(value.Tubes,tube)
				exist = true
				goto label
			}
		}
	}

	// 盒子不存在新加盒子及管信息
	if !exist {
		var one Single
		//one.Rack = 101			// 测试临时使用
		//one.Tube = 201			// 测试临时使用
		one.Rack = detail.BoxType   // 样本库系统,没有添加该字段信息逻辑,临时注释
		one.Tube = detail.TubeType  // 样本库系统,没有添加该字段信息逻辑,临时注释
		one.Rack_id = detail.SourceBox		 	// 此处需要添加源盒编码  SourceBox
		//one.Source.Cu = CU		// 测试临时使用
		one.Source.Cu = detail.Cu
		one.Source.Ee = EE
		one.Source.Pos = POS
		var tube Tube
		if detail.OperaMode != "auto" {
			one.Target.Cu = detail.Cu
			one.Target.Ltu = detail.Ltu
			one.Target.Group = detail.Group
			one.Target.Unit = detail.Unit
			one.Target.Pos = detail.Pos
			one.Target.Rack_id = detail.BoxBarcode
			//tube.T_no = TransPositionToNo(detail.BoxType,detail.Position)
			tube.T_no = detail.No //实际采用,暂时注释掉
		}
		tube.Id = detail.BarCode
		one.Tubes = append(one.Tubes, tube)
		ones = append(ones, one)
	}
label:
	entity.Data.Task_data = ones
}

//处理冻存管出库任务信息
func handleTubeRetrieve(entity *RequestEntity, detail *Sample_Storage_Task) {
	var one OutSingle
	//var exist bool
	if entity.Data.Task_data != nil {
		one = entity.Data.Task_data.(OutSingle)
		//exist = true
	}

	//if !exist {
	//	//one.Target.Cu = CU
	//	one.Target.Cu = detail.Cu
	//	one.Target.Ee = EE
	//	one.Target.Pos = POS
	//}
	var tube Tube
	tube.Id = detail.BarCode
	one.Tubes = append(one.Tubes, tube)
	entity.Data.Task_data = one
}

//任务撤销
func handleTaskChange(entity *RequestEntity, detail *Sample_Storage_Task) {
	entity.Data.Status = detail.Status
}

//查询冻存盒库存信息
func handleQueryRack(entity *RequestEntity, detail *Sample_Storage_Task) {
	entity.Data.Cu = detail.Cu
	entity.Data.Rack_id = detail.BoxBarcode
}

//查询冻存管库存信息
func handleQueryTube(entity *RequestEntity, detail *Sample_Storage_Task) {
	entity.Data.Rack_id = detail.BoxBarcode
	entity.Data.Tube_id = detail.BarCode
}

// 查询申请单详情下状态，存在一条子任务失败的情况，则整个申请单状态为失败
func (this *ConverseService) StatusModifyWithDetail(task_id string) error {
	status := SUCCESS
	// 关联查询申请详情表，申请主表中指定申请单下执行状态不为success的申请详情数量

	sql := "SELECT count(*) FROM `" + TABLE_APPLY_DETAIL + "` a  JOIN `" + TABLE_SAMPLE_APPLY + "` b ON a.parentid = b.Id WHERE ( a.parentid = b.Id and b.entryno = '" + task_id + "' and a.taskstatus <> " + strconv.Itoa(SUCCESS) + ")"

	//total, err := this.DBE.Table(TABLE_APPLY_DETAIL ).Join("", TABLE_SAMPLE_APPLY ,"a.parentid = b.Id").Where(" a.parentid = b.Id and b.entryno = '" + task_id + "' and a.taskstatus <> " + strconv.Itoa(SUCCESS)).Count()
	//if err != nil && err != sql.ErrNoRows {
	//	return err
	//}

	var total int
	//_, err := this.DBE.Exec(sql)
	this.DBE.SQL(sql).Get(&total)

	//total ,_ := result.RowsAffected()
	fmt.Println("数量：", total)

	// 存在未执行成功的子任务
	if total > 0 {
		status = FAILED
	}

	// 更新任务状态
	//updTaskSql := "UPDATE " + TABLE_TAST + " SET statuscode = '" + strconv.Itoa(status) + "' WHERE task_id = '" + task_id + "'"
	//_, err = this.DBE.Exec(updTaskSql)

	// 更新申请主表状态
	updApplySql := "UPDATE " + TABLE_SAMPLE_APPLY + " SET taskstatus = '" + strconv.Itoa(status) + "' WHERE entryno = '" + task_id + "'"
	_, err := this.DBE.Exec(updApplySql)
	return err
}

//修改任务表状态码
func (this *ConverseService) TaskStatusModify(statusCode int, task_id string) error {
	sql := "UPDATE " + TABLE_TAST + " SET statuscode = '" + strconv.Itoa(statusCode) + "'   WHERE task_id = '" + task_id + "'"
	_, err := this.DBE.Exec(sql)
	return err
}

// 修改出入库单状态
func (this *ConverseService) SampleApplyStatusModify(statusCode int, entryNo string) error {
	set  :=""
	if statusCode==1 || statusCode==2 || statusCode==3 || statusCode==5 || statusCode==6 {
		set = "  ,exception='' "
	}


	sql := "UPDATE " + TABLE_SAMPLE_APPLY + " SET taskstatus = '" + strconv.Itoa(statusCode) + "' "+set+"  WHERE entryno = '" + entryNo + "'"
	_, err := this.DBE.Exec(sql)
	return err
}

//2020/12/18新增  根据当前任务报文返回状态批量更新当前任务下所有的样本状态
func (this *ConverseService) SampleApplyDetailStatusModify(statusCode int, entryNo string) error {

	//获取出入库单Id
	getId := "SELECT id FROM " + TABLE_SAMPLE_APPLY + " WHERE entryno = '" + entryNo + "'"
	var idList []Id
	err := this.DBE.SQL(getId).Find(&idList)
	//批量更新全部成功或失败的任务样本状态
	sql := "UPDATE " + TABLE_APPLY_DETAIL + " SET taskstatus = '" + strconv.Itoa(statusCode) + "' WHERE parentid = '" + strconv.Itoa(idList[0].Id) + "'"
	_, err = this.DBE.Exec(sql)

	return err
}

////批量更新全部成功或失败的任务样本状态
//func (this *ConverseService)SampleApplyDetailStatusBatchModify(statusCode int , entryNo string) error {
//
//	//获取出入库单Id
//	getId := "SELECT id FROM " + TABLE_SAMPLE_APPLY + " WHERE entryno = '" + entryNo + "'"
//	var idList []Id
//	err := this.DBE.SQL(getId).Find(&idList)
//	//批量更新全部成功或失败的任务样本状态
//	sql:= "UPDATE " + TABLE_APPLY_DETAIL + " SET taskstatus = '" + strconv.Itoa(statusCode) + "' WHERE parentid = '" + strconv.Itoa(idList[0].Id) + "'"
//	_,err = this.DBE.Exec(sql)
//
//	return  err
//}

//修改全部样本执行成功状态
//func (this *ConverseService)ModifySampleALLSuccessStatus(res ResponseEntity){
//	tubeIds := handleSingleList(res.Data.Actual_data)
//	this.handleSampleSuccess(tubeIds, res.Response)
//}

//修改全部样本执行失败状态
//func (this *ConverseService)ModifySampleALLFailedStatus(res ResponseEntity){
//	tubeIds := handleSingleList(res.Data.Actual_data)
//	this.handleSampleFailed(tubeIds, res.Response)
//}

//任务执行驳回, 修改全部样本失败状态
func (this *ConverseService) ModifySampleAllRejectStatus(res ResponseEntity) error {
	//获取出入库单Id
	getId := "SELECT id FROM " + TABLE_SAMPLE_APPLY + " WHERE entryno = '" + res.Data.Task_id + "'"
	var idList []Id
	err := this.DBE.SQL(getId).Find(&idList)
	//批量更新全部成功或失败的任务样本状态
	sql := "UPDATE " + TABLE_APPLY_DETAIL + " SET taskstatus = '" + strconv.Itoa(REJECT) + "' WHERE parentid = '" + strconv.Itoa(idList[0].Id) + "'"
	_, err = this.DBE.Exec(sql)
	return err
}

//修改部分样本执行成功部分样本执行失败状态
//func (this *ConverseService)SampleApplyDetailStatusPartsModify(res ResponseEntity){
//
//	tubeIds := handleSingleList(res.Data.Actual_data)
//	this.handleSampleSuccess(tubeIds, res.Response)
//	tubeIds = handleSingleList(res.Data.Abnormal_data.Tubes)
//	this.handleSampleFailed(tubeIds, res.Response)
//
//}

//处理single切片
//func handleSingleList(singles []Single) string{
//	var tubeIds []string
//	for _, data := range singles {
//		for _, tube := range data.Tubes {
//			if tube.Oper == true {
//				tubeIds = append(tubeIds,tube.Id)
//			}
//		}
//	}
//	//id拼接成","隔开的字符串
//	  idStr := "'" + strings.Join(tubeIds,"','") + "'"
//	return idStr
//}

//修改样本失败状态
func (this *ConverseService) handleSampleFailed(idsStr string, response string, parentId int) {
	// 更新任务明细信息
	updatesql := "UPDATE " + TABLE_APPLY_DETAIL + " SET taskstatus = '" + strconv.Itoa(FAILED) + "' WHERE barcode IN (" + idsStr + ")" + " AND parentid = '" + strconv.Itoa(parentId) + "'"
	this.DBE.Exec(updatesql)

	// 更新任务状态
	updTaskSql := "UPDATE " + TABLE_TAST + " SET statuscode = '" + strconv.Itoa(FAILED) + "' WHERE  barcode IN (" + idsStr + ")"
	this.DBE.Exec(updTaskSql)

}

//处理样本执行成功状态
func (this *ConverseService) handleSampleSuccess(idsStr string, response string, applyMainId int) {
	if strings.Contains(response, "_storing") {
		this.sampleRKSuccessDBModify(idsStr, applyMainId)
	} else if strings.Contains(response, "_retrieving") {
		this.sampleCKSuccessDBModify(idsStr, applyMainId)
	}

}

//入库成功, 修改样本数据库状态信息
func (this *ConverseService) sampleRKSuccessDBModify(idsStr string, parentId int) error {
	updatesql := "UPDATE " + TABLE_APPLY_DETAIL + " SET IsLocked = '" + STATUS_UNLOCK + "', taskstatus = '" + strconv.Itoa(SUCCESS) + "' WHERE barcode IN (" + idsStr + ")" + " AND parentid = '" + strconv.Itoa(parentId) + "'"
	updatesql2 := "UPDATE " + TABLE_SAMPLE + " SET IsLocked = '" + STATUS_UNLOCK + "', IState = '" + RK_PASS + "' WHERE barcode IN (" + idsStr + ")"

	//更新每个样本的孔位信息

	_, err := this.DBE.Exec(updatesql)
	_, err = this.DBE.Exec(updatesql2)
	return err
}

//出库成功, 修改样本数据库状态信息
func (this *ConverseService) sampleCKSuccessDBModify(idsStr string, parentId int) error {
	var list []Bank_Apply_Detail
	var onHold []string
	var done []string
	err := this.DBE.Where("barcode IN (" + idsStr + ")").Find(&list)
	for _, one := range list {
		if strconv.Itoa(one.RecoveryId) == CK_PASS_ONHOLD {
			onHold = append(onHold, one.BarCode)
		} else if strconv.Itoa(one.RecoveryId) == CK_PASS_DONE {
			done = append(done, one.BarCode)
		}
	}

	sql := "UPDATE " + TABLE_SAMPLE + " SET istate = '" + CK_PASS_ONHOLD + "', islocked = '" + STATUS_UNLOCK + "' WHERE barcode IN ('" + strings.Join(onHold, "','") + "')"
	sql2 := "UPDATE " + TABLE_SAMPLE + " SET istate = '" + CK_PASS_DONE + "', islocked = '" + STATUS_UNLOCK + "', equipmentid = '0', shelfid = '0',boxid= '0', position = '', positioninfo = '' WHERE barcode IN ('" + strings.Join(done, "','") + "')"
	sql3 := "UPDATE " + TABLE_APPLY_DETAIL + " SET IsLocked = '" + STATUS_UNLOCK + "', taskstatus = '" + strconv.Itoa(SUCCESS) + "' WHERE barcode IN (" + idsStr + ")" + " AND parentid = '" + strconv.Itoa(parentId) + "'"
	_, err = this.DBE.Exec(sql)
	_, err = this.DBE.Exec(sql2)
	_, err = this.DBE.Exec(sql3)
	return err
}

//获取出入库单信息
func (this *ConverseService) GetApplyMain(entryNo string) Bank_Apply_Main {
	where := "entryNo = '" + entryNo + "'"
	var entity Bank_Apply_Main
	this.GetEntity(&entity, where)
	return entity
}

//根据出入库单信息判断任务信息, 并修改样本状态
func (this *ConverseService) ModifySampleStatusByApplyMainInfo(entryNo string, resp string, entity ResponseEntity) {

	applyMain := this.GetApplyMain(entryNo)
	fmt.Println("resp:", resp)

	var operaIds, abnormalIds, taskType string
	if applyMain.ApplyType == TASK_TUBE_STORING && strings.Contains(resp, "_storing") {

		fmt.Println("开始入库1",entity)

		taskType = "tube_storing" //  冻存管入库
		// 获取返回报文中成功的样本 和失败的样本
		operaIds, abnormalIds = this.getOperaSampleIdsStr(applyMain.ApplyType, applyMain.Id, resp, entity)

		for _,value :=range  entity.Data.Actual_data{
			//获取报文中的 盒子信息
			var Rack_id string = value.Target.Rack_id
			fmt.Println("冻存盒盒子编号：", Rack_id)
			// 获取报文中的 位置信息和 样本编码
			var tubes = value.Tubes
			fmt.Println("样本位置信息：", tubes)
			//新增方法 更新位置信息
			this.UpdatePosition(Rack_id, tubes, entity, applyMain.Id)
		}


	} else if applyMain.ApplyType == TASK_TUBE_RETREIVING && strings.Contains(resp, "_storing") {
		fmt.Println("开始入库2")
		//lite设备 部分管子出库
		taskType = "tube_retrieving"
		operaIds, abnormalIds = this.getOperaSampleIdsStr(applyMain.ApplyType, applyMain.Id, resp, entity)
	} else if applyMain.ApplyType == TASK_TUBE_RETREIVING && strings.Contains(resp, "_retrieving") /*resp == "rack_retrieving"*/ /*&& entity.Data.Is_end*/ {
		fmt.Println("开始入库3")
		//lite设备 整盒出库
		taskType = "tube_retrieving"
		operaIds, abnormalIds = this.getAllSampleIdsFromResEntity(entity)
	} else {


		return
	}

	// 此处判断，如果是冻存盒整盒入库，需要更新位置信息  盒  冻存盒当前的 所在的冻存架的id
	if resp == "rack_storing" {
		this.UpdateBoxInfo(entity)
	} else if resp == "rack_retrieving" {
		fmt.Println("出库")
		//rack_retrieving
		//rack_retrieving
		// 冻存盒出库任务完成以后，需要清空冻存盒中的冻存架信息，同时清空
		this.UpdateBoxInfoCK(entity)
	}

	//
	this.handleSampleSuccess(operaIds, taskType, applyMain.Id)
	if entity.Data.Type == "abnormal_end" {
		this.handleSampleFailed(abnormalIds, taskType, applyMain.Id)
	}
}

//2021/01/09 by 卢传敏
// 根据入库返回报文，更新 冻存盒的信息盒
func (this *ConverseService) UpdateBoxInfo(entity ResponseEntity) (err error) {
	//1.  获取当前返回的  冻存架信息，
	var shelf Shelf

	glog.Info("entity.Data.Actual_data::",entity.Data.Actual_data)



	// 循环处理返回的数据，如果出现多盒存入的分批处理

	for i := range entity.Data.Actual_data {

		glog.Info("操作地  ",i,"  条数据")

		boxBarcode := entity.Data.Actual_data[i].Rack_id // 冻存盒编号
		Cu := entity.Data.Actual_data[i].Target.Cu       // 设备编号
		Ltu := entity.Data.Actual_data[i].Target.Ltu     //
		Unit := entity.Data.Actual_data[i].Target.Unit
		Pos := entity.Data.Actual_data[i].Target.Pos
		Group := entity.Data.Actual_data[i].Target.Group

		fmt.Println("保存返回的冻存盒位置信息:cu：", Cu, ",Ltu", Ltu, ",Unit", Unit, ",Group", Group, ",Pos", Pos)

		sql := "select b.id EquipmentId,a.id,a.XStation,a.YStation from bank_shelf a left join bank_equipment b  on a.EquipmentId = b.id  where  b.cu = '" + utils.ToStr(Cu) + "' " +
			"and  a.Ltu = '" + utils.ToStr(Ltu) + "' and a.Unit ='" + utils.ToStr(Unit) + "' and a.Group ='" + utils.ToStr(Group) + "'"

		this.DBE.SQL(sql).Get(&shelf)
		fmt.Println("冻存架信息:", shelf.Id, shelf.XStation, shelf.YStation)

		//  更新盒所在的冻存架的信息  计算位置信息，并更新
		// 临时处理逻辑，默认 pos 为 盒子的  XStation
		_, err = this.DBE.Exec("update bank_box set XStation ='" + utils.ToStr(Pos) + "',YStation =1 ,EquipmentId ='" + com.ToStr(shelf.EquipmentId) + "',shelfId =" + utils.ToStr(shelf.Id) + " where Barcode ='" + boxBarcode + "' ")
		// 更新 当前冰箱冻存盒容量 信息
		_, err = this.DBE.Exec(" update bank_currboxcapacity  set  `A" + utils.ToStr(Pos) + "`= -1 where shelfId =" + utils.ToStr(shelf.Id) + "")

	}
	return err

}

//2021/01/09 by 卢传敏
// 根据出库返回报文，更新 冻存盒的信息盒
func (this *ConverseService) UpdateBoxInfoCK(entity ResponseEntity) (err error) {
	//1.  获取当前返回的  冻存架信息，
	var shelf Shelf

	// 循环处理返回的数据，如果出现多盒存入的分批处理

	for i := range entity.Data.Actual_data {
		boxBarcode := entity.Data.Actual_data[i].Rack_id // 冻存盒编号
		//Cu := entity.Data.Actual_data[i].source.Cu			// 设备编号
		//Ltu := entity.Data.Actual_data[i].source.Ltu		//
		//Unit := entity.Data.Actual_data[i].source.Unit
		Pos := entity.Data.Actual_data[i].Target.Pos
		//Group := entity.Data.Actual_data[i].source.Group?

		//fmt.Println("保存返回的冻存盒位置信息:cu：",Cu,",Ltu",Ltu,",Unit",Unit,",Group",Group,",Pos",Pos)
		//
		//sql := "select a.id,a.XStation,a.YStation from bank_shelf a left join bank_equipment b  on a.EquipmentId = b.id  where  b.cu = '"+utils.ToStr(Cu)+"' " +
		//	"and  a.Ltu = '"+utils.ToStr(Ltu)+"' and a.Unit ='"+utils.ToStr(Unit) +"' and a.Group ='"+utils.ToStr(Group)+"'"

		sql :=" select shelfId , EquipmentId from bank_box where code = '"+boxBarcode+"'"

		this.DBE.SQL(sql).Get(&shelf)
		fmt.Println("冻存架信息:", shelf.Id, shelf.XStation, shelf.YStation)

		//  更新盒所在的冻存架的信息  计算位置信息，并更新
		// 临时处理逻辑，默认 pos 为 盒子的  XStation
		_, err = this.DBE.Exec("update bank_box set EquipmentId=null,shelfId=null,XStation =null,YStation =null    where Barcode ='" + boxBarcode + "' ")
		// 更新 当前冰箱冻存盒容量 信息
		_, err = this.DBE.Exec(" update bank_currboxcapacity  set  `A" + utils.ToStr(Pos) + "`= -2 where shelfId =" + utils.ToStr(shelf.Id) + "")

	}
	return err

}
/**
 修改detail 信息
 */
func (this *ConverseService) UpdateDetail(BarCode string, entity ResponseEntity, parentId int,rack_id string ) {

	glog.Info("修改detail：",entity)

	var shelf Shelf
	var equipmentid string
	var ShelfId string
	for i := range entity.Data.Actual_data {
		Cu := entity.Data.Actual_data[i].Target.Cu   // 设备编号
		Ltu := entity.Data.Actual_data[i].Target.Ltu //
		Unit := entity.Data.Actual_data[i].Target.Unit
		Group := entity.Data.Actual_data[i].Target.Group


		//当  检测到数据 与当前操作盒子的数据一直时，更新  detail   和sample 信息
		if entity.Data.Actual_data[i].Target.Rack_id  == rack_id{
			sql := "select b.id EquipmentId,a.id,a.XStation,a.YStation from bank_shelf a left join bank_equipment b  on a.EquipmentId = b.id  where  b.cu = '" + utils.ToStr(Cu) + "' " +
				"and  a.Ltu = '" + utils.ToStr(Ltu) + "' and a.Unit ='" + utils.ToStr(Unit) + "' and a.Group ='" + utils.ToStr(Group) + "'"
			this.DBE.SQL(sql).Get(&shelf)
			equipmentid = strconv.Itoa(shelf.EquipmentId)
			ShelfId = strconv.Itoa(shelf.Id)
			sql = "Update bank_apply_detail Set EquipmentId=" + equipmentid + ",ShelfId=" + ShelfId + " where BarCode='" + BarCode + "' and ParentId=" + strconv.Itoa(parentId)
			this.DBE.Exec(sql)
			sql = "update bank_sample set EquipmentId=" + equipmentid + ",ShelfId=" + ShelfId + " where barcode ='" + BarCode + "' "
			this.DBE.Exec(sql)
		}


	}
}

//  20201026 卢传敏新增根据返回报文，更新位置信息
/**
 * rack_id 盒子编号
 * tubes 报文中返回的 位置和样本条码
 */
func (this *ConverseService) UpdatePosition(rack_id string, tubes []Tube, entity ResponseEntity, parentId int) {
	// 根据返回的报文中的盒子标识，获取盒子类型
	sql := "select Id,RowNum,ColumnNum from bank_box where Barcode ='" + rack_id + "'"
	var box Box
	this.DBE.SQL(sql).Get(&box)
	RowNum := box.RowNum
	ColumnNum := box.ColumnNum
	glog.Info("冻存盒的行数:", RowNum, ";冻存盒的列数：", ColumnNum)
	for i := 0; i < len(tubes); i++ {
		no := tubes[i].No
		id := tubes[i].Id
		glog.Info("样本在盒子中的位置：", no, "；样本条码: ", id)
		//计算管子在盒子中的坐标
		var box_x, box_y int

		if no%ColumnNum == 0 { // 如果 取余数为0 则 证明该数是能被  10 整除的数  为该行 最后一个孔位
			box_y = ColumnNum
			box_x = no / ColumnNum
		} else {
			box_y = no % ColumnNum
			box_x = (no / ColumnNum) + 1
		}

		glog.Info("管子在盒子中的位置坐标为：", box_y, ";", box_x)
		var position = utils.NumberToLetter(box_x) + utils.ToStr(box_y)
		sql = "update bank_sample set BoxId = '"+utils.ToStr(box.Id)+"',Position = '" + utils.ToStr(box_y) + ";" + utils.ToStr(box_x) + "' ,PositionInfo  = concat( REVERSE(SUBSTR(REVERSE(PositionInfo) FROM INSTR(REVERSE(PositionInfo),'-')+1)),'-" + position + "' ) where barcode ='" + id + "' "
		//执行sql 更新位置和坐标信息
		this.DBE.Exec(sql)
		this.UpdateDetail(id, entity, parentId,rack_id)
	}
}

//获取当前操作样本的id, 正常和异常的
func (this *ConverseService) getOperaSampleIdsStr(applyType, parentId int, resp string, entity ResponseEntity) (actualIds string, abnormalIds string) {

	//获取出入库单中所有样本信息
	var list []Bank_Apply_Detail
	where := " parentid = '" + strconv.Itoa(parentId) + "'"
	this.GetEntitysByWhere(TABLE_DETAIL, where, &list)
	var sampleIds []string
	for _, detail := range list {
		sampleIds = append(sampleIds, detail.BarCode)
	}

	//获取反馈报文中的所有成功样本Id列表
	var actualTubeIds []string
	for _, single := range entity.Data.Actual_data {
		for _, tube := range single.Tubes {
			actualTubeIds = append(actualTubeIds, tube.Id)
		}
	}

	//获取反馈报文中的所有异常样本Id列表
	var abnormalTubeIds []string
	for _, single := range entity.Data.Abnormal_data.Tubes {
		abnormalTubeIds = append(abnormalTubeIds, single.Id)
	}

	var operaTubeIds []string
	var failTubeIds []string
	if applyType == TASK_TUBE_STORING {
		for _, sampleId := range sampleIds {
			//操作成功样本Id
			for _, tubeId := range actualTubeIds {
				if sampleId == tubeId {
					operaTubeIds = append(operaTubeIds, tubeId)
					break
				}
			}

			//操作失败样本Id
			for _, tubeId := range abnormalTubeIds {
				if sampleId == tubeId {
					failTubeIds = append(failTubeIds, tubeId)
					break
				}
			}

		}
	}

	if applyType == TASK_TUBE_RETREIVING {
		for _, sampleId := range sampleIds {
			//操作成功样本Id
			for index, tubeId := range actualTubeIds {
				if index == len(actualTubeIds)-1 && tubeId != sampleId {
					operaTubeIds = append(operaTubeIds, sampleId)
				}
			}

			//操作失败样本Id
			for _, tubeId := range abnormalTubeIds {
				if sampleId == tubeId {
					failTubeIds = append(failTubeIds, tubeId)
					break
				}
			}
		}
	}

	actualIds = "'" + strings.Join(operaTubeIds, "','") + "'"
	abnormalIds = "'" + strings.Join(failTubeIds, ",") + "'"
	return
}

//当任务为rack_retrieving 且 end 时, 获取所有样本Ids
func (this *ConverseService) getAllSampleIdsFromResEntity(entity ResponseEntity) (actualIds string, abnormalIds string) {
	//获取反馈报文中的所有成功样本Id列表
	var actualTubeIds []string
	for _, single := range entity.Data.Actual_data {
		for _, tube := range single.Tubes {
			actualTubeIds = append(actualTubeIds, tube.Id)
		}
	}
	actualIds = "'" + strings.Join(actualTubeIds, "','") + "'"
	abnormalIds = ""
	return
}

////样本状态修改
//func (this *ConverseService)SampleStatusModify(statusCode int , res ResponseEntity){
//	if statusCode == SUCCESS {
//		this.SampleApplyDetailStatusBatchModify(statusCode, res.Data.Task_id)
//	}else if statusCode == REJECT {
//		this.SampleApplyDetailStatusBatchModify(FAILED, res.Data.Task_id)
//	}else if statusCode == FAILED {
//		this.SampleApplyDetailStatusPartsModify(res)
//	}
//}

//获取任务原始信息
//func (this *ConverseService) GetBasicTaskInfo(task_id string) ([]Sample_Storage_Task, error){
//	sql := `SELECT
//				d.EquipmentId,
//				e.RowNum e_row,
//				e.ColumnNum e_col,
//				d.ShelfId,
//				s.XStation s_x,
//				s.YStation s_y,
//				s.RowNum s_row,
//				s.ColumnNum s_col,
//				d.BoxId,
//				b.XStation b_x,
//				b.YStation b_y,
//				b.RowNum b_row,
//				b.ColumnNum b_col,
//				d.Position,
//				d.BarCode,
//				a.EntryNo task_id
//			FROM
//				` + TABLE_DETAIL + ` d
//				JOIN ` + TABLE_EQUIPMENT + ` e ON d.EquipmentId = e.Id
//				JOIN ` + TABLE_SHELF + ` s ON d.ShelfId = s.Id
//				JOIN ` + TABLE_BOX + ` b ON d.BoxId = b.Id
//				JOIN ` + TABLE_SAMPLE_APPLY + ` a ON d.ParentId = a.Id
//			WHERE
//				a.EntryNo = '` + task_id + `' AND a.ApplyStatus = '2'`
//	var list []Sample_Storage_Task
//	err := this.DBE.SQL(sql).Find(&list)
//	if err != nil {
//		return nil,err
//	}
//	return list,err
//}

//原始位置信息转换 样本库调用
//func (this *ConverseService) TransferPosition(one *Sample_Storage_Task) {
//	one.Unit = (one.S_Y-1)*one.E_Col + one.S_X
//	one.Pos = (one.B_Y-1)*one.S_Col + one.B_X
//	if one.Position != "" {
//		coord := strings.Split(one.Position, ";")
//		x, _ := strconv.Atoi(coord[0])
//		y, _ := strconv.Atoi(coord[1])
//		one.No = (y-1)*one.B_Col + x
//	}
//	one.Ltu = LTU
//	//one.Group = GROUP
//}

//处理任务原始信息   样本库调用
//func (this *ConverseService) HandleTaskInfo(list []Sample_Storage_Task, applyType string) *[]Sample_Storage_Task{
//	var resultList []Sample_Storage_Task
//	for _, value := range list {
//		this.AddTaskType(&value, applyType)
//		this.TransferPosition(&value)
//		resultList = append(resultList, value)
//	}
//	return &resultList
//}

//添加任务类型
//func (this *ConverseService) AddTaskType(one *Sample_Storage_Task, applyType string){
//	if  applyType == "1" {
//		one.Task_type = 3	//冻存管入库
//		one.OperaMode = "manua"
//	}else if applyType == "2" {
//		one.Task_type = 4	//冻存管出库
//	}
//}

//保存异常信息
func (this *ConverseService) SaveTaskExcepMsg(msg, taskId string) error {
	sql := "UPDATE " + TABLE_TAST + " SET exception = '" + msg + "' WHERE task_id = '" + taskId + "'"
	_, err := this.DBE.Exec(sql)
	return err
}

//保存异常信息
func (this *ConverseService) SaveSampleExcepMsg(msg, entryNo string) error {
	sql := "UPDATE " + TABLE_SAMPLE_APPLY + " SET exception = '" + msg + "' WHERE entryno = '" + entryNo + "'"
	_, err := this.DBE.Exec(sql)
	return err
}

//根据条件删除数据，不记录日志
func (this *ConverseService) DeleteEntityBytbl(tablename string, where string) (err error) {
	if where == "" {
		where = "1=2"
	}
	sql := `delete from ` + tablename + ` where ` + where
	_, err = this.DBE.Exec(sql)
	return
}

//样本库分表
func (s *ConverseSessionService) InsertEntityBytbl(tablename string, entity interface{}) (affected int64, err error) {
	affected, err = s.Session.Table(tablename).Insert(entity)
	LogError(err)
	return
}

//获取设备名称
func (s *ConverseService) GetEquipmentName(cu int) string {
	sql := "SELECT name from " + TABLE_EQUIPMENT + " where cu = '" + strconv.Itoa(cu) + "'"
	var entity Equipment
	s.DBE.SQL(sql).Get(&entity)
	return entity.Name
}

//异常信息转换
func (s *ConverseService) HandleCauses(causes []Cause) string {
	var exceptInfo string
	for _, cause := range causes {
		eName := s.GetEquipmentName(cause.Cu)
		exceptInfo += s.GetReason(cause, eName)
	}
	return exceptInfo
}

//根据异常码获取异常原因
func (s *ConverseService) GetReason(cause Cause, equipmentName string) string {
	var reasonStr string
	switch cause.Reason {
	case 1:
		reasonStr = "存储位不够;"
		break
	case 2:
		reasonStr = "单次任务涉及的冻存盒数量超出限制;"
		break
	case 3:
		reasonStr = "指定的位置已经被占用或者位置不正确，无法存入;"
		break
	case 4:
		reasonStr = "没有权限对指定位置进行操作;"
		break
	case 5:
		reasonStr = "指定的编号不正确，无法完成操作;"
		break
	case 6:
		reasonStr = "报文数据不完整，缺少冻存管数据;"
		break
	case 7:
		reasonStr = "相同的冻存盒位置只允许有一组报文数据;"
		break
	case 8:
		reasonStr = "半自动设备在不配置转运机器人的情况下，一个存管任务只允许操作一台设备;"
	}

	if cause.Cu != 0 {
		//reasonStr = strconv.Itoa(cause.Cu)+"号设备, " + equipmentName + "," + reasonStr
		reasonStr = "设备: " + equipmentName + "," + reasonStr
	}
	return reasonStr
}

//处理Exceptions异常信息
func (s *ConverseService) HandleExceptions(excepts []Exception) string {
	var exceptStr string
	for _, except := range excepts {
		eName := s.GetEquipmentName(except.Cu)
		for _, code := range except.Codes {
			//var tempStr = string(except.Cu)+"号设备," + eName + ","
			var tempStr = "设备: " + eName + ","
			switch code {
			case 40200:
				tempStr += "移动盒子过程中设备故障，动作失败;"
				break
			case 40201:
				tempStr += "移动盒子过程中目标位置不为空，动作取消;"
				break
			case 40202:
				tempStr += "移动盒子过程中起始位置为空，动作取消;"
				break
			case 40300:
				tempStr += "移动管子过程中设备故障，动作失败;"
				break
			case 40301:
				tempStr = "移动管子过程中目标位置不为空，动作取消;"
				break
			case 40302:
				tempStr = "移动管子过程中起始位置为空，动作取消;"
			}
			exceptStr += tempStr
		}
	}
	return exceptStr
}

//处理返回设备状态数据, 并存储到数据表里
func RecordDeviceData(list []List_Data) {
	t := time.Now()
	var data []GenePoint_Device_Report_Data
	for _, one := range list {
		var piece GenePoint_Device_Report_Data
		piece.Cu = one.Cu
		piece.Addr = one.Addr
		piece.Type = one.Type
		piece.Value = one.Value
		piece.RecordTime = t
		data = append(data, piece)
	}
	svc := GetConverseService(utils.DBE)
	svc.InsertEntity(data)
}


// 更新异常信息
func (s *ConverseService)SaveErrInfo(err ,taskid string){
	// 任务发送失败，，，修改任务状态，，，，提示任务执行失败
	// 请求发送失败

	svc :=  GetConverseService(utils.DBE)

	svc.SaveTaskExcepMsg(err, taskid)
	svc.SaveSampleExcepMsg(err, taskid)
}