GrpcPrint/PrintS/job/JobController.cpp

#include "JobController.h"
#include <commdlg.h>
#include <time.h>
#include "../Toast.h"
#include "../LanguageManager.h"
#include "../global.h"
#include <fstream>
#include "../protobuf/stream.pb.h"

JobController::LoadProgressInfoFlag JobController::m_LoadProgressInfoFlag = CkeckingJobData;
//vector<string> JobController::m_LoadErrorInfo = vector<string>();
CRITICAL_SECTION JobController::m_LoadInfoCS;

float JobController::m_LoadProgress = 0.0f;

JobController::JobController()
	: m_CurrentJob(NULL)
	, m_LoadThead(INVALID_HANDLE_VALUE)
	, m_LoadFlag(false)
	, m_FilePath("")
	, m_TempJob(NULL)
	, m_PrepareJob(NULL)
	, m_SavePreJobThread(INVALID_HANDLE_VALUE)
{
	InitializeCriticalSection(&m_cs);
	InitializeCriticalSection(&m_PreJobCS);

	m_LoadProgressInfoMap[AnalyzingJobData] = g_LngManager->UI_AnalyzingJobData;
	m_LoadProgressInfoMap[CkeckingJobData] = g_LngManager->UI_CheckingJobData;
}


JobController::~JobController()
{
	RemoveAllJob();
	DeleteCriticalSection(&m_cs);
	DeleteCriticalSection(&m_PreJobCS);
}

void JobController::StartLoadPrepareJob()
{
	HANDLE lp = AtlCreateThread(LoadPrepareJobProc, this);
	CloseHandle(lp);
}

DWORD WINAPI JobController::LoadPrepareJobProc(JobController* _this) {
	if (!_this)return 0;
	char buffer[512];
	//MachineCfg* mcfg = ConfigManager::GetInstance()->GetMachineCfg();
	//sprintf_s(buffer, sizeof(buffer), "%sPrepareJob/%d.h3d", g_AppPath.c_str(), mcfg->m_MachineType);
	sprintf_s(buffer, sizeof(buffer), "D://jobfile//bigmodel_name.h3d");
	H3DFileProcessor* fp = new H3DFileProcessor();
	if (fp->Process(buffer) != BP_SUCCESS)
	{
		delete fp;
		return NULL;
	}
	map<int, bool>* precfgs = ConfigManager::GetInstance()->GetPreJobParamCfg();
	vector<MetaData::Layer*> layers = fp->GetMetaData()->GetLayersVec();
	for (map<int, bool>::iterator it = precfgs->begin(); it != precfgs->end(); it++) {
		if (it->first < layers.size()) {
			layers[it->first]->isPrintable = it->second;
		}
	}
	EnterCriticalSection(&_this->m_PreJobCS);
	if (_this->m_PrepareJob) {
		delete _this->m_PrepareJob;
	}
	_this->m_PrepareJob = fp;
	LeaveCriticalSection(&_this->m_PreJobCS);
	return 0;
}

bool JobController::LoadJob(string filepath)
{
	SetLoadProgress(0.0f);
	JobController::m_LoadProgressInfoFlag = CkeckingJobData;
	string filename = filepath.substr(filepath.find_last_of("\\") + 1, filepath.length() - 1);
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL && m_CurrentJob->GetJobFileName() == filename) {
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_AddTaskRepeat->ShowText(), 3000));
		LeaveCriticalSection(&m_cs);
		return false;
	}


	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
		printf("m_CurrentJob:%p", m_CurrentJob);
	}
	m_LoadFlag = true;
	LeaveCriticalSection(&m_cs);

	m_FilePath = filepath;
	m_LoadThead = AtlCreateThread(LoadProc, this);
	return true;
}

DWORD WINAPI JobController::LoadProc(JobController* _this)
{
	if (_this) {
		_this->LoadRun();
		EnterCriticalSection(&_this->m_cs);
		_this->m_LoadFlag = false;
		LeaveCriticalSection(&_this->m_cs);
	}

	return 0;
}

