void WebCoreClass::newUpload(DesuraId id, const char* hash, uint64 fileSize, char **key)
{
	gcString size("{0}", fileSize);

	XML::gcXMLDocument doc;
	PostMap post;

	post["siteareaid"] = id.getItem();
	post["sitearea"] = id.getTypeString();
	post["action"] = "newupload";
	post["filehash"] = hash;
	post["filesize"] = size;

	auto uNode = postToServer(getMcfUploadUrl(), "itemupload", post, doc);
	auto iNode = uNode.FirstChildElement("mcf");
	
	if (!iNode.IsValid())
		throw gcException(ERR_BADXML);	

	if (key)
	{
		const std::string text = iNode.GetAtt("key");

		if (text.empty())
			throw gcException(ERR_BADXML);	

		Safe::strcpy(key, text.c_str(), text.size());
	}
}
void WebCoreClass::resumeUpload(DesuraId id, const char* key, WebCore::Misc::ResumeUploadInfo &info)
{
	XML::gcXMLDocument doc;
	PostMap post;

	post["siteareaid"] = id.getItem();
	post["sitearea"] = id.getTypeString();
	post["action"] = "resumeupload";
	post["key"] = key;

	auto uNode = postToServer(getMcfUploadUrl(), "itemupload", post, doc);
	auto iNode = uNode.FirstChildElement("mcf");

	if (!iNode.IsValid())
		throw gcException(ERR_BADXML);	

	gcString complete;
	iNode.GetChild("complete", complete);

	if (complete == "1")
		throw gcException(ERR_COMPLETED);

	iNode.GetChild("date", info.szDate);
	iNode.GetChild("filehash", info.szHash);
	iNode.GetChild("filesize", info.size);
	iNode.GetChild("filesizeup", info.upsize);
}
void ToolManager::cancelDownload(Misc::ToolTransInfo* info, bool force)
{
	if (!info)
		return;

	m_DownloadLock.lock();

	std::vector<DesuraId> idList;
	info->getIds(idList);

	for (size_t x=0; x<idList.size(); x++)
	{
		DesuraId id = idList[x];
		ToolInfo* info = findItem(id.toInt64());

		//This should not happen as there is a check before a download starts to make sure all tool ids are valid
		if (!info)
			continue;	

		std::map<uint64, UserCore::Task::DownloadToolTask*>::iterator it = m_mDownloads.find(id.toInt64());

		if (it != m_mDownloads.end())
			it->second->decreaseRefCount(force);
	}

	m_DownloadLock.unlock();	
}
Exemple #4
0
gcString MCFManager::getMcfPath(DesuraId id, MCFBranch branch, MCFBuild build, bool isUnAuthed)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());
	std::string res;

	try
	{
		int flags = isUnAuthed?FLAG_UNAUTHED:FLAG_NONE;

		sqlite3x::sqlite3_connection db(szItemDb.c_str());

		if (flags == FLAG_NONE)
		{
			sqlite3x::sqlite3_command cmd(db, "SELECT path FROM mcfitem WHERE internalid=? AND mcfbuild=? AND branch=?;");
			cmd.bind(1, (long long int)id.toInt64());
			cmd.bind(2, (int)build);
			cmd.bind(3, (int)branch);
			res = cmd.executestring();
		}
		else
		{
			sqlite3x::sqlite3_command cmd(db, "SELECT path FROM mcfitem WHERE internalid=? AND mcfbuild=? AND branch=? AND flags & ?;");
			cmd.bind(1, (long long int)id.toInt64());
			cmd.bind(2, (int)build);
			cmd.bind(3, (int)branch);
			cmd.bind(4, (int)flags);
			res = UTIL::OS::getAbsPath(cmd.executestring());
		}
	}
	catch (std::exception &)
	{
	}

	return res;
}
Exemple #5
0
gcString MCFManager::getMcfBackup(DesuraId gid, DesuraId mid)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());
	std::string res;

	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());
		sqlite3x::sqlite3_command cmd(db, "SELECT path FROM mcfbackup WHERE gid=? AND mid=?;");
		cmd.bind(1, (long long int)gid.toInt64());
		cmd.bind(2, (long long int)mid.toInt64());
		res = UTIL::OS::getRelativePath(cmd.executestring());

		if (!UTIL::FS::isValidFile(UTIL::FS::PathWithFile(res)))
		{
			properDelMcfBackup(gid, mid);
			res = "";
		}
	}
	catch (std::exception &)
	{
	}

	return res;
}
void WebCoreClass::resumeUpload(DesuraId id, const char* key, WebCore::Misc::ResumeUploadInfo &info)
{
	TiXmlDocument doc;
	PostMap post;

	post["siteareaid"] = id.getItem();
	post["sitearea"] = id.getTypeString();
	post["action"] = "resumeupload";
	post["key"] = key;

	TiXmlNode *uNode = postToServer(getMcfUploadUrl(), "itemupload", post, doc);
	TiXmlNode* mNode = uNode->FirstChild("mcf");

	if (!mNode)
		throw gcException(ERR_BADXML);	

	gcString complete;
	XML::GetChild("complete", complete, mNode);

	if (complete == "1")
		throw gcException(ERR_COMPLETED);

	XML::GetChild("date", info.szDate, mNode);
	XML::GetChild("filehash", info.szHash, mNode);
	XML::GetChild("filesize", info.size, mNode);
	XML::GetChild("filesizeup", info.upsize, mNode);
}
void WebCoreClass::newUpload(DesuraId id, const char* hash, uint64 fileSize, char **key)
{
	gcString size("{0}", fileSize);

	TiXmlDocument doc;
	PostMap post;

	post["siteareaid"] = id.getItem();
	post["sitearea"] = id.getTypeString();
	post["action"] = "newupload";
	post["filehash"] = hash;
	post["filesize"] = size;

	TiXmlNode *uNode = postToServer(getMcfUploadUrl(), "itemupload", post, doc);
	TiXmlNode* iNode = uNode->FirstChild("mcf");
	
	if (!iNode)
		throw gcException(ERR_BADXML);	

	TiXmlElement* cEl = iNode->ToElement();
		
	if (cEl)
	{
		const char* text = cEl->Attribute("key");

		if (!text)
			throw gcException(ERR_BADXML);	

		Safe::strcpy(key, text, 255);
	}
}
Exemple #8
0
void MCFManager::delAllMcfPath(DesuraId id)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());
	sqlite3x::sqlite3_connection db(szItemDb.c_str());

	try
	{
		sqlite3x::sqlite3_command cmd(db, "SELECT path FROM mcfitem WHERE internalid=?;");
		cmd.bind(1, (long long int)id.toInt64());
		sqlite3x::sqlite3_reader reader = cmd.executereader();

		while (reader.read())
		{
			std::string path = reader.getstring(0);
			UTIL::FS::delFile(UTIL::FS::PathWithFile(path));
		}
	}
	catch (std::exception &)
	{
	}

	try
	{
		sqlite3x::sqlite3_command cmd(db, "DELETE FROM mcfitem WHERE internalid=?;");
		cmd.bind(1, (long long int)id.toInt64());
		cmd.executenonquery();
	}
	catch (std::exception &e)
	{
		Warning("Failed to delete mcf items: {0}\n", e.what());
	}
}
Exemple #9
0
void MCF::setHeader(DesuraId id, MCFBranch branch, MCFBuild build)
{
	assert(m_sHeader);
	m_sHeader->setBranch(branch);
	m_sHeader->setType(id.getType());
	m_sHeader->setBuild(build);
	m_sHeader->setId(id.getItem());
}
bool UpdateThreadOld::pollUpdates()
{
	if (!m_pWebCore || !m_pUser)
		return false;

	updateBuildVer();

	std::map<std::string, std::string> post;

#ifdef DESURA_NONGPL_BUILD
	post["appid"] = gcString("{0}", m_iAppId);
	post["build"] = gcString("{0}", m_iAppVersion);
#endif

	for (uint32 x=0; x< m_pUser->getItemManager()->getCount(); x++)
	{
		UserCore::Item::ItemInfoI* item = m_pUser->getItemManager()->getItemInfo(x);

		if (!item)
			continue;

		if (!(item->getStatus() & UserCore::Item::ItemInfoI::STATUS_ONCOMPUTER) || (item->getStatus()&UserCore::Item::ItemInfoI::STATUS_ONACCOUNT))
			continue;

		DesuraId id = item->getId();

		if (id.getType() == DesuraId::TYPE_LINK)
			continue;

		gcString key("updates[{0}][{1}]", id.getTypeString().c_str(), id.getItem());
		post[key] = "1";
	}

	TiXmlDocument doc;

	try
	{
		m_pWebCore->getUpdatePoll(doc, post);
	}
	catch (gcException &e)
	{
		Warning(gcString("Update poll failed: {0}\n", e));
		return false;
	}

	parseXML(doc);

#ifdef WIN32
	checkFreeSpace();
#endif

	m_hHttpHandle->cleanPostInfo();
	m_hHttpHandle->cleanUp();
	m_hHttpHandle->clearCookies();

	return true;
}
Exemple #11
0
void MCF::setHeader(DesuraId id, MCFBranch branch, MCFBuild build)
{
	if (!m_sHeader)
		m_sHeader = new MCFCore::MCFHeader();

	m_sHeader->setBranch(branch);
	m_sHeader->setType(id.getType());
	m_sHeader->setBuild(build);
	m_sHeader->setId(id.getItem());
}
void WebCoreClass::updateAccountItem(DesuraId id, bool add)
{
	TiXmlDocument doc;
	PostMap post;

	post["siteareaid"] = id.getItem();
	post["sitearea"] = id.getTypeString();
	post["action"] = add?"add":"delete";

	postToServer(getUpdateAccountUrl(), "iteminstall", post, doc);
}
Exemple #13
0
ToolStartRes ToolTransInfo::startNextInstall(std::shared_ptr<IPCToolMain> pToolMain, DesuraId &toolId)
{
	gcTrace("ToolId {0}", toolId);

	if (m_uiCompleteCount == m_pTransaction->size())
		return ToolStartRes::NoToolsLeft;

	toolId = m_pTransaction->get(m_uiCompleteCount);
	ToolInfo* info = m_pToolManager->findItem(toolId.toInt64());

	if (!info)
	{
		Warning("Failed to find tool for tool install with id {0}", toolId.toInt64());
		m_uiCompleteCount++;
		return startNextInstall(pToolMain, toolId);
	}
		
	if (info->isInstalled())
	{
		onINComplete();
		return startNextInstall(pToolMain, toolId);
	}

	DesuraId id = info->getId();
	m_pTransaction->onStartInstallEvent(id);

	gcException e = pToolMain->installTool(info);

#ifdef NIX
	if (e.getErrId() == ERR_COMPLETED)
	{
		onINComplete();
		return startNextInstall(pToolMain, toolId);
	}
#endif

	if (e.getErrId() != WARN_OK && e.getErrId() != ERR_UNKNOWNERROR)
	{
		onINError(e);
		return ToolStartRes::Failed;
	}
	else
	{
		UserCore::Misc::ToolProgress prog;

		prog.done = m_uiCompleteCount;
		prog.total = m_pTransaction->size();
		prog.percent = prog.done*100/prog.total;

		m_pTransaction->onProgressEvent(prog);
	}
	
	return ToolStartRes::Success;
}
Exemple #14
0
void WebCoreClass::getDownloadProviders(DesuraId id, XML::gcXMLDocument &xmlDocument, MCFBranch mcfBranch, MCFBuild mcfBuild)
{
	PostMap postData;

	postData["siteareaid"] = id.getItem();
	postData["sitearea"] = id.getTypeString();
	postData["branch"] = (size_t) mcfBranch;

	if (mcfBuild != 0)
		postData["build"] = (size_t) mcfBuild;

	postToServer(getMCFDownloadUrl(), "itemdownloadurl", postData, xmlDocument);
}
Exemple #15
0
void InternalLink::handleInternalLink(DesuraId id, uint8 action, const std::vector<std::string> &argsList)
{
	if (g_pMainApp->isOffline() && action != ACTION_LAUNCH)
		return;

	Args args(argsList);

	bool handled = true;

	switch (action)
	{
	case ACTION_UPLOAD		: uploadMCF( id );						break;
	case ACTION_CREATE		: createMCF( id );						break;
	case ACTION_RESUPLOAD	: resumeUploadMCF( id, args );			break;
#ifdef WIN32
	case ACTION_INSTALLEDW	: installedWizard();					break;
#endif
	case ACTION_SHOWSETTINGS: showSettings(args);					break;
	case ACTION_APPUPDATELOG: showUpdateLogApp( id.getItem() );		break;
	case ACTION_PAUSE		: setPauseItem( id , true );			break;
	case ACTION_UNPAUSE		: setPauseItem( id , false );			break;
	case ACTION_UNINSTALL	: uninstallMCF( id );					break;
	case ACTION_PROMPT		: showPrompt(id, args);					break;
	case ACTION_UPDATELOG	: showUpdateLog(id);					break;
	case ACTION_DISPCDKEY	: showCDKey(id, args);					break;

	default: 
		handled = false;
		break;
	}

	if (handled || checkForm(id))
		return;

	switch (action)
	{
	case ACTION_INSTALL		: installItem(id, args);				break;
	case ACTION_LAUNCH		: launchItem(id, args);					break;
	case ACTION_VERIFY		: verifyItem(id, args);					break;
	case ACTION_UPDATE		: updateItem(id, args);					break;
	case ACTION_TEST		: installTestMCF(id, args);				break;
	case ACTION_INSCHECK	: installCheck(id);						break;
	case ACTION_SHOWUPDATE	: showUpdateForm(id, args);				break;
	case ACTION_SWITCHBRANCH: switchBranch(id, args);				break;
	case ACTION_CLEANCOMPLEXMOD: cleanComplexMod(id);				break;

	default: 
		Warning(gcString("Unknown internal link {0} for item {1}\n.", (uint32)action, id.toInt64()));	
		break;
	}
}
Exemple #16
0
void MCFManager::getAllMcfPaths(DesuraId id, std::vector<McfPathData> &vList)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());
	std::string res;

	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());

		sqlite3x::sqlite3_command cmd(db, "SELECT path, mcfbuild, branch FROM mcfitem WHERE internalid=?");
		cmd.bind(1, (long long int)id.toInt64());

		sqlite3x::sqlite3_reader reader = cmd.executereader();

		while (reader.read())
		{
			McfPathData mpd;

			mpd.path = UTIL::OS::getAbsPath(reader.getstring(0));
			mpd.build = MCFBuild::BuildFromInt(reader.getint(1));
			mpd.branch = MCFBranch::BranchFromInt(reader.getint(2));

			vList.push_back(mpd);
		}
	}
	catch (std::exception &)
	{
	}
}
Exemple #17
0
void MCFManager::getMCFFiles(std::vector<mcfInfo*> &validFiles, DesuraId id)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());

	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());

		sqlite3x::sqlite3_command cmd(db, "SELECT path, mcfbuild FROM mcfitem WHERE internalid=?;");
		cmd.bind(1, (long long int)id.toInt64());

		sqlite3x::sqlite3_reader reader = cmd.executereader();

		while (reader.read())
		{
			std::string p = UTIL::OS::getAbsPath(reader.getstring(0));
			uint32 v = reader.getint(1);

			validFiles.push_back(new mcfInfo(p.c_str(), v, MCFBranch()));
		}
	}
	catch (std::exception &)
	{
	}
}
Exemple #18
0
void InternalLink::installCheck(DesuraId id)
{
	UI::Forms::ItemForm* form = showItemForm(id, UI::Forms::INSTALL_ACTION::IA_INSTALL_CHECK);

	if (!form)
		Warning(gcString("Cant find item (or item not ready) for install check [{0}].\n", id.toInt64()));
}
Exemple #19
0
void InternalLink::installItem(DesuraId id, Args args)
{
	std::string branch = args.getArgValue("branch");
	std::string global = args.getArgValue("global");

	MCFBranch iBranch;

	if (branch == "shortcut" || global == "shortcut")
	{
		iBranch = MCFBranch::BranchFromInt(-1);
	}
	else if (global.size() > 0)
	{
		iBranch = MCFBranch::BranchFromInt(Safe::atoi(global.c_str()), true);
	}
	else
	{
		iBranch = MCFBranch::BranchFromInt(Safe::atoi(branch.c_str()));
	}

	g_pMainApp->showPlay();

	if (iBranch == 0 && !args.containsArg("skippreorder") && checkForPreorder(id))
		return;
	
	UI::Forms::ItemForm* form = showItemForm(id, UI::Forms::INSTALL_ACTION::IA_INSTALL, iBranch);

	if (!form)
		Warning(gcString("Cant find item (or item not ready) for install [{0}].\n", id.toInt64()));	
}
Exemple #20
0
void MCFManager::properDelMcfBackup(DesuraId gid, DesuraId mid)
{
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());
	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());
		sqlite3x::sqlite3_command cmd(db, "DELETE FROM mcfbackup WHERE gid=? AND mid=?;");
		cmd.bind(1, (long long int)gid.toInt64());
		cmd.bind(2, (long long int)mid.toInt64());
		cmd.executenonquery();
	}
	catch (std::exception &e)
	{
		Warning("Failed to delete mcf backup: {0}\n", e.what());
	}
}
void InternalLink::cleanComplexMod(DesuraId id)
{
	UI::Forms::ItemForm* form = showItemForm(id, UI::Forms::INSTALL_ACTION::IA_CLEANCOMPLEX, true);

	if (!form)
		Warning("Cant find item (or item not ready) for clean complex mod [{0}].\n", id.toInt64());
}
Exemple #22
0
gcString MCFManager::newMcfPath(DesuraId id, MCFBranch branch, MCFBuild build, bool isUnAuthed)
{
	gcString curPath = getMcfPath(id, branch, build, isUnAuthed);

	if (curPath != "")
		return curPath;

	curPath = generatePath(id, branch, build, isUnAuthed);
	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());

	try
	{
		int flags = isUnAuthed?FLAG_UNAUTHED:FLAG_NONE;

		sqlite3x::sqlite3_connection db(szItemDb.c_str());
		sqlite3x::sqlite3_command cmd(db, "INSERT INTO mcfitem VALUES (?,?,?,?,?);");
		cmd.bind(1, (long long int)id.toInt64());
		cmd.bind(2, (int)build);
		cmd.bind(3, UTIL::OS::getRelativePath(curPath));
		cmd.bind(4, (int)branch);
		cmd.bind(5, (int)flags);

		cmd.executenonquery();
	}
	catch (std::exception &e)
	{
		curPath = "";
		Warning("Failed to insert mcf item: {0}\n", e.what());
	}

	return curPath;
}
Exemple #23
0
void User::removeUninstallInfo(DesuraId id)
{
#ifdef WIN32
	if (getServiceMain())
		getServiceMain()->removeUninstallRegKey(id.toInt64());
#endif
}
Exemple #24
0
void User::updateUninstallInfo(DesuraId id, uint64 installSize)
{
#ifdef WIN32
	if (getServiceMain())
		getServiceMain()->setUninstallRegKey(id.toInt64(), installSize);
#endif
}
Exemple #25
0
void UpdateInfoForm::setInfo(DesuraId id, bool launch)
{
	m_bLaunch = launch;
	m_uiInternId = id;

	m_cbReminder->Enable(m_bLaunch);
	m_cbReminder->Show(m_bLaunch);

	

	UserCore::Item::ItemInfoI* item = GetUserCore()->getItemManager()->findItemInfo( id );

	if (!item)
	{
		Warning("Cant find item for update form.\n");
		return;
	}

	if (item->getIcon() && UTIL::FS::isValidFile(UTIL::FS::PathWithFile(item->getIcon())))
		setIcon(item->getIcon());

	m_cbReminder->SetValue(m_bLaunch && item->getOptions() & UserCore::Item::ItemInfoI::OPTION_NOTREMINDUPDATE);

	SetLabel(gcWString(L"{0} {1}", Managers::GetString(L"#UI_TITLE"), item->getName()));

	m_ieBrowser->loadUrl(gcWString(L"http://www.desura.com/{0}/{1}/changelog", id.getTypeString(), item->getShortName()));
}
void GameExplorerManager::removeItem(DesuraId item)
{
	Misc::GameExplorerInfo* gei = BaseManager::findItem(item.toInt64());

	if (gei)
		gei->removeDll();
}
Exemple #27
0
void UploadPrepThread::doRun()
{
	UTIL::FS::Path path = UTIL::FS::PathWithFile(m_szFile);

	if (!UTIL::FS::isValidFile(path))
		throw gcException(ERR_INVALIDFILE);


	McfHandle mcfHandle;;

	bool validMcf = false;

	mcfHandle->setFile(m_szFile.c_str());
	mcfHandle->parseMCF();

	MCFCore::MCFHeaderI* mcfHead = mcfHandle->getHeader();

	DesuraId mcfId = mcfHead->getDesuraId();
	DesuraId itemId =  getItemId();

	validMcf = (mcfHead->isValid() && (!mcfId.isOk() || mcfId == itemId));

	if (!validMcf)
		throw gcException(ERR_INVALIDMCF);


	std::string hash = UTIL::MISC::hashFile(path.getFullPath().c_str());
	uint64 fileSize = UTIL::FS::getFileSize(path);

	char* key = NULL;

	try
	{
		getWebCore()->newUpload(getItemId(), hash.c_str(), fileSize, &key);
	}
	catch (gcException &)
	{
		safe_delete(key);
		throw;
	}

	getUploadManager()->addUpload(getItemId(), key, m_szFile.c_str());
	m_szKey = gcString(key);
	safe_delete(key);

	onCompleteStrEvent(m_szKey);
}
Exemple #28
0
gcString MCFManager::newMcfBackup(DesuraId gid, DesuraId mid)
{
	gcString curPath = getMcfBackup(gid, mid);

	if (curPath != "")
		return curPath;

	gcString parPath;
	gcString parFile;

	size_t x=0;


	do
	{


		if (x==0)
			parFile = gcString("backup_{0}.mcf", mid.toInt64());
		else
			parFile = gcString("backup_{0}_{1}.mcf", mid.toInt64(), x);

		parPath = gcString("{0}{1}{2}", m_szMCFSavePath, DIRS_STR, gid.getFolderPathExtension(parFile.c_str()));
		x++;
	}
	while ( UTIL::FS::isValidFile(UTIL::FS::PathWithFile(parPath)) );

	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());

	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());
		sqlite3x::sqlite3_command cmd(db, "INSERT INTO mcfbackup VALUES (?,?,?);");
		cmd.bind(1, (long long int)gid.toInt64());
		cmd.bind(2, (long long int)mid.toInt64());
		cmd.bind(3, UTIL::OS::getRelativePath(parPath));

		cmd.executenonquery();
	}
	catch (std::exception &e)
	{
		Warning("Failed to update mcf backup: {0}\n", e.what());
	}

	return parPath;
}
Exemple #29
0
void MCFManager::validateMcf(const char* mcf)
{
	if (!UTIL::FS::isValidFile(UTIL::FS::PathWithFile(mcf)))
		return;

	McfHandle mcfHandle;
	mcfHandle->setFile(mcf);

	try
	{
		mcfHandle->parseMCF();
	}
	catch (gcException &)
	{
		return;
	}

	MCFCore::MCFHeaderI *mcfHead = mcfHandle->getHeader();

	DesuraId id = mcfHead->getDesuraId();
	MCFBuild build = mcfHead->getBuild();
	MCFBranch branch = mcfHead->getBranch();

	bool isPatch = strstr(mcf, "patch")?true:false;
	bool isUnAuthed = strstr(mcf, "unauth")?true:false;
	int flags = (isPatch?FLAG_PATCH:FLAG_NONE) + (isUnAuthed?FLAG_UNAUTHED:FLAG_NONE);

	gcString szItemDb = getMcfDb(m_szAppDataPath.c_str());

	try
	{
		sqlite3x::sqlite3_connection db(szItemDb.c_str());
		sqlite3x::sqlite3_command cmd(db, "INSERT INTO mcfitem VALUES (?,?,?,?,?);");
		cmd.bind(1, (long long int)id.toInt64());
		cmd.bind(2, (int)build);
		cmd.bind(3, UTIL::OS::getRelativePath(mcf));
		cmd.bind(4, (int)branch);
		cmd.bind(5, (int)flags);

		cmd.executenonquery();
	}
	catch (std::exception &)
	{
	}
}
Exemple #30
0
std::string ToolManager::getToolName(DesuraId toolId)
{
	ToolInfo* info = findItem(toolId.toInt64());

	if (!info)
		return "";

	return info->getName();
}