void MigrateStandaloneTask::doTask() { auto wildc = gcRefPtr<WildcardManager>::create(); wildc->onNeedSpecialEvent += delegate(&getUserCore()->getNeedWildCardEvent()); for (size_t x=0; x<m_vFileList.size(); x++) { AutoDelFile adf(m_vFileList[x]); XML::gcXMLDocument doc(m_vFileList[x].getFullPath().c_str()); if (!doc.IsValid()) continue; auto root = doc.GetRoot("game"); if (!root.IsValid()) continue; gcString path; gcString id; uint32 branch = -1; uint32 build = -1; root.GetChild("path", path); root.GetChild("id", id); root.GetChild("branch", branch); root.GetChild("build", build); if (id == "" || !UTIL::FS::isValidFolder(path)) continue; DesuraId itemId(id.c_str(), "games"); auto info = getUserCore()->getItemManager()->findItemInfo(itemId); if (!info || info->isInstalled()) continue; try { getUserCore()->getCIPManager()->updateItem(itemId, path); getUserCore()->getItemManager()->retrieveItemInfo(getItemId(), 0, wildc); } catch (...) { continue; } info = getUserCore()->getItemManager()->findItemInfo(itemId); auto realInfo = gcRefPtr<UserCore::Item::ItemInfo>::dyn_cast(info); if (!realInfo) continue; realInfo->migrateStandalone(MCFBranch::BranchFromInt(branch), MCFBuild::BuildFromInt(build)); } }
void UploadResumeThread::doRun() { assert(m_pUpInfo); getWebCore()->resumeUpload(getItemId(), m_szKey.c_str(), *m_pUpInfo); const char* localFilePath = getUploadManager()->findUpload(m_szKey.c_str()); gcString sLocalFP(localFilePath); if (localFilePath && validFile(localFilePath)) { onCompleteStrEvent(sLocalFP); return; } //gona try and search for the file in the data/mods/id folder const char* appDataPath = getUserCore()->getAppDataPath(); gcString searchPath("{0}{1}{2}", appDataPath, DIRS_STR, getItemId().getFolderPathExtension()); gcString sNull("NULL"); if (doSearch(searchPath.c_str())) return; if (getUserCore()->isAdmin()) { searchPath = gcString("{0}{1}temp{1}", appDataPath, DIRS_STR); if (doSearch(searchPath.c_str())) return; } onCompleteStrEvent(sNull); }
bool VSInstallMissing::doTask() { const char* val = getUserCore()->getCVarValue("gc_corecount"); gcException errFailMCFServ(ERR_NULLHANDLE, "Failed to create uninstall MCF service!\n"); m_pIPCIM = getUserCore()->getServiceMain()->newInstallMcf(); if (!m_pIPCIM) { onErrorEvent(errFailMCFServ); return false; } uint8 workers = 1; if (val) workers = atoi(val); if (workers == 0) workers = 1; m_pIPCIM->onCompleteEvent += delegate(this, &VSInstallMissing::onComplete); m_pIPCIM->onProgressEvent += delegate(&onProgressEvent); m_pIPCIM->onErrorEvent += delegate(&onErrorEvent); m_pIPCIM->start(m_hMcf->getFile(), getItemInfo()->getPath(), getItemInfo()->getInstallScriptPath(), workers); m_WaitCond.wait(); m_bFinished = true; return isStopped() == false; }
void InstallCheckTask::doRun() { WildcardManager wildc = WildcardManager(); wildc.onNeedSpecialEvent += delegate(&onNeedWCEvent); wildc.onNeedSpecialEvent += delegate(getUserCore()->getNeedWildCardEvent()); getUserCore()->getItemManager()->retrieveItemInfo(getItemId(), 0, &wildc); uint32 prog = 0; onCompleteEvent(prog); getItemHandle()->completeStage(false); }
bool GatherInfoTask::checkNullBranch(UserCore::Item::BranchInfoI* branchInfo) { if (branchInfo) return true; if (!getUserCore()->getItemManager()->isKnownBranch(getMcfBranch(), getItemId())) throw gcException(ERR_BADITEM, "Branch is invalid or user doesnt have permissions to install branch."); if (!m_bFirstTime || HasAnyFlags(m_uiFlags, GI_FLAG_TEST)) throw gcException(ERR_UNSUPPORTEDPLATFORM, 1, "This branch is not supported on this platform"); m_bFirstTime = false; bool res = false; if (!m_bCanceled && m_pGIHH) res = m_pGIHH->showPlatformError(); if (!res) { completeStage(); } else { m_uiMcfBranch = MCFBranch::BranchFromInt(0); checkRequirements(); } return false; }
void GatherInfoTask::doTask() { auto pUser = getUserCore(); if (!pUser) return; try { uint32 flags = UserCore::Item::ItemInfoI::STATUS_DELETED; if (m_bAddToAccount) flags = UserCore::Item::ItemInfoI::STATUS_ONACCOUNT; pUser->getItemManager()->retrieveItemInfo(getItemId(), flags); if (m_bAddToAccount) { //if we just removed this item from account it will be in a hidden deleted status auto info = pUser->getItemManager()->findItemInfo(getItemId()); if (info) info->delSFlag(UserCore::Item::ItemInfoI::STATUS_DELETED); } } catch(gcException &e) { Warning("Failed to gather item info in task: {0}\n", e); } }
void GetItemListThread::doRun() { m_szDbName = getCIBDb(getUserCore()->getAppDataPath()); tinyxml2::XMLDocument doc; getWebCore()->getInstalledItemList(doc); int ver = XML::processStatus(doc, "itemwizard"); tinyxml2::XMLElement *infoNode = doc.FirstChildElement("itemwizard"); if (!infoNode) throw gcException(ERR_BADXML); if (isStopped()) return; WildcardManager wMng = WildcardManager(); if (ver == 1) parseItems1(infoNode, &wMng); else parseItems2(infoNode, &wMng); try { createCIPDbTables(getUserCore()->getAppDataPath()); sqlite3x::sqlite3_connection db(m_szDbName.c_str()); sqlite3x::sqlite3_command cmd(db, "REPLACE INTO cipiteminfo (internalid, name) VALUES (?,?);"); for (size_t x=0; x<m_vGameList.size(); x++) { cmd.bind(1, (long long int)m_vGameList[x].getId().toInt64()); cmd.bind(2, std::string(m_vGameList[x].getName()) ); cmd.executenonquery(); } } catch (std::exception &e) { Warning(gcString("Failed to update cip item list: {0}\n", e.what())); } uint32 prog=0; onCompleteEvent(prog); }
VSDownloadMissing::~VSDownloadMissing() { m_hMcf->getNewProvider() -= delegate(this, &VSDownloadMissing::onNewProvider); UserCore::User* pUser = dynamic_cast<UserCore::User*>(getUserCore()); if (pUser) pUser->getBDManager()->cancelDownloadBannerHooks(this); }
void VerifyServiceTask::refreshInfo() { if (m_bRefreshedInfo) return; m_bRefreshedInfo = true; getUserCore()->getItemManager()->retrieveItemInfo(getItemId()); }
void ItemHandle::doLaunch(Helper::ItemLaunchHelperI* helper) { char magicBytes[5] = {0}; UserCore::Item::Misc::ExeInfoI* ei = getItemInfo()->getActiveExe(); const char* exe = ei->getExe(); const char* args = getUserCore()->getCVarValue("gc_linux_launch_globalargs"); gcString globalExe = getUserCore()->getCVarValue("gc_linux_launch_globalbin"); if (globalExe.size() > 0) { if (!UTIL::FS::isValidFile(globalExe.c_str())) { Warning(gcString("Couldn't find global exe [{0}], ignoring.\n", globalExe)); globalExe = ""; exe = ei->getExe(); } else { exe = globalExe.c_str(); } } try { UTIL::FS::FileHandle fh(exe, UTIL::FS::FILE_READ); fh.read(magicBytes, 5); } catch (gcException& e) { throw gcException(ERR_LAUNCH, e.getSecErrId(), gcString("Failed to read [{0}]: {1}\n", exe, e)); } UTIL::LIN::BinType type = UTIL::LIN::getFileType(magicBytes, 5); if (type == UTIL::LIN::BT_WIN && helper) helper->showWinLaunchDialog(); //if we are not using globalExe set exe to Null so that we use the proper exe if (globalExe.size() == 0 || type == UTIL::LIN::BT_UNKNOWN) exe = NULL; doLaunch(type == UTIL::LIN::BT_UNKNOWN, exe, args); }
bool VerifyServiceTask::checkTools() { refreshInfo(); std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return false; getUserCore()->getToolManager()->invalidateTools(toolList); if (!getUserCore()->getToolManager()->areAllToolsDownloaded(toolList)) getItemHandle()->goToStageDownloadTools(false); else getItemHandle()->goToStageInstallTools(false); return true; }
void VerifyServiceTask::checkHooks() { refreshInfo(); const char* hookPath = getItemInfo()->getInstallScriptPath(); const char* insPath = getItemInfo()->getPath(); if (hookPath && UTIL::FS::isValidFile(hookPath)) getUserCore()->getServiceMain()->runInstallScript(hookPath, insPath, "PostInstall"); }
void DownloadAvatarTask::doTask() { try { if (strncmp(m_szUrl.c_str(),"http://", 7)==0) { HttpHandle wc(m_szUrl.c_str()); wc->getWeb(); if (wc->getDataSize() != 0) { if (UTIL::MISC::isValidImage((const unsigned char*)wc->getData()) == IMAGE_VOID) throw gcException(ERR_INVALIDDATA, gcString("The url [{0}] is not an image format", m_szUrl)); UTIL::FS::Path urlPath(m_szUrl, "", true); UTIL::FS::Path path(getUserCore()->getAppDataPath(), "", false); path += "users"; path += gcString("{0}", m_uiUserId); path += urlPath.getFile(); UTIL::FS::recMakeFolder(path); UTIL::FS::FileHandle fh(path, UTIL::FS::FILE_WRITE); fh.write(wc->getData(), wc->getDataSize()); fh.close(); getUserCore()->setAvatarUrl(path.getFullPath().c_str()); } else { throw gcException(ERR_BADRESPONSE); } } } catch (gcException &e) { onErrorEvent(e); } }
void VerifyServiceTask::setupCurTask() { m_pCurTask->onErrorEvent += delegate(this, &VerifyServiceTask::onError); m_pCurTask->setItemHandle(getItemHandle()); m_pCurTask->setMcfBuild(m_McfBuild); m_pCurTask->setMcfBranch(m_McfBranch); m_pCurTask->setUserCore(getUserCore()); m_pCurTask->setWebCore(getWebCore()); m_pCurTask->setMcfHandle(m_hMcf.handle()); }
void DownloadToolTask::doRun() { uint32 per = 0; getItemInfo()->setPercent(per); if (m_ToolTTID == UINT_MAX) validateTools(); std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); UserCore::Misc::ToolTransaction* tt = new UserCore::Misc::ToolTransaction(); tt->onCompleteEvent += delegate(this, &DownloadToolTask::onDLComplete); tt->onErrorEvent += delegate(this, &DownloadToolTask::onDLError); tt->onProgressEvent += delegate(this, &DownloadToolTask::onDLProgress); tt->toolsList = toolList; if (m_ToolTTID != UINT_MAX) { bool res = getUserCore()->getToolManager()->updateTransaction(m_ToolTTID, tt); if (!res) //must be complete { onComplete(); return; } } else { m_ToolTTID = getUserCore()->getToolManager()->downloadTools(tt); } if (m_ToolTTID != UINT_MAX) m_WaitCond.wait(); onComplete(); }
void DownloadToolTask::onComplete() { bool notComplete = isStopped() || m_bCancelled; getUserCore()->getToolManager()->removeTransaction(m_ToolTTID, notComplete); m_ToolTTID = UINT_MAX; std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (!m_bCancelled && !getUserCore()->getToolManager()->areAllToolsDownloaded(toolList)) { gcException e(ERR_INVALID, "Failed to download tools."); onErrorEvent(e); notComplete = true; } if (notComplete) { getItemHandle()->completeStage(true); return; } uint32 blank = 0; onCompleteEvent(blank); if (m_bInstallAfter) { getItemHandle()->goToStageInstallTools(m_bLaunch); } else { if (HasAllFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX)) getItemHandle()->goToStageInstallComplex(getMcfBranch(), getMcfBuild()); else getItemHandle()->goToStageInstall(m_szDownloadPath.c_str(), getMcfBranch()); } }
gcString VSCheckMcf::downloadMCFHeader() { if (isStopped()) return ""; auto mm = getUserCore()->getInternal()->getMCFManager(); gcString path = mm->getMcfPath(getItemId(), getMcfBranch(), getMcfBuild()); if (path == "") path = mm->newMcfPath(getItemId(), getMcfBranch(), getMcfBuild()); m_hTempMcf->setHeader(getItemId(), getMcfBranch(), getMcfBuild()); try { auto dp = std::make_shared<MCFDownloadProviders>(getWebCore(), getUserCore()->getUserId()); MCFDownloadProviders::forceLoad(m_hTempMcf, dp); m_hTempMcf->dlHeaderFromWeb(); } catch (gcException &except) { onErrorEvent(except); return ""; } m_hTempMcf->setFile(path.c_str()); m_hTempMcf->markFiles(m_hTempMcf.handle(), false, false, false, false); m_hTempMcf->saveMCFHeader(); if (isStopped()) return ""; m_hTempMcf = McfHandle(); return path; }
void DownloadToolTask::validateTools() { std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return; if (!getUserCore()->getToolManager()->areAllToolsValid(toolList)) { //missing tools. Gather info again TiXmlDocument doc; getWebCore()->getItemInfo(getItemId(), doc, MCFBranch(), MCFBuild()); TiXmlNode *uNode = doc.FirstChild("iteminfo"); if (!uNode) throw gcException(ERR_BADXML); TiXmlNode *toolNode = uNode->FirstChild("toolinfo"); if (toolNode) getUserCore()->getToolManager()->parseXml(toolNode); TiXmlNode *gameNode = uNode->FirstChild("games"); if (!gameNode) throw gcException(ERR_BADXML); getItemInfo()->getCurrentBranch()->getToolList(toolList); } if (!getUserCore()->getToolManager()->areAllToolsValid(toolList)) throw gcException(ERR_INVALID, "Tool ids cannot be resolved into tools."); }
void DownloadToolTask::downloadTool() { m_fhFile.open(m_Path, UTIL::FS::FILE_WRITE); HttpHandle hh(m_pTool->getUrl()); m_pHttpHandle = hh.operator->(); hh->getProgressEvent() += delegate(this, &DownloadToolTask::onProgress); hh->getWriteEvent() += delegate(this, &DownloadToolTask::onWrite); hh->setUserAgent(getUserCore()->getWebCore()->getUserAgent()); hh->getWeb(); m_pHttpHandle = nullptr; m_fhFile.close(); }
void DownloadToolTask::validateTools() { std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return; auto pToolManager = getUserCore()->getToolManager(); if (pToolManager->areAllToolsValid(toolList)) return; pToolManager->reloadTools(getItemId()); getItemInfo()->getCurrentBranch()->getToolList(toolList); if (!pToolManager->areAllToolsValid(toolList)) throw gcException(ERR_INVALID, "Tool ids cannot be resolved into tools."); }
void GatherInfoThread::doRun() { auto wildc = gcRefPtr<WildcardManager>::create(); wildc->onNeedSpecialEvent += delegate(&onNeedWCEvent); uint32 prog = 0; onProgUpdateEvent(prog); getUserCore()->getItemManager()->retrieveItemInfo(getItemId(), 0, wildc, MCFBranch::BranchFromInt(getMcfBranch()), MCFBuild::BuildFromInt(getMcfBuild())); if (isStopped()) return; auto item = getItemInfo(); if (!item) throw gcException(ERR_INVALIDDATA, "The item handle was null (gather info failed)"); uint32 itemId = item->getId().getItem(); onCompleteEvent(itemId); }
bool VSCheckMcf::doTask(bool &goodMcf) { auto mm = getUserCore()->getInternal()->getMCFManager(); gcString filePath = mm->getMcfPath(getItemId(), getMcfBranch(), getMcfBuild()); if (!checkMcf(filePath)) { UTIL::FS::delFile(filePath); filePath = downloadMCFHeader(); } if (!checkMcf(filePath)) return false; goodMcf = false; m_hMcf->setFile(filePath.c_str()); if (isStopped()) return false; try { m_hMcf->parseMCF(); bool passedVerify = m_hMcf->verifyMCF(); if (m_hMcf->isComplete()) goodMcf = passedVerify; m_hMcf->saveMCFHeader(); } catch (gcException &) { } return true; }
void RegenLaunchScriptsTask::doTask() { std::vector<gcRefPtr<UserCore::Item::ItemHandleI>> itemList; auto im = getUserCore()->getItemManager(); for (size_t x=0; x<im->getCount(); x++) { itemList.push_back(im->getItemHandle(x)); } for (size_t x=0; x<itemList.size(); x++) { if (!itemList[x] || !itemList[x]->getItemInfo()->isInstalled()) continue; #ifdef NIX itemList[x]->installLaunchScripts(); #endif } }
void VSDownloadMissing::onNewProvider(MCFCore::Misc::DP_s& dp) { if (isStopped()) return; if (!dp.provider) return; if (dp.action == MCFCore::Misc::DownloadProvider::ADD) { UserCore::User* pUser = dynamic_cast<UserCore::User*>(getUserCore()); if (pUser) pUser->getBDManager()->downloadBanner(this, dp.provider); } else if (dp.action == MCFCore::Misc::DownloadProvider::REMOVE) { UserCore::Misc::GuiDownloadProvider gdp(MCFCore::Misc::DownloadProvider::REMOVE, dp.provider); onNewProviderEvent(gdp); } }
void DownloadBannerTask::doTask() { BannerCompleteInfo dpinfo(this, m_DownloadProvider); try { UTIL::FS::Path path(getUserCore()->getAppDataPath(), "", false); path += "temp"; UTIL::FS::recMakeFolder(path); getWebCore()->downloadBanner(&m_DownloadProvider, path.getFullPath().c_str()); dpinfo.complete = true; } catch (gcException &e) { Warning("Failed to download banner: {0}\n", e); dpinfo.complete = false; } onDLCompleteEvent(dpinfo); }
void ChangeAccountTask::doTask() { auto pItem = getItemInfo(); if (!pItem || !getWebCore()) return; try { if (m_Action == ACCOUNT_ADD) { getWebCore()->updateAccountItem(pItem->getId(), true); pItem->addSFlag(ItemInfoI::STATUS_ONACCOUNT); } else { getWebCore()->updateAccountItem(pItem->getId(), false); pItem->delSFlag(ItemInfoI::STATUS_ONACCOUNT); if (!(pItem->getStatus() & (ItemInfoI::STATUS_INSTALLED| ItemInfoI::STATUS_ONCOMPUTER| ItemInfoI::STATUS_DOWNLOADING| ItemInfoI::STATUS_INSTALLING| ItemInfoI::STATUS_UPLOADING| ItemInfoI::STATUS_VERIFING))) { getUserCore()->getItemManager()->removeItem(pItem->getId()); } } } catch (gcException &except) { if (except.getSecErrId() != 107) Warning("Error in Change Account task: {0}.\n", except); } }
bool UIComplexModServiceTask::initService() { m_OldBranch = getItemInfo()->getInstalledBranch(); m_OldBuild = getItemInfo()->getInstalledBuild(); UserCore::Item::ItemInfo* parentInfo = getParentItemInfo(); if (getItemInfo()->getInstalledModId().isOk()) parentInfo = getItemInfo(); if (!parentInfo) { onComplete(); return false; } m_idLastInstalledMod = parentInfo->getInstalledModId(); getUserCore()->getItemManager()->setInstalledMod(parentInfo->getId(), DesuraId()); if (!m_idLastInstalledMod.isOk()) { onComplete(); return false; } UserCore::Item::ItemInfo* modInfo = dynamic_cast<UserCore::Item::ItemInfo*>(getUserCore()->getItemManager()->findItemInfo(m_idLastInstalledMod)); if (!modInfo) { gcException eModNoExist(ERR_NULLHANDLE, "Installed mod doesnt exist in database!\n"); onErrorEvent(eModNoExist); return false; } m_pIPCCL = getServiceMain()->newComplexLaunch(); if (!m_pIPCCL) { gcException eFailedUninstall (ERR_NULLHANDLE, "Failed to create uninstall complex branch mcf service!\n"); onErrorEvent(eFailedUninstall); return false; } UserCore::MCFManager *mm = UserCore::GetMCFManager(); gcString installPath = modInfo->getPath(); gcString parPath = mm->getMcfBackup(parentInfo->getId(), m_idLastInstalledMod); gcString modMcfPath; if (m_idLastInstalledMod == getItemInfo()->getId()) modMcfPath = getBranchMcf(modInfo->getId(), m_OldBranch, m_OldBuild); else modMcfPath = getBranchMcf(modInfo->getId(), modInfo->getInstalledBranch(), modInfo->getInstalledBuild()); if (m_uiCompleteAction == CA_UNINSTALL) modInfo->resetInstalledMcf(); m_pIPCCL->onCompleteEvent += delegate(this, &UIComplexModServiceTask::onComplete); m_pIPCCL->onProgressEvent += delegate(this, &UIComplexModServiceTask::onProgress); m_pIPCCL->onErrorEvent += delegate((UIBaseServiceTask*)this, &UIBaseServiceTask::onServiceError); m_pIPCCL->startRemove(modMcfPath.c_str(), parPath.c_str(), installPath.c_str(), getItemInfo()->getInstallScriptPath()); return true; }
uint32 GatherInfoTask::validate() { UserCore::Item::ItemInfoI* pItemInfo = getItemHandle()->getItemInfo(); uint32 isValid = 0; if (!pItemInfo) return UserCore::Item::Helper::V_BADINFO; DesuraId par = pItemInfo->getParentId(); UserCore::Item::ItemInfoI *parInfo = nullptr; if (par.isOk()) { parInfo = getUserCore()->getItemManager()->findItemInfo(par); if (!parInfo || !(parInfo->getStatus() & UserCore::Item::ItemInfoI::STATUS_INSTALLED)) isValid |= UserCore::Item::Helper::V_PARENT; } const char* path = pItemInfo->getPath(getMcfBranch()); if (!path) { isValid |= UserCore::Item::Helper::V_BADPATH; } else { const char *comAppPath = getUserCore()->getAppDataPath(); uint64 inFreeSpace = UTIL::OS::getFreeSpace(path); uint64 dlFreeSpace = UTIL::OS::getFreeSpace(comAppPath); //if they are on the same drive: if (strncmp(comAppPath, path, 3) == 0) { if ((inFreeSpace+dlFreeSpace) < (pItemInfo->getDownloadSize()+pItemInfo->getInstallSize())) { isValid |= (UserCore::Item::Helper::V_FREESPACE|UserCore::Item::Helper::V_FREESPACE_DL|UserCore::Item::Helper::V_FREESPACE_INS); } } else { if (dlFreeSpace < pItemInfo->getDownloadSize()) isValid |= UserCore::Item::Helper::V_FREESPACE|UserCore::Item::Helper::V_FREESPACE_DL; if (inFreeSpace < pItemInfo->getInstallSize()) isValid |= UserCore::Item::Helper::V_FREESPACE|UserCore::Item::Helper::V_FREESPACE_INS; } if (pItemInfo->getStatus() & UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX) { const char* primPath = pItemInfo->getInsPrimary(); if (primPath && strcmp(primPath, "") != 0 && UTIL::FS::isValidFolder(primPath) && !UTIL::FS::isFolderEmpty(primPath)) isValid |= UserCore::Item::Helper::V_NONEMPTY; } else if (pItemInfo->getStatus() & UserCore::Item::ItemInfoI::STATUS_DLC) { if (!parInfo || gcString(path) != gcString(parInfo->getPath())) { if (!UTIL::FS::isFolderEmpty(path)) isValid |= UserCore::Item::Helper::V_NONEMPTY; } } else if (!UTIL::FS::isFolderEmpty(path)) { isValid |= UserCore::Item::Helper::V_NONEMPTY; } } #ifdef NIX UserCore::Item::BranchInfoI* bi = pItemInfo->getBranchById(getMcfBranch()); std::vector<DesuraId> toolList; bi->getToolList(toolList); uint32 res = getUserCore()->getToolManager()->hasNonInstallableTool(toolList); switch (res) { case 0: isValid |= UserCore::Item::Helper::V_JAVA_SUN; break; case 1: isValid |= UserCore::Item::Helper::V_JAVA; break; case 2: isValid |= UserCore::Item::Helper::V_MONO; break; case 3: isValid |= UserCore::Item::Helper::V_AIR; break; }; #endif return isValid; }
void CreateMCFThread::doRun() { UserCore::Item::ItemInfo *item = getItemInfo(); if (!item && !getUserCore()->isAdmin()) throw gcException(ERR_BADITEM); if (!item) { waitForItemInfo(); item = getItemInfo(); } if (isStopped()) return; if (!item) throw gcException(ERR_BADITEM); const char* val = getUserCore()->getCVarValue("gc_corecount"); if (val && atoi(val) != 0) m_hMCFile->setWorkerCount(atoi(val)); m_hMCFile->parseFolder(m_szPath.c_str(), true); if (m_hMCFile->getFileCount() == 0) throw gcException(ERR_ZEROFILECOUNT, gcString("There are no files in the folder {0}. \nPlease check to see if you have the correct folder and try again.", m_szPath)); if (item->getBranchCount() == 0) { m_hMCFile->setHeader(getItemId(), MCFBranch(), MCFBuild()); m_hMCFile->getHeader()->setParent(0); } else { std::vector<UserCore::Item::BranchInfo*> vBranchList; try { retrieveBranchList(vBranchList); if (vBranchList.size() != 0) compareBranches(vBranchList); } catch (...) { } safe_delete(vBranchList); } if (isStopped()) return; createMcf(); if (isStopped()) return; m_bComplete = true; onCompleteStrEvent(m_szFilePath); }
bool VSCheckMcfDownload::doTask(gcString &path) { auto mm = getUserCore()->getInternal()->getMCFManager(); path = mm->getMcfPath(getItemId(), getMcfBranch(), getMcfBuild()); return checkMcf(path); }