PhysicalDevice/Detector/Trixel/DIOS.Dev.FPD.TrixellDR/DIOS.Dev.FPDDeviceMould/DIOS.Dev.FPD.CalibUnit.cpp

// CCOS.Dev.FPD.DEMO.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include "CCOS.Dev.FPDDeviceMould.hpp"

using namespace CCOS::Dev;
using namespace CCOS::Dev::Detail::Detector;
namespace nsFPD = CCOS::Dev::Detail::Detector;

extern Log4CPP::Logger* gLogger;

//-----------------------------------------------------------------------------
//		CalibUnit
//-----------------------------------------------------------------------------
nsFPD::CalibUnit::CalibUnit()
{
	m_CalibMode = CCOS_CALIBRATION_MODE_ZSKK;
	m_CurrentCalibType = CCOS_CALIBRATION_TYPE_NONE;
	m_CalibStatus = CCOS_CALIBRATION_STATUS_MAX;
	m_strCalibProgress = "0";
	m_strUploadCalibrationFilesResult = "0";
	m_strSaveCalibrationFileFinish = "0";
}

nsFPD::CalibUnit:: ~CalibUnit()
{

}

void OEM_IF nsFPD::CalibUnit::SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
{
	m_EventCenter = EventCenter;
}


RET_STATUS nsFPD::CalibUnit::JSSetSID(std::string in, std::string& out)
{
	Info("JSSetSID. {$}", in.c_str());
	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];
	return SetSID(mode);
}

RET_STATUS nsFPD::CalibUnit::JSActiveCalibration(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];

	Info("JSActiveCalibration. {$}", in.c_str());
	Info("Calibrationtype is {$}", mode);
	out = "test@ActiveCalibration";
	CCOS_CALIBRATION_TYPE type = CCOS_CALIBRATION_TYPE_NONE;
	if (mode == CCOS_CALIBRATION_TYPE_DARK)
	{
		type = CCOS_CALIBRATION_TYPE_DARK;
	}
	else if (mode == CCOS_CALIBRATION_TYPE_XRAY)
	{
		type = CCOS_CALIBRATION_TYPE_XRAY;
	}
	RET_STATUS bret = ActiveCalibration(type);
	if (RET_STATUS::RET_SUCCEED == bret)
	{
		m_CurrentCalibType = type;
	}
	return bret;
}

RET_STATUS nsFPD::CalibUnit::JSGetRequestedDose(std::string in, std::string& out)
{
	Info("JSGetRequestedDose");
	string strDoseInfo = "";
	RET_STATUS bret = GetRequestedDose(strDoseInfo);
	if (RET_STATUS::RET_SUCCEED == bret)
	{
		out = strDoseInfo;
	}
	return bret;
}


