myvtm/Module/mod_chromium/CModTools.cpp

#include "stdafx.h"
#include "uuid4.h"
#if (defined _WIN32 || defined _WIN64)
#include "processControl.h"
#define SPLIT_SLASH_STR "\\"
#else
#include <mutex>
#include <thread>
#include "path.h"
#include "fileutil.h"
#include <boost/process.hpp>
#include <boost/thread.hpp>
#include "CommEntityUtil.hpp"
#endif
#include "baseEx.h"
#include "CModTools.h"
#include "SpIni.h"
#include <vector>
#include <list>
#include <memory>
#include <iostream>
#include "../mod_upload/Upload_client_g.h"
#include "mod_chromium.h"
#include <boost/thread/mutex.hpp>
#include "EventCode.h"
#include "url_encoder.h"
#include "SpUtility.h"


void SystemRunTest(const std::string& systemCmd);


extern std::pair<bool, std::string> DetectActiveHttp(std::vector<std::string> urlArr);

auto GetCefHead = [](CEntityBase* curEntity)->CSimpleStringA {
	CSimpleStringA strChromiumPath, basePath;
    curEntity->GetFunction()->GetPath("Base", basePath);
    strChromiumPath.Append(basePath);
#if defined(_MSC_VER)
    strChromiumPath.Append(CSimpleStringA(SPLIT_SLASH_STR) + "bin" + SPLIT_SLASH_STR + "Chromium" + SPLIT_SLASH_STR);
    strChromiumPath.Append(CEFCLIENT_NAME);
#else
    strChromiumPath.Append(CSimpleStringA(SPLIT_SLASH_STR) + "res" + SPLIT_SLASH_STR + "RunScript" + SPLIT_SLASH_STR);
    strChromiumPath.Append("startMixBrower.sh");
#endif //_MSC_VER
	return strChromiumPath;
};


auto detectUrls = [](std::string urls) -> std::string {
	std::vector<std::string> urlArr;
	urlArr.emplace_back(urls);
	auto checkRet = DetectActiveHttp(urlArr);
	LogWarn(Severity_Low, Error_Debug, LOG_SLV_CHROMIUM_URLCHECK,
		CSimpleStringA::Format("check chromium url %d, %s", checkRet.first, checkRet.first ? checkRet.second.c_str() : urls.c_str()));
	if (checkRet.first)
		return checkRet.second.c_str();
	else
		return urlArr[0];
};
namespace Chromium {

	boost::mutex g_mutexFreerdp, m_guardInterruptLock;

	void CModTools::lockGuard()
	{
		m_guardInterruptLock.lock();
	}

	void CModTools::unlockGuard()
	{
		m_guardInterruptLock.unlock();
	}

	void CModTools::InitCModTools(CEntityBase* pEntity) {
		this->m_pEntity = pEntity;
		m_UseUOSBrowser = 0;
		m_isGuardMainBrowser = false;
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum Error = m_pEntity->GetFunction()->OpenConfig(Config_Root, spConfig);
		if (Error == Error_Succeed)
		{
			Error = spConfig->ReadConfigValue("Terminal", "MachineType", m_strMachineType);
			if (Error == Error_Succeed)
			{
				Error = spConfig->ReadConfigValue("Terminal", "Site", m_strSite);
				if (Error != Error_Succeed)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("ReadConfigValue, get Site value failed");
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("ReadConfigValue, get MachineType value failed");
			}
		}

		auto configRet = ReadCenterConfigStr();
		m_UserMgrUrlStr = std::get<0>(configRet);
		m_UserMgrUrlNoSidebarStr = std::get<1>(configRet);
		m_UserMgrUrlNoSidebarMutiStr = std::get<2>(configRet);
		m_UserMgrUrlFultureStr = std::get<3>(configRet);
		m_UserMgrAdStr = std::get<4>(configRet);
		notifyExist = breakdownExist = m_isAdOpen = false;
		m_magicStr = uuid4_generate(8);
		m_withMin = false;

#if defined(RVC_OS_LINUX)
        InitBrowserUseMode();
#endif //RVC_OS_LINUX
		SetSpecialPageParam("", "", "", 0);
	}


	bool CModTools::killAllChromium()
	{
#if (defined _WIN32 || defined _WIN64)

		const char* killCmd = "taskkill /F /IM cefclient.exe /T";

		SYSTEM_ON(killCmd);

		return true;
#else
		do
		{
			boost::process::child child_process("sudo killall -9 uosbrowser");
			child_process.wait();
		} while (false);
		do 
		{
            boost::process::child child_process("sudo killall -9 cefclient");
            child_process.wait();
		} while (false);

        do {
            boost::process::child child_process("sudo killall -9 browser");
            child_process.wait();
        } while (false);

		breakdownExist = m_isAdOpen = notifyExist = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("run killAllChromium success ex");
		return true;
#endif
	}

	void CModTools::killAllChromiumByThread(int seconds)
	{
#if (defined _WIN32 || defined _WIN64)
#else
		auto cur = std::async([]() {
			CModTools::get_mutable_instance().killAllChromium();
			});
		std::future_status a1 = cur.wait_for(std::chrono::seconds(seconds));
		if (a1 == std::future_status::deferred)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("killAllChromiumByThread run delay");
		else
		{
			if (a1 == std::future_status::ready)
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("killAllChromiumByThread run end");
			else
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("killAllChromiumByThread do not end, over than %d seconds", seconds);
		}
#endif

	}

	bool CModTools::killChromiumByName(std::string name)
	{
		return true;
	}

	std::pair<bool, std::string> CModTools::getAdUrl()
	{
		auto AdUrl = m_UserMgrAdStr;
		auto strUrl = detectUrls(AdUrl.GetData());
		return strUrl.length() > 0 ? std::make_pair(true, strUrl) : std::make_pair(false, strUrl);
	}

	std::pair<bool, std::string> CModTools::getErrUrl(ERR_PAGE_REASON errType)
	{
		CSimpleStringA errPagePath;
		m_pEntity->GetFunction()->GetPath("Base", errPagePath);
		errPagePath.Append(SPLIT_SLASH_STR).Append("res").Append(SPLIT_SLASH_STR);
		errPagePath.Append("ManagerDesktop").Append(SPLIT_SLASH_STR);
		if (errType._to_integral() == ERR_PAGE_REASON::breakdown)
			errPagePath.Append("entityCheck.html");
		else if (errType._to_integral() == ERR_PAGE_REASON::warnPrompt)
			errPagePath.Append("serverNoAccess.html");
		else if (errType._to_integral() == ERR_PAGE_REASON::CardStoreIsBusy)
			errPagePath.Append("cardStore.html");
		else if (errType._to_integral() == ERR_PAGE_REASON::main)
			errPagePath.Append("homePageErr.html");
		else
			errPagePath.Append("entityCheck.html");

		return std::make_pair(true, errPagePath.GetData());
	}