void JobController::LoadRun()
{
	if (m_FilePath.find(".h3d") != string::npos)
	{
		m_TempJob = new H3DFileProcessor();
	}
	else
		m_TempJob = new JobFileProcessor();

	if (m_TempJob->Process(m_FilePath) != BP_SUCCESS) {
		delete m_TempJob;
		m_TempJob = NULL;
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_NotSupportData->ShowText(), 3000, Toast::COLOR_RED));
		return;
	}
	else {
		m_TempJob->GetMetaData()->ReCalcEvaTime();
		EnterCriticalSection(&m_cs);
		m_CurrentJob = m_TempJob;
		m_CurrentJob->GetMetaData()->ResetIfs();
		printf("m_CurrentJob:%p\n", m_CurrentJob);
		// 根据工艺参数设置层的默认供粉量
		ParamSetCfg::ParamSet* ps = ConfigManager::GetInstance()->GetParamSetCfg()->ParamSetVec[0];
		std::vector<MetaData::Layer*>& layers = m_CurrentJob->GetMetaData()->GetLayersVec();
		for (unsigned int i = 0; i < ps->PowderSets.size(); i++)
		{
			for (unsigned int layer = ps->PowderSets[i]->start_layer;
				layer < m_CurrentJob->GetLayerCount() && layer <= ps->PowderSets[i]->end_layer;
				layer++)
			{
				layers[layer - 1]->powder = ps->PowderSets[i]->powder * layers[layer - 1]->layer_thickness;
			}
		}

		m_CurrentJob->GetMetaData()->GetLayer(0)->scan_times = 2;

		LeaveCriticalSection(&m_cs);
	}
}


float JobController::GetLoadProgress()
{
	float rel = 0;
	EnterCriticalSection(&m_LoadInfoCS);
	rel = m_LoadProgress;
	LeaveCriticalSection(&m_LoadInfoCS);
	return rel;
}

string JobController::GetLoadInfo()
{
	return m_LoadProgressInfoMap[m_LoadProgressInfoFlag]->ShowText();
}

bool JobController::IsLoadFinished()
{
	bool rel = false;
	EnterCriticalSection(&m_cs);
	rel = !m_LoadFlag;
	LeaveCriticalSection(&m_cs);
	return rel;
}

void JobController::RemoveJob(string job_titel)
{
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
		printf("m_CurrentJob:%p", m_CurrentJob);
	}
	LeaveCriticalSection(&m_cs);
}

void JobController::RemoveAllJob()
{
	EnterCriticalSection(&m_cs);
	if (m_CurrentJob != NULL) {
		delete m_CurrentJob;
		m_CurrentJob = NULL;
		m_TempJob = NULL;
		printf("m_CurrentJob:%p", m_CurrentJob);
	}
	LeaveCriticalSection(&m_cs);
}

FileProcessor* JobController::GetUnFinishedJob()
{
	if (m_CurrentJob->IsFinished())
		return m_CurrentJob;
	else
		return NULL;
}


void JobController::StartSavePrepareJob()
{
	if (m_SavePreJobThread != INVALID_HANDLE_VALUE)return;
	m_SavePreJobThread = AtlCreateThread(SavePrepareJobProc, this);
}

DWORD WINAPI JobController::SavePrepareJobProc(JobController* _this)
{
	if (!_this || !_this->m_PrepareJob) {
		if (_this->m_SavePreJobThread != INVALID_HANDLE_VALUE)CloseHandle(_this->m_SavePreJobThread);
		_this->m_SavePreJobThread = INVALID_HANDLE_VALUE;
		return 0;
	}
	_this->m_PrepareJob->UpdateFile();
	if (_this->m_SavePreJobThread != INVALID_HANDLE_VALUE)CloseHandle(_this->m_SavePreJobThread);
	_this->m_SavePreJobThread = INVALID_HANDLE_VALUE;
	ConfigManager::GetInstance()->SavePreJobParamCfg();
	g_Toast->AddToast(new ToastBean(g_LngManager->Toast_WriteFileSuccess->ShowText(), 3000, Toast::COLOR_GREEN));
	return 0;
}

bool JobController::IsSavingPrepareJob() {
	if (m_SavePreJobThread != INVALID_HANDLE_VALUE) {
		return true;
	}
	else return false;
}


void  JobController::LoadJob(const list<Item>& lst, ::stream::ResponseAny** response) {
	string path;
	for (auto it = lst.begin(); it != lst.end(); ++it) {
		if (it->nameKey == "path")  path = it->strValue;
	}
	stream::ComResponce result;
	result.set_res(LoadJob(path));
	(*response)->mutable_data()->PackFrom(result); 
}


void JobController::GeneralInfoReq(::stream::ResponseAny**  response) {
	stream::GeneralInfo result;
	if (m_CurrentJob && m_CurrentJob->GetMetaData()) {
		result.set_isok(true);
		result.set_material(m_CurrentJob->GetMetaData()->GetMaterial());
		result.set_job_name(m_CurrentJob->GetMetaData()->GetJobTitle());   //任务名    
		auto jobDim = result.mutable_jobdimensions();
		jobDim->set_xmax(m_CurrentJob->GetMetaData()->GetJobDimensions()->xmax);
		jobDim->set_xmin(m_CurrentJob->GetMetaData()->GetJobDimensions()->xmin);
		jobDim->set_ymax(m_CurrentJob->GetMetaData()->GetJobDimensions()->ymax);
		jobDim->set_ymin(m_CurrentJob->GetMetaData()->GetJobDimensions()->ymin);
		jobDim->set_zmax(m_CurrentJob->GetMetaData()->GetJobDimensions()->zmax);
		jobDim->set_zmin(m_CurrentJob->GetMetaData()->GetJobDimensions()->zmin);
	}
	else {
		result.set_isok(false);
	}
	(*response)->mutable_data()->PackFrom(result);
}