RET_STATUS nsFPD::CalibUnit::JSSetRequestedDose(std::string in, std::string& out)
{
	Info("JSSetRequestedDose. \n{$}", in.c_str());
	RET_STATUS nRet = SetRequestedDose(in);
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::SetRequestedDose(std::string in)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSPrepareCalibration(std::string in, std::string& out)
{
	Info("JSPrepareCalibration.");
	return PrepareCalibration();
}

RET_STATUS nsFPD::CalibUnit::JSStartCalibration(std::string in, std::string& out)
{
	Info("JSStartCalibration.");
	return StartCalibration();
}

RET_STATUS OEM_IF nsFPD::CalibUnit::PauseCalibration()
{
	Info("PauseCalibration.");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSStopCalibration(std::string in, std::string& out)
{
	Info("JSStopCalibration.");
	return StopCalibration();
}

RET_STATUS nsFPD::CalibUnit::JSSetCorrectionType(std::string in, std::string & out)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibStatus(std::string & out)
{
	auto szFDinfo = std::to_string(m_CalibStatus);
	out = szFDinfo;

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetCalibrationStatus(string in)
{
	Info("SetCalibrationStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	int nCalibrationStatus = atoi(in.c_str());
	string strTemp = "";
	switch (nCalibrationStatus)
	{
	case CCOS_CALIBRATION_STATUS_ERROR:
		strTemp = "ZSKK_FPD_STATE_ERROR";
		break;
	case CCOS_CALIBRATION_STATUS_STANDBY:
		strTemp = "ZSKK_FPD_STATE_STANDBY";
		break;
	case CCOS_CALIBRATION_STATUS_ACTIVE:
		strTemp = "ZSKK_FPD_STATE_ACTIVE";
		break;
	case CCOS_CALIBRATION_STATUS_RUNNING:
		strTemp = "ZSKK_FPD_STATE_RUNNING";
		break;
	case CCOS_CALIBRATION_STATUS_PAUSE:
		strTemp = "ZSKK_FPD_STATE_PAUSE";
		break;
	case CCOS_CALIBRATION_STATUS_PREPARE:
		strTemp = "ZSKK_FPD_STATE_PREPARE";
		break;
	default:
		break;
	}
	m_CalibStatus = (CCOS_CALIBRATION_STATUS)nCalibrationStatus;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationStatus, in);
	Info("CalibrationStatus: {$}",strTemp.c_str());
	return RET_STATUS::RET_SUCCEED;
}

CCOS_CALIBRATION_STATUS OEM_IF nsFPD::CalibUnit::GetCalibrationStatus()
{
	return m_CalibStatus;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibProgress(std::string & out)
{
	out = m_strCalibProgress;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetCalibrationProgress(string in)
{
	Info("SetCalibrationProgress in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strCalibProgress = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationProgress, m_strCalibProgress);
	Info("CalibrationProgress: {$}", m_strCalibProgress);
	return RET_STATUS::RET_SUCCEED;
}

CCOS_CALIBRATION_TYPE OEM_IF nsFPD::CalibUnit::GetCalibrationType()
{
	return m_CurrentCalibType;
}

RET_STATUS nsFPD::CalibUnit::JSUploadCalibrationFiles(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string mode = "";
	try
	{
		mode = (string)json[0];
	}
	catch (...)
	{
		return RET_STATUS::RET_FAILED;
	}

	return UploadCalibrationFiles(mode);
}

RET_STATUS nsFPD::CalibUnit::JSGetUploadCalibrationFilesResult(std::string & out)
{
	out = m_strUploadCalibrationFilesResult;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetUploadCalibrationFilesResult(string in)
{
	Info("SetUploadCalibrationFilesResult in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strUploadCalibrationFilesResult = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::UploadCalibrationFilesResult, m_strUploadCalibrationFilesResult);
	Info("UploadCalibrationFilesResult:{$}", m_strUploadCalibrationFilesResult);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetSupportCalibrationType(std::string& out)
{
	ResDataObject tmp;
	if (Support_DarkCalib())
	{
		tmp.add("Offset", CCOS_CALIBRATION_TYPE_DARK);
	}
	if (Support_XrayCalib())
	{
		tmp.add("Gain", CCOS_CALIBRATION_TYPE_XRAY);
	}
	if (tmp.size() > 0)
	{
		out = tmp.encode();
	}
	else
	{
		out = "";
		return RET_STATUS::RET_NOSUPPORT;
	}
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::CalibUnit::Support_DarkCalib()
{
	return false;
}

bool nsFPD::CalibUnit::Support_XrayCalib()
{
	return false;
}


RET_STATUS nsFPD::CalibUnit::JSGetHaveImgCalibration(std::string& out)
{
	if (Support_HaveImageCalib())
	{
		out =  "1";
	}
	else
	{
		out =  "0";
	}
	Info("JSGetHaveImgCalibration out:{$}",out.c_str());
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::CalibUnit::Support_HaveImageCalib()
{
	return false;
}


RET_STATUS nsFPD::CalibUnit::JSGetCalibrationStep(std::string in, std::string& out)
{
	Info("JSGetCalibrationStep. \n{$}", in.c_str());
	int nDetectorID = 0;
	string strCalibrationStepInfo;
	
	RET_STATUS nRet = GetCalibrationStep(nDetectorID, strCalibrationStepInfo);
	out = strCalibrationStepInfo;
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::GetCalibrationStep(int nDetectorID, std::string& strCalibrationStepInfo)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSAcceptCalibration(std::string in, std::string& out)
{
	RET_STATUS nRet = AcceptCalibration();
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::AcceptCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSRejectCalibration(std::string in, std::string& out)
{
	RET_STATUS nRet = RejectCalibration();
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::RejectCalibration()
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSSaveCalibrationFile(std::string in, std::string& out)
{
	Info("JSSaveCalibrationFile.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	bool bSaveFlag = false;
	try
	{
		bSaveFlag = (bool)jsonInput[0];
	}
	catch (...)
	{
		Error("JSSaveCalibrationFile parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = SaveCalibrationFile(bSaveFlag);
	return nRet;
}


RET_STATUS nsFPD::CalibUnit::SaveCalibrationFile(bool bSaveFlag)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::CalibUnit::JSGetSaveCalibrationFileFinish(std::string& out)
{
	out = m_strSaveCalibrationFileFinish;
	return RET_STATUS::RET_SUCCEED;
}


void OEM_IF nsFPD::CalibUnit::SetSaveCalibrationFileFinish(bool bResult)
{
	string strFPDInfo = std::to_string(bResult);
	m_strSaveCalibrationFileFinish = strFPDInfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::SaveCalibrationFileFinish, m_strSaveCalibrationFileFinish);
	Info("SetSaveCalibrationFileFinish. {$}", strFPDInfo);
}


RET_STATUS nsFPD::CalibUnit::JSStartOffset(std::string in, std::string& out)
{
	FINFO("JSStartOffset: {$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	bool isAll = false;
	try
	{
		isAll = (bool)jsonInput[0];
	}
	catch (...)
	{
		FERROR("JSStartOffset parameter error");
		return RET_STATUS::RET_FAILED;
	}
	return StartOffset(isAll);
}

RET_STATUS nsFPD::CalibUnit::StartOffset(bool isAll)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSAbortOffset(std::string in, std::string& out)
{
	FINFO("JSAbortOffset");
	return AbortOffset();
}

RET_STATUS nsFPD::CalibUnit::AbortOffset()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetOffsetStatus(std::string& out)
{
	out = m_strOffsetStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetOffsetStatus(std::string in)
{
	FINFO("SetOffsetStatus in:{$}", in);
	m_strOffsetStatus = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "OffsetStatus", m_strOffsetStatus);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetOffsetCounts(std::string& out)
{
	out = m_strOffsetCounts;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetOffsetCounts(std::string in)
{
	FINFO("SetOffsetCounts in:{$}", in);
	m_strOffsetCounts = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "OffsetCounts", m_strOffsetCounts);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetOffsetProgress(std::string& out)
{
	out = m_strOffsetProgress;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetOffsetProgress(std::string in)
{
	FINFO("SetOffsetProgress in:{$}", in);
	m_strOffsetProgress = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "OffsetProgress", m_strOffsetProgress);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetOffsetInterval(std::string& out)
{
	out = m_strOffsetInterval;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetOffsetInterval(std::string in)
{
	FINFO("SetOffsetInterval in:{$}", in);
	m_strOffsetInterval = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSUpdateOffsetInterval(std::string in, std::string& out)
{
	FINFO("JSUpdateOffsetInterval in:{$}", in);
	m_strOffsetInterval = in;
	out = m_strOffsetInterval;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibMode(std::string& out)
{
	auto szOut = std::to_string(m_CalibMode);
	out = szOut;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetCalibMode(string in)
{
	FINFO("SetCalibMode in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	int nCalibMode = std::stoi(in);
	m_CalibMode = (CCOS_CALIBRATION_MODE)nCalibMode;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSUpdateCalibMode(std::string in, std::string& out)
{
	FINFO("JSUpdateCalibMode in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	int nCalibMode = std::stoi(in);
	m_CalibMode = (CCOS_CALIBRATION_MODE)nCalibMode;

	return UpdateCalibMode(m_CalibMode);
}

RET_STATUS nsFPD::CalibUnit::UpdateCalibMode(CCOS_CALIBRATION_MODE eCalibMode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetLastCalibrationDate(std::string& out)
{
	out = m_strLastCalibrationDate;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetLastCalibrationDate(string in)
{
	FINFO("SetLastCalibrationDate in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strLastCalibrationDate = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::LastCalibrationDate, m_strLastCalibrationDate);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSUpdateLastCalibrationDate(std::string in, std::string& out)
{
	FINFO("JSUpdateLastCalibrationDate in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strLastCalibrationDate = in;
	return UpdateLastCalibrationDate(m_strLastCalibrationDate);
}

RET_STATUS nsFPD::CalibUnit::UpdateLastCalibrationDate(std::string in)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSGetCalibrationFileExpireTime(std::string& out)
{
	out = m_strCalibrationFileExpireTime;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::SetCalibrationFileExpireTime(string in)
{
	FINFO("SetCalibrationFileExpireTime in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strCalibrationFileExpireTime = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationFileExpireTime, m_strCalibrationFileExpireTime);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::CalibUnit::JSUpdateCalibrationFileExpireTime(std::string in, std::string& out)
{
	FINFO("JSUpdateCalibrationFileExpireTime in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strCalibrationFileExpireTime = in;
	return UpdateCalibrationFileExpireTime(m_strCalibrationFileExpireTime);
}

RET_STATUS nsFPD::CalibUnit::UpdateCalibrationFileExpireTime(std::string in)
{
	return RET_STATUS::RET_SUCCEED;
}