	std::pair<bool, std::string> CModTools::GenerateErrPage(ERR_PAGE_REASON errType, std::tuple < std::string, std::string> norParam, std::tuple<std::string, std::string, std::string, DWORD, DWORD> exParam)
	{
		auto generate_url_prefix = []() -> CSimpleStringA {
#if defined(RVC_OS_WIN)
			return CSimpleStringA("");
#else
			return CSimpleStringA("\\");
#endif
		};
		auto errUrlRet = getErrUrl(errType);
		CSimpleStringA errPagePathBase = errUrlRet.second.c_str();
		CSimpleStringA errPageParams(true);
		CSimpleStringA needGuardian = "Y";
		auto rc = this->m_pEntity->GetFunction()->GetSysVar("NeedGuardian", needGuardian);
		bool showRebootTime = true;
		if (rc == Error_Succeed && needGuardian.Compare("Y", false))
			showRebootTime = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("NeedGuardian:%s", needGuardian.GetData());

		switch (errType)
		{
		case ERR_PAGE_REASON::CardStoreIsBusy:
			break;
		case ERR_PAGE_REASON::breakdown:
		case ERR_PAGE_REASON::warnPrompt:
		{
			errPageParams.Append(CSimpleStringA("showlimit=1"));
			if (m_withMin) {
				errPageParams.Append(CSimpleStringA(generate_url_prefix())).Append(CSimpleStringA("&showmin=1"));
			}
		}
		break;
		default:
			return std::make_pair(false, std::string("unknown err_page_reason:").append(errType._to_string()));
		}

		CSimpleStringA errPageUrl(true);
		if (!errPageParams.IsNullOrEmpty()) {
			errPageUrl = CSimpleStringA("file:///") + errPagePathBase + "?" + errPageParams;
		} else {
			errPageUrl = CSimpleStringA("file:///") + errPagePathBase;
		}
#if defined(RVC_OS_WIN)
        std::string in = errPageUrl.GetData();
		errPageUrl = UrlEncoder::Encode(in).c_str();

		errPageUrl.Append(" ");
        CSimpleStringA cachePath;
        this->m_pEntity->GetFunction()->GetPath("Temp", cachePath);
        cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("cefCache_").Append(m_strCacheHead.length() > 0 ? m_strCacheHead.c_str() : "").Append(errType._to_string());
		errPageUrl.Append(" --cache-path=").Append(cachePath);
        if (g_useMagic)
			errPageUrl.Append(" --magic-str=").Append(m_magicStr.c_str());
		if (g_withMedia)
			errPageUrl.Append(" --enable-media-stream=1 --enable-speech-input=1");
		if (g_withConsole)
			errPageUrl.Append(" --with-console");
		errPageUrl.Append(" --no-sandbox").Append(" --hide-controls").Append(" --hide-tabs");
		errPageUrl.Append(" --top=-1");

        switch (errType) {
        case ERR_PAGE_REASON::TerminalManagerKickOut:
        case ERR_PAGE_REASON::TerminalManagerOff:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::TerminalManager)._to_string());
            break;
        case ERR_PAGE_REASON::CardStoreIsBusy:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::CardStoreIsBusy)._to_string());
            break;
        case ERR_PAGE_REASON::CameraConfig:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::CameraConfig)._to_string());
            break;
        case ERR_PAGE_REASON::disabled:
        case ERR_PAGE_REASON::jobuncomplete:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::TradeManager)._to_string());
            break;
        case ERR_PAGE_REASON::warnPrompt:
        case ERR_PAGE_REASON::breakdown:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::breakdown)._to_string());
            break;
        default:
			errPageUrl.Append(" --logextend=").Append((+PAGE_TYPE::errPage)._to_string());
            break;
        }
		CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity);
		CSimpleString dstCmd = strChromiumPath + " --url=" + errPageUrl;

#else
        CSimpleString dstCmd = generateBrowserCMDForEverything(errPageUrl.GetData(), 2).c_str();