void JobController::PartInfoReq(::stream::ResponseAny** response) {
	stream::Parts result;
	if (m_CurrentJob && m_CurrentJob->GetMetaData()) {
		result.set_isok(true);
		for (auto it = m_CurrentJob->GetMetaData()->GetPartVec().begin();
			it != m_CurrentJob->GetMetaData()->GetPartVec().end(); ++it) {
			::stream::Part* part = result.add_ps();
			part->set_id((*it)->id);
			part->set_name((*it)->name);
			part->set_sourceid((*it)->sourceId);
			auto dim = part->mutable_dimensions();
			dim->set_xmax((*it)->dimensions->xmax);
			dim->set_xmin((*it)->dimensions->xmin);
			dim->set_ymax((*it)->dimensions->ymax);
			dim->set_ymin((*it)->dimensions->ymin);
			dim->set_zmax((*it)->dimensions->zmax);
			dim->set_zmin((*it)->dimensions->zmin);

			auto layerdim = part->mutable_layerdimensions();
			layerdim->set_xmax((*it)->dimensions->xmax);
			layerdim->set_xmin((*it)->dimensions->xmin);
			layerdim->set_ymax((*it)->dimensions->ymax);
			layerdim->set_ymin((*it)->dimensions->ymin);
			layerdim->set_zmax((*it)->dimensions->zmax);
			layerdim->set_zmin((*it)->dimensions->zmin);

			auto partPosBean = part->mutable_partposbean();
			partPosBean->set_jobid((*it)->partPosBean.m_JobId);
			partPosBean->set_isselect((*it)->partPosBean.m_IsSelect);
			partPosBean->set_partid((*it)->partPosBean.m_PartId);
			partPosBean->set_xoffset((*it)->partPosBean.m_XOffset);
			partPosBean->set_yoffset((*it)->partPosBean.m_YOffset);
			partPosBean->set_rotateangle((*it)->partPosBean.m_RotateAngle);
			partPosBean->set_radians((*it)->partPosBean.m_Radians);
			partPosBean->set_srcpartcenterx((*it)->partPosBean.m_SrcPartCenterX);
			partPosBean->set_srcpartcentery((*it)->partPosBean.m_SrcPartCenterY);
			partPosBean->set_partcenterx((*it)->partPosBean.m_PartCenterX);
			partPosBean->set_partcentery((*it)->partPosBean.m_PartCenterY);

			for (auto ps = (*it)->paramSet.begin(); ps != (*it)->paramSet.end(); ++ps) {
				auto paramSet = part->add_paramset();
				paramSet->set_id((*ps)->id);
				paramSet->set_name((*ps)->name);
				paramSet->set_set_type((*ps)->set_type);
				paramSet->set_laser_speed((*ps)->laser_speed);
				paramSet->set_scan_field((*ps)->scan_field);
				auto ls = paramSet->mutable_laser_set();
				ls->set_id((*ps)->laser_set->id);
				ls->set_laser_diameter((*ps)->laser_set->laser_diameter);
				ls->set_laser_power((*ps)->laser_set->laser_power);
				ls->set_laser_real_power((*ps)->laser_set->laser_real_power);
			}

			part->set_print_enable((*it)->print_enable);
			part->set_param_pos((*it)->param_pos);
			part->set_iscopy((*it)->isCopy);
		}
	}
	else {
		result.set_isok(false);
	}
	(*response)->mutable_data()->PackFrom(result);
}

void JobController::LayersReq(::stream::ResponseAny** response) {
	stream::Layers result;
	if (m_CurrentJob && m_CurrentJob->GetMetaData()) {
		for (auto layer = m_CurrentJob->GetMetaData()->GetLayersVec().begin();
			layer != m_CurrentJob->GetMetaData()->GetLayersVec().end(); ++layer) {
			auto ly = result.add_layer();
			ly->set_index((*layer)->index);
			ly->set_isok(true);
			ly->set_powder((*layer)->powder);
			ly->set_layer_thickness((*layer)->layer_thickness);
			ly->set_scan_times((*layer)->scan_times);
		}
	}
	else {
		result.set_isok(false);
	}

	(*response)->mutable_data()->PackFrom(result);
}

