package converseService

import (
	"crypto/md5"
	"fmt"
	"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) 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 string) *RequestEntity {
	var requestName string
	switch taskType {
	case 1:
		requestName = "rack_storing"
		break
	case 2:
		requestName = "rack_retrieving"
		break
	case 3:
		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"
	}
	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:
		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.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 Single
	var exist bool
	if entity.Data.Task_data != nil {
		one = entity.Data.Task_data.(Single)
		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) 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 {
	sql := "UPDATE " + TABLE_SAMPLE_APPLY + " SET taskstatus = '" + strconv.Itoa(statusCode) + "' WHERE entryno = '" + entryNo + "'"
	_, 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)
}

//处理样本执行成功状态
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)
	var operaIds, abnormalIds, taskType string
	if applyMain.ApplyType == TASK_TUBE_STORING && strings.Contains(resp, "_storing") {
		taskType = "tube_storing"
		operaIds, abnormalIds = this.getOperaSampleIdsStr(applyMain.ApplyType, applyMain.Id, resp, entity)
	} else if applyMain.ApplyType == TASK_TUBE_RETREIVING && strings.Contains(resp, "_storing") {
		//lite设备 部分管子出库
		taskType = "tube_retrieving"
		operaIds, abnormalIds = this.getOperaSampleIdsStr(applyMain.ApplyType, applyMain.Id, resp, entity)
	} else if applyMain.ApplyType == TASK_TUBE_RETREIVING && resp == "rack_retrieving" && entity.Data.Is_end {
		//lite设备 整盒出库
		taskType = "tube_retrieving"
		operaIds, abnormalIds = this.getAllSampleIdsFromResEntity(entity)
	} else {
		return
	}

	this.handleSampleSuccess(operaIds, taskType, applyMain.Id)
	if entity.Data.Type == "abnormal_end" {
		this.handleSampleFailed(abnormalIds, taskType, applyMain.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)
}