#endif //RVC_OS_WIN

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("GenerateErrPage type=%s, dstPage=%s", errType._to_string(), dstCmd.GetData());

		return std::make_pair(true, (const char*)dstCmd.GetData());
	}

	std::string formatTime(SYSTEMTIME time)
	{
		char tBuf[1024] = "";
        //sprintf(tBuf, "%04u-%02u-%02u %02u:%02u:%02u:%03u", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds);
		sprintf(tBuf, "%04u-%02u-%02u %02u:%02u:%02u", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond);
		return tBuf;
	}

	std::string CModTools::GetSpShellNextRebootTime()
	{
		static std::string shellBootTime;

		if (0 == shellBootTime.length())
		{
			CAutoArray<CSimpleStringA> t_names;
			CAutoArray<int> t_Idx;
			CAutoArray<CEntityStartInfo> t_Infos;
			this->m_pEntity->GetFunction()->GetAllEntityStartInfo(t_names, t_Idx, t_Infos);

			for (int i = 0; i < t_Infos.GetCount(); i++) {
                //if (0 == t_Idx[i])//shell
				if (t_names[i].Compare("HealthManager") == 0) {
					SYSTEMTIME startTime = t_Infos[i].startTime;
					CSmallDateTime dateTime;
					dateTime.FromSystemTime(startTime);
					/** 十分钟后重启 [Gifur@2022324]*/
					CSmallDateTime dateNewTime((DWORD)dateTime + 10 * 60);
					shellBootTime = dateNewTime.ToTimeString().GetData();
#if defined(RVC_OS_LINUX)
					SP::Utility::replaceInPlace(shellBootTime, " ", "-");
#endif //RVC_OS_LINUX
					break;
				}
			}
		}
		return shellBootTime;

	}

	void CModTools::setLimitReason(const char* reason) {
		CSimpleStringA m_strLimitReason = reason;
		if (m_strLimitReason.Compare("breakdown") != 0 && !m_strLimitReason.IsNullOrEmpty())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("reason:%d, setState:%s", reason, "L");
			this->m_pEntity->GetFunction()->SetSysVar("TradeManageState", "L", true);
		}
		if (m_strLimitReason.Compare("breakdown") == 0) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("reason:%d, no setState", reason);
		}
		if (m_strLimitReason.IsNullOrEmpty())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("reason:%d, setState:%s", reason, "T");
			this->m_pEntity->GetFunction()->SetSysVar("TradeManageState", "T", true);
		}
	}

	/** 这个接口将移除，信创不再使用CEFClient [Gifur@2023626]*/
	void CModTools::StopChromiumBrowser(ERR_PAGE_REASON reason, bool stopAll)
	{
#if defined(_MSC_VER)
        CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
        strCmdLine.Append(strChromiumPath).Append(" --kill");
        if (!stopAll)
            strCmdLine.Append(" --logextend=").Append(reason._to_string());
        if (reason._to_integral() == ERR_PAGE_REASON::main)
            m_isGuardMainBrowser = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("StopChromiumBrowser cmdline:%s, current guardian main browser : %d", strCmdLine.GetData(), m_isGuardMainBrowser);

        SYSTEM_ON(strCmdLine.GetData());
        if (reason._to_integral() == ERR_PAGE_REASON::breakdown || reason._to_integral() == ERR_PAGE_REASON::warnPrompt)
            breakdownExist = false;
        if (reason._to_integral() == ERR_PAGE_REASON::ErrNotify)
            notifyExist = false;
        if (stopAll)
            breakdownExist = notifyExist = false;

#else
		if (stopAll)
			killAllChromium();
		else
			LogWarn(Severity_Low, Error_NotSupport, LOG_WARN_CHROMIUM_NOT_SUPPORT_TOKILL_SPECIFIED_BROWSER,
					CSimpleStringA::Format("StopChromiumBrowser: %s", reason._to_string()));
#endif //_MSC_VER
	}

	/** 这个接口将移除，信创不再使用CEFClient [Gifur@2023626]*/
	void CModTools::StopSingleChromiumBrowserByName(std::string cefName)
	{
#if defined(_MSC_VER)
        CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
        strCmdLine.Append(strChromiumPath).Append(" --kill");
        strCmdLine.Append(" --logextend=").Append(cefName.c_str());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("StopChromiumBrowser cmdline:%s, current guardian main browser : %d", strCmdLine.GetData(), m_isGuardMainBrowser);
        SYSTEM_ON(strCmdLine.GetData());
#else
        LogWarn(Severity_Low, Error_NotSupport, LOG_WARN_CHROMIUM_NOT_SUPPORT_TOKILL_SPECIFIED_BROWSER,
                CSimpleStringA::Format("StopSingleChromiumBrowserByName: %s", cefName.c_str()));
#endif //_MSC_VER
	}

	std::pair<bool, std::string> CModTools::getMainUrl()
	{
		CSimpleStringA strUrl;
		bool isOpenExtend = false;

		auto mainUrl = m_UserMgrUrlFultureStr;
		strUrl = detectUrls(mainUrl.GetData()).c_str();
		strUrl = mainUrl;
		isOpenExtend = false;

		return std::make_pair(isOpenExtend, strUrl.GetData());
	}

	std::pair<bool, std::string> CModTools::getExtendUrl()
	{
		CSimpleStringA strUrl;

		if (m_UserMgrUrlNoSidebarStr.Compare(""))
		{
			auto mainUrl = m_UserMgrUrlNoSidebarStr;
			auto exUrl = m_UserMgrUrlNoSidebarMutiStr;
			auto t_Arr = exUrl.Split('|');
			std::vector<std::string> urlArr;
			urlArr.emplace_back(mainUrl.GetData());
			for (int i = 0; i < t_Arr.GetCount(); i++)
				urlArr.emplace_back(t_Arr[i].GetData());

			auto checkRet = DetectActiveHttp(urlArr);
			if (checkRet.first)
				strUrl = checkRet.second.c_str();
			else
				strUrl = mainUrl;
		}
		else
			strUrl = m_UserMgrUrlStr;

		return std::make_pair(strUrl.GetLength() > 0, strUrl.GetData());
	}



	std::string CModTools::generateAdCmd(std::string AdUrl) {
		
#if defined(RVC_OS_LINUX)
		return generateBrowserCMDForEverything(AdUrl, 1);
#else
        CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
        strCmdLine.Append(strChromiumPath).Append(" --url=").Append(AdUrl.c_str());
        CSimpleStringA cachePath;
        this->m_pEntity->GetFunction()->GetPath("Temp", cachePath);
        cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("cefCache_").Append(m_strCacheHead.length() > 0 ? m_strCacheHead.c_str() : "").Append((+ERR_PAGE_REASON::Ad)._to_string());
        strCmdLine.Append(" --cache-path=").Append(cachePath);
        if (g_useMagic)
            strCmdLine.Append(" --magic-str=").Append(m_magicStr.c_str());
		if (g_withMedia)
			strCmdLine.Append(" --enable-media-stream=1 --enable-speech-input=1");
		if (g_withConsole)
			strCmdLine.Append(" --with-console");
        strCmdLine.Append(" --no-sandbox");
        strCmdLine.Append(" --hide-controls");
        strCmdLine.Append(" --hide-tabs");
        strCmdLine.Append(" --logextend=").Append((+PAGE_TYPE::Ad)._to_string());
        strCmdLine.Append(" --top=-1");
        strCmdLine.Append(" --run-extend");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cmdline : %s", strCmdLine.GetData());
        return strCmdLine.GetData();
#endif //RVC_OS_LINUX
	}

#if defined(RVC_OS_WIN)
    std::string CModTools::generateCefclientCmd(bool isExtend, std::string mainUrl)
    {
        CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
        strCmdLine.Append(strChromiumPath).Append(" --url=").Append(mainUrl.c_str());

        if (isExtend) {
            //not support
        }
        CSimpleStringA cachePath;
        this->m_pEntity->GetFunction()->GetPath("Temp", cachePath);
        cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("cefCache_").Append(m_strCacheHead.length() > 0 ? m_strCacheHead.c_str() : "")
            .Append(isExtend ? (+ERR_PAGE_REASON::extend)._to_string() : (+ERR_PAGE_REASON::main)._to_string());
        //strCmdLine.Append(" --hide-controls=true")
        strCmdLine.Append(" --cache-path=").Append(cachePath);
        strCmdLine.Append(" --no-sandbox");
        strCmdLine.Append(" --hide-controls");
        if (g_useMagic)
            strCmdLine.Append(" --magic-str=").Append(m_magicStr.c_str());
		if (g_withMedia)
			strCmdLine.Append(" --enable-media-stream=1 --enable-speech-input=1");
		if (g_withConsole)
			strCmdLine.Append(" --with-console");
        strCmdLine.Append(" --hide-tabs");
        if (m_withDebugMode)
            strCmdLine.Append(" --remote-debugging-port=9222");
        if (isExtend) {
            strCmdLine.Append(" --with-tab");
            strCmdLine.Append(" --logextend=").Append((+PAGE_TYPE::extend)._to_string());
        } else
            strCmdLine.Append(" --logextend=").Append((+PAGE_TYPE::slv)._to_string());
        strCmdLine.Append(" --errurl=file:\/\/\/").Append(getErrUrl(ERR_PAGE_REASON::main).second.c_str());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cmdline : %s", strCmdLine.GetData());
        return strCmdLine.GetData();
    }