void JobController::LayerInfoReq(JCONTROLLERFUNC type, ::stream::ResponseAny** response) {
	stream::LayerInfo result;
	MetaData::Layer* p = nullptr;
	if (type == CURRLAYERINFO && m_CurrentJob) {
		p = m_CurrentJob->GetMetaData()->GetCurrentLayer();
	}
	else if (type == PREVLAYERINFO && m_CurrentJob) {
		p = m_CurrentJob->GetMetaData()->GetPreviewLayer();
	}
	if (p) {
		result.set_isok(true);
		result.set_index(p->index);
		result.set_powder(p->powder);
		result.set_layer_thickness(p->layer_thickness);
		result.set_scan_times(p->scan_times);
	}
	else {
		result.set_isok(false);
	}
	(*response)->mutable_data()->PackFrom(result);
}

void JobController::MachineTypeReq(::stream::ResponseAny** response) {
	stream::MachineType result;
	
	for (auto it = m_CurrentJob->GetMetaData()->GetScanFields()->begin();
		it != m_CurrentJob->GetMetaData()->GetScanFields()->end(); ++it) {
		auto sf = result.add_sf();
		sf->set_id((*it)->id);
		sf->set_id((*it)->reference);
		auto dim = sf->mutable_dimension();
		dim->set_xmax((*it)->dimension->xmax);
		dim->set_xmin((*it)->dimension->xmax);
		dim->set_ymax((*it)->dimension->ymax);
		dim->set_ymin((*it)->dimension->ymin);
	}
	(*response)->mutable_data()->PackFrom(result);
}


void JobController::CallFuncs(const ReadData & rd, const list<Item>&lst, ::stream::ResponseAny **response) {
	stream::ComResponce result;
	JCONTROLLERFUNC jfunc = (JCONTROLLERFUNC)ConverType::TryToI(rd.nameKey);
	switch (jfunc)
	{
	case LOADJOB:
		LoadJob(lst, response);   break;
	case REMOVEALLJOB:
		RemoveAllJob();   break;
	case GENERALINFO:
		GeneralInfoReq(response);   break; 
	case MACHINETYPE:
		MachineTypeReq(response);  break;
	case PARTINFO:
		PartInfoReq(response);   break;
	case LAYERS:
		LayersReq(response);    break;
	case CURRLAYERINFO:
		LayerInfoReq(CURRLAYERINFO,response);  break;
	case PREVLAYERINFO:
		LayerInfoReq(PREVLAYERINFO,response);  break;
	case RECALCEVATIME:
		m_CurrentJob->GetMetaData()->ReCalcEvaTime();  break;
	case UPDATEPARAMETERSET:  
		m_CurrentJob->UpdateParameterSet(rd,lst);  break;
	case ERRORINFO:
		result.set_data(m_CurrentJob->GetMetaData()->GetErrorInfo());
		(*response)->mutable_data()->PackFrom(result);
		break;
	case JOBPARAM:
		JobParamReq(response);  break;
	case UPDATEPARAM:
		UpdateParam(rd, lst); break;
	case ONELAYERDATA:
		GetJob()->GetMetaData()->GetLayerByIndex((unsigned int)ConverType::TryToI(rd.strValue), response);  break;
	default:
		break;
	}
}

void JobController::SendToClients() {
	if (!IsLoadFinished()) {  //没有加载完成
		list<Item> lst;
		lst.emplace_back(Item{ "LoadProgress", to_string(GetLoadProgress()), iFLOAT });
		lst.emplace_back(Item{ "LoadInfo", GetLoadInfo(), iSTRING });
		lst.emplace_back(Item{ "IsLoadFinished", to_string(IsLoadFinished()), iBOOL });
		ClientWrapper::Instance()->PushAllClient(WriteData(JOBCONTROLLER, lst));
	}

}


void JobController::JobParamReq(::stream::ResponseAny** response) {
	stream::JobParam result;

	if (m_CurrentJob) {
		result.set_isok(true);
		result.set_layercount(m_CurrentJob->GetLayerCount());  
		result.set_componentcount(m_CurrentJob->GetComponentCount()); 
		result.set_jobuid(m_CurrentJob->GetJobUid()); 
		result.set_jobfilename(m_CurrentJob->GetJobFileName());   
		result.set_layerinherit(m_CurrentJob->IsLayerInherit());   
		result.set_startindex(m_CurrentJob->GetStartIndex());   
		result.set_setparamtype(m_CurrentJob->m_SetParamType);   
		result.set_loadfinished(IsLoadFinished());
	}
	else {
		result.set_isok(false);
	}

	(*response)->mutable_data()->PackFrom(result);
}


void JobController::UpdateParam(const ReadData& rd, const list<Item>& lst) {
	
	for (auto it = lst.begin(); it != lst.end(); ++it) {
		if (it->nameKey == "Layerinherit") m_CurrentJob->SetLayerInherit(ConverType::TryToI(it->strValue));
		if (it->nameKey == "StartIndex") m_CurrentJob->SetStartIndex(ConverType::TryToI(it->strValue));
		if (it->nameKey == "SetParamType") m_CurrentJob->m_SetParamType = ConverType::TryToI(it->strValue);
	}

}