PhysicalDevice/Detector/CCOS.Dev.FPDDeviceMould/CCOS.Dev.FPD.CalibUnit.cpp

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

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

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

//extern Log4CPP::Logger* mLog::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";
	m_strOffsetStatus = "Idle";
	m_strOffsetCounts = "0";
	m_strOffsetProgress = "0";
	m_strOffsetInterval = "30";
	m_strLastCalibrationDate = "0000-00-00 00:00:00";
	m_strCalibrationFileExpireTime = "90";
	m_strCalibrationFileExpirationReminder = "1";
}

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)
{
	FINFO("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)
{
	cout << "CalibUnit::JSActiveCalibration in:" << in << endl;
	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];
	cout << "CalibUnit::JSActiveCalibration mode:" << mode << endl;

	FINFO("JSActiveCalibration. {$}", in.c_str());
	FINFO("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)
{
	FINFO("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)
{
	FINFO("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)
{
	FINFO("JSPrepareCalibration.");
	return PrepareCalibration();
}

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

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

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

RET_STATUS CCOS::Dev::Detail::Detector::CalibUnit::JSAbortCalibration(std::string in, std::string& out)
{
	return AbortCalibration();
}

RET_STATUS CCOS::Dev::Detail::Detector::CalibUnit::JSCompleteCalibration(std::string in, std::string& out)
{
	return CompleteCalibration();
}

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)
{
	FINFO("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);
	FINFO("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)
{
	FINFO("SetCalibrationProgress in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strCalibProgress = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CalibrationProgress, m_strCalibProgress);
	FINFO("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)
{
	FINFO("SetUploadCalibrationFilesResult in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strUploadCalibrationFilesResult = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::UploadCalibrationFilesResult, m_strUploadCalibrationFilesResult);
	FINFO("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";
	}
	FINFO("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)
{
	FINFO("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)
{
	FINFO("JSSaveCalibrationFile.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	bool bSaveFlag = false;
	try
	{
		bSaveFlag = (bool)jsonInput[0];
	}
	catch (...)
	{
		FERROR("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);
	FINFO("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;
}

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

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

RET_STATUS nsFPD::CalibUnit::JSUpdateCalibrationFileExpirationReminder(std::string in, std::string& out)
{
	FINFO("JSUpdateCalibrationFileExpirationReminder in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strCalibrationFileExpirationReminder = in;
	return UpdateCalibrationFileExpirationReminder(m_strCalibrationFileExpirationReminder);
}

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