#endif //RVC_OS_WIN

	std::string CModTools::generateMainCmd(std::string mainUrl)
	{
#if defined(_MSC_VER)
		return generateCefclientCmd(false, mainUrl);
#else
        return generateBrowserCMDForEverything(mainUrl, 0);
#endif //_MSC_VER
	}

	std::string CModTools::generateInstallCmd(std::string installUrl)
	{
#if defined(RVC_OS_LINUX)
		return generateBrowserCMDForEverything(installUrl, 0);
#else
		CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
		strCmdLine.Append(strChromiumPath).Append(" --url=").Append(installUrl.c_str());
		CSimpleStringA cachePath;
		this->m_pEntity->GetFunction()->GetPath("Temp", cachePath);
		cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("cefCache_").Append(m_strCacheHead.length() > 0 ? m_strCacheHead.c_str() : "").Append((+ERR_PAGE_REASON::Ad)._to_string());
		strCmdLine.Append(" --cache-path=").Append(cachePath);
		strCmdLine.Append(" --no-sandbox");
		strCmdLine.Append(" --hide-controls");
		strCmdLine.Append(" --lang=zh-CN");//install page need language chinese
		strCmdLine.Append(" --hide-tabs");
		strCmdLine.Append(" --top=-1");
		strCmdLine.Append(" --logextend=").Append((+PAGE_TYPE::Install)._to_string());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cmdline : %s", strCmdLine.GetData());
		return strCmdLine.GetData();
#endif //RVC_OS_LINUX
	}

	std::string CModTools::generateSpecialPageFromOtherEntityCmd(std::string mainUrl)
	{
#if defined(RVC_OS_WIN)
        CSimpleStringA cachePath;
        CSimpleStringA strChromiumPath = GetCefHead(this->m_pEntity), strCmdLine = "";
        strCmdLine.Append(strChromiumPath).Append(" --url=").Append(mainUrl.c_str());
        this->m_pEntity->GetFunction()->GetPath("Temp", cachePath);
        cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("cefCache_").Append(m_strCacheHead.length() > 0 ? m_strCacheHead.c_str() : "").Append(m_specialPage_temp_name.c_str());
        //strCmdLine.Append(" --hide-controls=true")
        strCmdLine.Append(" --cache-path=").Append(cachePath);
        strCmdLine.Append(" --no-sandbox");
        strCmdLine.Append(" --hide-controls");
        if (g_useMagic)
            strCmdLine.Append(" --magic-str=").Append(m_magicStr.c_str());
		if (g_withMedia)
			strCmdLine.Append(" --enable-media-stream=1 --enable-speech-input=1");
		if (g_withConsole)
			strCmdLine.Append(" --with-console");
        strCmdLine.Append(" --hide-tabs");
        strCmdLine.Append(" --logextend=").Append(m_specialPage_temp_name.c_str());
        if (m_specialPage_temp_size.length() > 0)
            strCmdLine.Append(" --center-size=").Append(m_specialPage_temp_size.c_str());
        if (m_specialPage_temp_point.length() > 0)
            strCmdLine.Append(" --src-pos=").Append(m_specialPage_temp_point.c_str());
        strCmdLine.Append(" --top=").Append(std::to_string((unsigned long long)m_specialPage_temp_top).c_str());
        strCmdLine.Append(" --errurl=file:\/\/\/").Append(getErrUrl(ERR_PAGE_REASON::main).second.c_str());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cmdline : %s", strCmdLine.GetData());
        return strCmdLine.GetData();
#else
        return generateBrowserCMDForEverything(mainUrl, 3);
#endif //RVC_OS_WIN
	}
#if defined(RVC_OS_LINUX)
    std::string CModTools::generateBrowserCMDForEverything(const std::string& url, int pageType)
    {
        CSimpleStringA strBasePath(true);
        this->m_pEntity->GetFunction()->GetPath("BaseDir", strBasePath);
        std::string strPath(strBasePath.GetData());
        const std::string execute_newbrowser_path = strPath + SPLIT_SLASH_STR + "res" + SPLIT_SLASH_STR + "RunScript" + SPLIT_SLASH_STR + "startBrower.sh";
        const std::string execute_oldbrowser_path = strPath + SPLIT_SLASH_STR + "res" + SPLIT_SLASH_STR + "RunScript" + SPLIT_SLASH_STR + "startUOSBrower.sh";

		//旧版浏览器（系统自带）
        if (m_UseUOSBrowser == 1) {

            CSimpleStringA strUOSBrowserPath(execute_oldbrowser_path.c_str());
            CSimpleStringA strParams(" --new-window --kiosk --no-first-run --disable-popup-blocking --disable-notifications --disable-desktop-notifications --allow-running-insecure-content --disable-infobars --disable-suggestions-service --disable-save-password-bubble --disable-component-update");
			if (pageType == 0 || pageType == 2 || pageType == 3) {

			} else if (pageType == 1) {
				strParams.Append(" --window-position=1280,1024");
			}

            CSimpleStringA tempPath;
            this->m_pEntity->GetFunction()->GetPath("Temp", tempPath);
            CSimpleStringA cachePath(tempPath);
			if (pageType == 0 || pageType == 2 || pageType == 3) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserMain_").Append((+ERR_PAGE_REASON::main)._to_string());
			} else if (pageType == 1) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserVice_").Append((+ERR_PAGE_REASON::Ad)._to_string());
            } else if (pageType == 2) {
				cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserMain_").Append((+ERR_PAGE_REASON::breakdown)._to_string());
            } else if (pageType == 3) {
				cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserMain_").Append((+ERR_PAGE_REASON::OutsideRequest)._to_string());
            }
            strParams.Append(" --disk-cache-dir=").Append(cachePath);
            strParams.Append(" --disk-cache-size=").Append("2147483647"); //2G
			if (g_withMedia)
			{
				strParams.Append(" 	--use-fake-ui-for-media-stream");
			}

            CSimpleStringA usrDataPath(tempPath);
            if (pageType == 0) {
                usrDataPath.Append(SPLIT_SLASH_STR).Append("UOSBrowserConfigMain_").Append((+ERR_PAGE_REASON::main)._to_string());
            } else if (pageType == 1) {
                usrDataPath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserConfigVice_").Append((+ERR_PAGE_REASON::Ad)._to_string());
			} else if (pageType == 2) {
                usrDataPath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserConfigMain_").Append((+ERR_PAGE_REASON::breakdown)._to_string());
            } else if (pageType == 3) {
                usrDataPath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("UOSBrowserConfigMain_").Append((+ERR_PAGE_REASON::OutsideRequest)._to_string());
            }
            strParams.Append(" --user-data-dir=").Append(usrDataPath);
            strParams.Append(" ");
            strParams.Append(url.c_str());
            strUOSBrowserPath.Append(strParams);

            if (pageType == 0) {
				LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_CHROMIUM_OPEN_MAIN_WITH_UOS, strUOSBrowserPath);
            } else if (pageType == 1) {
                LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_CHROMIUM_OPEN_AD_WITH_UOS, strUOSBrowserPath);
            }
            return strUOSBrowserPath.GetData();
        }

		//新版浏览器
        if (m_UseUOSBrowser == 2) {

            CSimpleStringA strUOSBrowserPath(execute_newbrowser_path.c_str());
            CSimpleStringA strParams(" --kiosk --incognito --allow-running-insecure-content --new-window");
            if (pageType == 0 || pageType == 2 || pageType == 3) {

            } else if (pageType == 1) {
                strParams.Append(" --window-position=1280,1024");
            }

            CSimpleStringA tempPath;
            this->m_pEntity->GetFunction()->GetPath("Temp", tempPath);
            CSimpleStringA cachePath(tempPath);
            if (pageType == 0) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserMain_").Append((+ERR_PAGE_REASON::main)._to_string());
            } else if (pageType == 1) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserVice_").Append((+ERR_PAGE_REASON::Ad)._to_string());
            } else if (pageType == 2) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserMain_").Append((+ERR_PAGE_REASON::breakdown)._to_string());
            } else if (pageType == 3) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserMain_").Append((+ERR_PAGE_REASON::OutsideRequest)._to_string());
            }
            strParams.Append(" --disk-cache-dir=").Append(cachePath);
            strParams.Append(" --disk-cache-size=").Append("2147483647"); //2G
			if (g_withMedia)
			{
				strParams.Append(" 	--use-fake-ui-for-media-stream");
			}

            CSimpleStringA usrDataPath(tempPath);
            if (pageType == 0) {
                usrDataPath.Append(SPLIT_SLASH_STR).Append("BrowserConfigMain_").Append((+ERR_PAGE_REASON::main)._to_string());
            } else if (pageType == 1) {
                usrDataPath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserConfigVice_").Append((+ERR_PAGE_REASON::Ad)._to_string());
            } else if (pageType == 2) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserConfigMain_").Append((+ERR_PAGE_REASON::breakdown)._to_string());
            } else if (pageType == 3) {
                cachePath.Append(CSimpleStringA(SPLIT_SLASH_STR)).Append("BrowserConfigMain_").Append((+ERR_PAGE_REASON::OutsideRequest)._to_string());
            }
            strParams.Append(" --user-data-dir=").Append(usrDataPath);
            strParams.Append(" ");
            strParams.Append(url.c_str());
            strUOSBrowserPath.Append(strParams);

            if (pageType == 0) {
				LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_CHROMIUM_OPEN_MAIN_WITH_UOSV2, strUOSBrowserPath);
            } else if (pageType == 1) {
				LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_CHROMIUM_OPEN_AD_WITH_UOSV2, strUOSBrowserPath);
            }
            return strUOSBrowserPath.GetData();
        }

		return std::string("");
    }
#endif //RVC_OS_LINUX

    std::pair<bool, std::string> CModTools::openAdPage()
    {
		if (m_isAdOpen)//only open ad in first time
			return std::make_pair(false, "open AdPage failed! Already exist.");

		auto AdUrlRet = getAdUrl();
		if (AdUrlRet.first)
		{
			auto strAdCmd = generateAdCmd(AdUrlRet.second);
			auto openAdRet = openCef(strAdCmd);
			if (Error_Succeed != openAdRet.first)
				return std::make_pair(false, "open Ad err!");
			else
			{
				m_isAdOpen = true;
				return std::make_pair(true, "");
			}

		}
		else
			return std::make_pair(false, "StartChromiumBrowser Ad url err!");
	}


	std::pair<ErrorCodeEnum, int> CModTools::StartChromiumBrowser(
		ERR_PAGE_REASON reason, std::tuple < std::string, std::string> normalParam
		, std::tuple<std::string, std::string, std::string, DWORD, DWORD> exParam) {

		g_mutexFreerdp.lock();
		std::shared_ptr<void> delHandleFun((void*)0, [&](void*) {
			g_mutexFreerdp.unlock();
			});

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("start browser %d", reason._to_integral());

		if (reason._to_integral() == ERR_PAGE_REASON::main)
		{
			auto mainUrlRet = getMainUrl();

			if (0 == mainUrlRet.second.length())
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("StartChromiumBrowser get %s url failed!", reason._to_string());
				LogWarn(Severity_High, Error_Unexpect, LOG_EVT_CHROMIUM_DETECT_MAIN_URL_EMPTY,
						CSimpleStringA::Format("StartChromiumBrowser get %s url failed!", reason._to_string()));
				return std::make_pair(Error_Unexpect, 0);
			}

			auto strCmdLine = generateMainCmd(mainUrlRet.second);

			auto openCefRet = openCef(strCmdLine, (m_UseUOSBrowser == 0));//with guard
			if (Error_Succeed == openCefRet.first) {
                LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_OPEN_MAIN_URL,
                        CSimpleStringA::Format("StartChromiumBrowser %s", mainUrlRet.second.c_str()));

#ifndef DEVOPS_ON_PRD
                LogEvent(Severity_High, LOG_EVT_CHROMIUM_OPEN_MAIN_URL, CSimpleStringA::Format("当前打开的业务链接:%s", mainUrlRet.second.c_str()));
#endif
                return std::make_pair(Error_Succeed, openCefRet.second);
			}
		}
		else if (reason._to_integral() == ERR_PAGE_REASON::extend)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("do not support freerdp");
		}
		else if (reason._to_integral() == ERR_PAGE_REASON::Ad)
		{
			auto AdRet = openAdPage();
			if (!AdRet.first) DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s", AdRet.second.c_str());
			return std::make_pair(AdRet.first ? Error_Succeed : Error_Unexpect, 0);
		}
		 else if (reason._to_integral() == ERR_PAGE_REASON::OutsideRequest) {

#if defined(RVC_OS_WIN)
			auto strCmdLine = generateCefclientCmd(false, std::get<0>(normalParam));
#else
			auto strCmdLine = generateBrowserCMDForEverything(std::get<0>(normalParam), 3);
#endif //RVC_OS_WIN
	        auto openCefRet = openCef(strCmdLine, false);
	        if (Error_Succeed == openCefRet.first)
	            return std::make_pair(Error_Succeed, openCefRet.second);
		 	else 
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open cef for %s failed: %d", reason._to_string(), openCefRet.first);
	    }
		 else if (reason._to_integral() == ERR_PAGE_REASON::SpecialPageFromOtherEntity)
		{
			auto strCmdLine = generateSpecialPageFromOtherEntityCmd(std::get<0>(normalParam));
			auto openCefRet = openCef(strCmdLine, false);
			if (Error_Succeed == openCefRet.first)
				return std::make_pair(Error_Succeed, openCefRet.second);
			else
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open cef for %s failed: %d", reason._to_string(), openCefRet.first);
		}
		 else if (reason._to_integral() == ERR_PAGE_REASON::Install)
		{
			std::vector<std::string> installUrls;
#ifdef DEVOPS_ON_ST /*DevOps流水线编译，ST环境*/
			installUrls.push_back("https://deviceinstallweb.paasst.cmbchina.cn/installRequire");
			installUrls.push_back("https://deviceinstallwebdmz.paasst.cmbchina.cn/installRequire");
#elif defined(DEVOPS_ON_UAT)/*DevOps流水线编译，UAT环境*/
			installUrls.push_back("https://deviceinstallweb.paasuat.cmbchina.cn/installRequire");
			installUrls.push_back("https://deviceinstallwebdmz.paasuat.cmbchina.cn/installRequire");
#elif defined(DEVOPS_ON_PRD)/*DevOps流水线编译，PRD环境*/
			installUrls.push_back("https://deviceinstallweb.paas.cmbchina.cn/installRequire");
			installUrls.push_back("https://deviceinstallweb.paas.cmbchina.com/installRequire");
#else/*本地编译等非DevOps环境编译的版本*/
			installUrls.push_back("https://deviceinstallweb.paasst.cmbchina.cn/installRequire");
#endif
			auto checkRet = DetectActiveHttp(installUrls);
			if (!checkRet.first)
			{
				LogWarn(Severity_High, Error_NetBroken, LOG_WARN_CHROMIUM_INSTALL_URLS_CHECK,
					CSimpleString::Format("install page check err, can not connect to %s or %s", installUrls[0].c_str(), installUrls[1].c_str()).GetData());
			}
			std::string dstInstallUrl = checkRet.first ? checkRet.second : installUrls[0];
			CSimpleString runningVer = "";
			m_pEntity->GetFunction()->GetRunningVersion(runningVer);
			dstInstallUrl.append("?terminalVersion=").append(runningVer.GetData());
#if defined(RVC_OS_LINUX)
			auto replaceAll = [](std::string& str, const std::string& search, const std::string& replace) {
				size_t pos = 0;
				while ((pos = str.find(search, pos)) != std::string::npos) {
					str.replace(pos, search.length(), replace);
					pos += replace.length();
				}
			};
			replaceAll(dstInstallUrl, "&", "\\&");
#endif // RVC_OS_WIN

			auto strCmdLine = generateInstallCmd(dstInstallUrl);
			auto openCefRet = openCef(strCmdLine, false);
			if (Error_Succeed == openCefRet.first)
				return std::make_pair(Error_Succeed, openCefRet.second);
			else
				Dbg("open cef for %s failed: %d", reason._to_string(), openCefRet.first);
		}
		else
		{
			//open err page
			
			if (notifyExist)
				return std::make_pair(Error_Duplication, 0);

			if ((ERR_PAGE_REASON::breakdown == reason._to_integral() || reason._to_integral() == ERR_PAGE_REASON::warnPrompt) && breakdownExist)
				return std::make_pair(Error_Duplication, 0);//只打开一个breakdown页面，后续通过cefclient改动，避免打开同种页面

			auto errPageUrl = GenerateErrPage(reason, normalParam, exParam);
			if (!errPageUrl.first)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("errPage get url failed!");
				return std::make_pair(Error_Unexpect, 0);
			}
			auto errPageRet = openCef(errPageUrl.second);
			if (Error_Succeed == errPageRet.first)
			{
				if (ERR_PAGE_REASON::ErrNotify == reason._to_integral())
					notifyExist = true;
				else if (ERR_PAGE_REASON::breakdown == reason._to_integral() || reason._to_integral() == ERR_PAGE_REASON::warnPrompt)
					breakdownExist = true;
			}


			return std::make_pair(errPageRet.first, 0);

		}

		return std::make_pair(Error_Unexpect, 0);
	}

	void CModTools::cefClientGuardian(std::string cmdline)
	{
		m_isGuardMainBrowser = true;
		while (m_isGuardMainBrowser)
		{
			try
			{
#if (defined _WIN32 || defined _WIN64)
				auto startRet = startProcessInJob(cmdline, "");
				if (!std::get<0>(startRet))
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cefClientGuardian startProcessInJob failed!");
				else
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("cefClientGuardian open cefclient pid:%d, cmd:%s", std::get<1>(startRet), cmdline.c_str());
				WaitForSingleObject(std::get<3>(startRet), INFINITE);
				boost::mutex::scoped_lock(m_guardInterruptLock);//必须保证unlock被执行，不然就会有问题
#else
				boost::process::child child_process(cmdline);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open cefclient pid:%d, cmd:%s", child_process.id(), cmdline.c_str());
				child_process.wait();
#endif
			}
			catch (const std::exception& e)
			{
				std::cout << e.what() << std::endl;
				return;
			}
			catch (...)
			{
				return;
			}
			boost::this_thread::sleep_for(boost::chrono::seconds(1));
		}
		return;
	}

	// 输入为北京时间 输出为北京时间戳
	int CModTools::StandardToStamp(const char* str_time, bool dateOnly)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("StandardToStamp str = %s", str_time);
		struct tm stm;
		int iY, iM, iD, iH, iMin, iS;

		// 检查有效性
		if ('-' != str_time[4] || '-' != str_time[7])
		{
			return 0;
		}

		memset(&stm, 0, sizeof(stm));
		iY = atoi(str_time);
		iM = atoi(str_time + 5);
		iD = atoi(str_time + 8);
		if (dateOnly)
		{
			iH = 0;
			iMin = 0;
			iS = 0;
		}
		else {
			iH = atoi(str_time + 11);
			iMin = atoi(str_time + 14);
			iS = atoi(str_time + 17);
		}

		stm.tm_year = iY - 1900;
		stm.tm_mon = iM - 1;
		stm.tm_mday = iD;
		stm.tm_hour = iH;
		stm.tm_min = iMin;
		stm.tm_sec = iS;

		/*printf("%d-%0d-%0d %0d:%0d:%0d\n", iY, iM, iD, iH, iMin, iS);*/   //标准时间格式例如：2016:08:02 12:12:30
		return (int)mktime(&stm);
	}

	bool CModTools::isOutsidePad() {

		if ((m_strSite.IsEndWith("FLB", true) || m_strSite.IsEndWith("SMM", true)) &&
			m_strMachineType.IsEndWith("PAD", true))
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("isOutsidePad Yes");
			return true;
		}
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("isOutsidePad No");
		return false;
	}


	bool CModTools::findRestartCode(DWORD userCode) {
		DWORD authArr_noretry_norestart[] = ERRARR_ACCESSAUTH_NORETRY_NORESTART;
		DWORD authArr_retry_norestart[] = ERRARR_ACCESSAUTH_RETRY_NORESTART;
		std::vector<DWORD> norestartArr;
#if (defined _WIN32 || defined _WIN64)
		for each (auto i in authArr_noretry_norestart)
#else	
		for (auto i : authArr_noretry_norestart)
#endif
			norestartArr.emplace_back(i);
#if (defined _WIN32 || defined _WIN64)
		for each (auto i in authArr_retry_norestart)
#else	
		for (auto i : authArr_retry_norestart)
#endif
			norestartArr.emplace_back(i);

#if (defined _WIN32 || defined _WIN64)
		for each (auto i in norestartArr)
#else	
		for (auto i : norestartArr)
#endif
		{
			if (userCode == i) {
				return false;
			}
		}
		return true;
	}

	DWORD CModTools::spiltErrMsg(std::string errMsg)
	{
		DWORD usercode = 0;
		CSimpleString m_sAuthErrMsg = errMsg.c_str();
		auto authArr = m_sAuthErrMsg.Split('|');
		if (authArr.GetCount() > 1)
		{
			auto ErrcodeStr = authArr[0];
			if (ErrcodeStr[0] == '0' && ErrcodeStr[1] == 'x')
				usercode = std::stoi(ErrcodeStr.GetData(), 0, 0);
		}
		return usercode;
	}

	bool CModTools::CheckTradeRecord() {
		std::list<int> timeList;

		using namespace Upload;
		UploadService_ClientBase* pClient = new UploadService_ClientBase(m_pEntity);
		auto rc = pClient->Connect();
		if (rc != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("connect to Upload entity fail: %d", rc);
			pClient->SafeDelete();
			pClient = NULL;
		}
		else
		{
			UploadService_UploadDateList_Req req = {};
			UploadService_UploadDateList_Ans ans = {};

			rc = (*pClient)(EntityResource::getLink().upgradeLink())->UploadDateList(req, ans, 10000);

			if (rc != Error_Succeed)
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("get CreateProcessRunAs fail from FreeRDPWrap: %d", rc);
			else
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("UploadDateList succeed from Upload");
				for (int i = 0; i < ans.uploadDateStr.GetCount(); ++i)
				{
					CSimpleStringA str = (CSimpleStringA)ans.uploadDateStr[i];
					int t = StandardToStamp(ans.uploadDateStr[i], true);
					timeList.emplace_back(t);
				}
			}
			pClient->GetFunction()->CloseSession();
			pClient = NULL;

		}

		// 比较时间戳 登记时间 <= 列表时间 < 今天 返回true
		time_t now = time(0);
		localtime(&now);
		now -= now % (3600 * 24);
		now -= 3600 * 8; //处理东八区问题
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum BootTimeCfgError = m_pEntity->GetFunction()->OpenConfig(Config_Run, spConfig);
		CSimpleStringA strLastRecordTime = "";
		ErrorCodeEnum errorRead = Error_Succeed;
		errorRead = spConfig->ReadConfigValue("Record", "LastRecordTime", strLastRecordTime);
		if (errorRead != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Read Record LastRecordTime -> Failed! Maybe LastRecordTime not exist!");
			strLastRecordTime = "";
		}

		int timestamp_lastRecordTime = now;
		if (!strLastRecordTime.IsNullOrEmpty())
		{
			timestamp_lastRecordTime = StandardToStamp(strLastRecordTime, false);
		}
		for (std::list<int>::iterator it = timeList.begin(); it != timeList.end(); ++it)
		{
			if (timestamp_lastRecordTime <= *it && *it < now)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("CheckTradeRecord lastRecordTime=%d, time_list=%d, now=%d", timestamp_lastRecordTime, *it, now);
				return true;
			}
		}
		return false;
	}

    void CModTools::InitBrowserUseMode()
    {
#if (defined _WIN32 || defined _WIN64)
#else
		if (m_pEntity != nullptr) {
			CSmartPointer<IConfigInfo> spConfig;
			m_pEntity->GetFunction()->OpenConfig(Config_Cache, spConfig);
			CSimpleStringA value(true);
			spConfig->ReadConfigValue("BusinessBrowserType", "FultureEx", value);
			if (!(value.IsNullOrEmpty() || (value.Compare("1") != 0))) {
				m_UseUOSBrowser = 0;
			} else {
                m_UseUOSBrowser = ToGetUOSBrowserType();
			}
		} else {
			m_UseUOSBrowser = ToGetUOSBrowserType();
		}
#endif
    }

    int CModTools::ToGetUOSBrowserType()
    {
#if (defined _WIN32 || defined _WIN64)
		return 0;
#else
		const std::string execute_newbrowser_path_check = "/usr/share/browser/browser";
        const std::string execute_oldbrowser_path_check = "/usr/share/uosbrowser/uosbrowser";

        CSimpleStringA strBasePath(true);
        this->m_pEntity->GetFunction()->GetPath("BaseDir", strBasePath);
        std::string strPath(strBasePath.GetData());
        const std::string execute_newbrowser_path = strPath + SPLIT_SLASH_STR + "res" + SPLIT_SLASH_STR + "RunScript" + SPLIT_SLASH_STR + "startBrower.sh";
        const std::string execute_oldbrowser_path = strPath + SPLIT_SLASH_STR + "res" + SPLIT_SLASH_STR + "RunScript" + SPLIT_SLASH_STR + "startUOSBrower.sh";

		int result(0);
		std::string additional("");

        std::string succStr, errStr;
        std::string runStr("dpkg -l | grep org.deepin.browser | awk '{print $3}'");
        if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
			if (succStr.empty()) {
				if (ExistsFileA(execute_oldbrowser_path_check.c_str())) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s exists!", execute_oldbrowser_path_check.c_str());
					result = 1;
				} else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s not exists!", execute_oldbrowser_path_check.c_str());
				}
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_BROWSER_LACK_OF_NEWONE, "have not installered new version UOS  browser");
			} else {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("new browser version: %s", succStr.c_str());
				additional = succStr;
				if (!ExistsFileA(execute_newbrowser_path.c_str())) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s not exists!", execute_newbrowser_path.c_str());
				}
				result = 2;
			}
		} else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("execute '%s' failed!", runStr.c_str());
		}

		UploadBrowserInfo(result, additional.c_str());

		return result;
#endif
    }

    void CModTools::UploadBrowserInfo(int usingType, LPCTSTR info)
    {
        CSmartPointer<IConfigInfo> spConfig;
        this->m_pEntity->GetFunction()->OpenConfig(Config_Run, spConfig);
		int oldType(0);
		CSimpleStringA strVersion;
		spConfig->ReadConfigValueInt("BrowserUse", "Type", oldType);
		spConfig->ReadConfigValue("BrowserUse", "Version", strVersion);
		if (oldType != usingType || strVersion.Compare(info) != 0) {
            LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_CHROMIUM_BROWSER_USING_TYPE_CHANGE,
					CSimpleStringA::Format("{ \"type\":%d, \"version\":\"%s\"}", usingType, info));

            spConfig->WriteConfigValueInt("BrowserUse", "Type", usingType);
            spConfig->WriteConfigValue("BrowserUse", "Version", info);
		}
    }




	std::pair<ErrorCodeEnum, int> CModTools::openCef(std::string cmdline, bool isGuard, bool usingSystemCmd)
	{
		if (isGuard) {
			//mod_chromium相当于cefclient的守护进程
			boost::thread cefGuardian(boost::bind(&CModTools::cefClientGuardian, this, cmdline));
			cefGuardian.detach();
		}
		else
		{
#if (defined _WIN32 || defined _WIN64)
			auto startRet = startProcessInJob(cmdline, "");
			if (!std::get<0>(startRet))
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("startProcessInJob failed!");
			return std::make_pair(std::get<0>(startRet) ? Error_Succeed : Error_Unexpect, std::get<1>(startRet));
#else
			auto systemStartChromium = [](std::string str, bool systemCmd) {
				if (systemCmd) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("system(%s)", str.c_str());
					system(str.c_str());
				} else {
                    SystemRunTest(str);
				}
			};
			boost::thread(systemStartChromium, cmdline, usingSystemCmd).detach();
#endif
		}
		return std::make_pair(Error_Succeed, 0);
	}

	bool CModTools::RestartProxyServer() {
		// start tcp bridge service
		ErrorCodeEnum Error;
		CSmartPointer<IEntityFunction> spEntityFunction = this->m_pEntity->GetFunction();
		Error = spEntityFunction->StopTcpBridgeServer();

		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("stop tcp bridge server failed! error = %d", Error);
			return false;
		}
			

		Error = spEntityFunction->StartTcpBridgeServer(4504);

		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("start tcp bridge server failed! error = %d", Error);
			return false;
		}
			
		return true;
	}

	std::tuple<CSimpleStringA, CSimpleStringA, CSimpleStringA, CSimpleStringA, CSimpleStringA> CModTools::ReadCenterConfigStr(CSimpleStringA entityName) {
		CSimpleStringA str = "", strNew = "", strEx = "", strFulture = "", strAd = "", strCacheHead;
		bool forceCleanCache = false;
		CSmartPointer<IConfigInfo> spCerConfig;
		ErrorCodeEnum err = this->m_pEntity->GetFunction()->OpenConfig(Config_CenterSetting, spCerConfig);
		if (entityName == "")
			entityName = this->m_pEntity->GetEntityName();

		SpIniMappingTable table;
		// clean cache every time
		table.AddEntryString(entityName, "UserMgrUrl", str, "");
		table.AddEntryString(entityName, "UserMgrUrlNoSidebar", strNew, "");
		table.AddEntryString(entityName, "UserMgrUrlNoSidebarMuti", strEx, "");
		table.AddEntryString(entityName, "UserMgrUrlFulture", strFulture, "");
		table.AddEntryString(entityName, "UserMgrAd", strAd, "");
		table.AddEntryString(entityName, "CacheHead", strCacheHead, "");
		if (Error_Succeed == table.Load(spCerConfig))
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)(CSimpleString::Format("read centersetting config : UserMgrUrl-%s, UserMgrUrlNoSidebar-%s, UserMgrUrlNoSidebarMuti-%s, UserMgrUrlFulture-%s, UserMgrAd-%s",
				str.GetData(), strNew.GetData(), strEx.GetData(), strFulture.GetData(), strAd.GetData()));

		CChromiumEntity* pChromiumEntity = reinterpret_cast<CChromiumEntity*>(m_pEntity);
		if (pChromiumEntity != nullptr && pChromiumEntity->HasCustomMainUrl()) {
			strFulture = pChromiumEntity->GetCustomMainUrl();
			CSimpleStringA strTmp = CSimpleStringA::Format("更新业务中台链接为：[%s]", strFulture.GetData());
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_USE_CUSTOM_FULTURE_URL, strTmp);
		}

		m_strCacheHead = strCacheHead.GetData();

		return std::make_tuple(str, strNew, strEx, strFulture, strAd);
	}

}