Ejemplo n.º 1
0
bool Installer::Delete(const QString& appName, eAppType type, bool force) {
    Logger::GetInstance()->AddLog(tr("Deleting %1").arg(appName));
    AppsConfig appsConfig = Settings::GetInstance()->GetCurrentConfig();
    AppsConfig::AppMap* appMap = appsConfig.GetAppMap(type);

    AppsConfig::AppMap::const_iterator appIter = appMap->find(appName);
    if (appIter == appMap->end())
        return "";

    AppsConfig::AppVersion::const_iterator iter = appIter.value().begin();
    if (iter == appIter.value().end())
        return "";

    const AppConfig& config = iter.value();

    QString installPath = GetInstallPath(type);
    if (!config.m_RunPath.isEmpty()){
        while (ProcessHelper::IsProcessRuning(installPath + config.m_RunPath)) {
            Logger::GetInstance()->AddLog(tr("%1 app is running.").arg(appName));
            if(force)
            {
                if (1 == QMessageBox::information(NULL,//this,
                                                 tr("Error"),
                                                 tr("%1 app is running please close it.").arg(appName),
                                                 tr("Retry"))) {
                    Logger::GetInstance()->AddLog(tr("Deleting %1 canceled").arg(appName));
                    return false;
                }
            }
            else
            {
                if (1 == QMessageBox::information(NULL,//this,
                                                 tr("Error"),
                                                 tr("%1 app is running please close it.").arg(appName),
                                                 tr("Retry"),
                                                 tr("Cancel"))) {
                    Logger::GetInstance()->AddLog(tr("Deleting %1 canceled").arg(appName));
                    return false;
                }
            }
        }
    }

    bool result = false;
#ifdef Q_OS_WIN
    if (!config.m_InstallCmd.isEmpty() || !config.m_UninstallCmd.isEmpty()) {
        QString path = GetInstallPath(type) + APP_INSTALLER_DIR + "/" + appName + "/";
        if (!config.m_UninstallCmd.isEmpty())
            path += config.m_UninstallCmd;
        else
            path += config.m_InstallCmd;

        QString params = config.m_UninstallParams;

        int nExitCode = RunAndWaitForFinish(path, params);
        if (nExitCode == config.m_nSuccessInstallCode)
            result = true;
    } else {
#endif
        result = true;
        for (int i = 0; i < config.m_InstalledFiles.size(); ++i) {
            QString path = installPath + config.m_InstalledFiles.at(i);

            QFile file(path);
            if (file.exists()) {
                QFileInfo info(file);
                if (info.isDir()) {
                    result &= DirectoryManager::DeleteDir(path);
                } else {
                    result &= QFile().remove(path);
                }
            }
        }
#ifdef Q_OS_WIN
    }
#endif

    if (!result) {
        Logger::GetInstance()->AddLog(tr("Error delete app"));
        return false;
    }

    Logger::GetInstance()->AddLog(tr("%1 deleted").arg(appName));
    appMap->remove(appName);
    Settings::GetInstance()->UpdateConfig(appsConfig);

    UpdateAvailableSoftware();
    return true;
}
Ejemplo n.º 2
0
void Installer::OnAppDownloaded() {
    emit DownloadFinished();

    if (!m_pReply)
        return;

    eAppType type = (eAppType)m_pReply->property(INSTALL_TYPE).toInt();
    QString appName = m_pReply->property(INSTALL_NAME).toString();
    QString appVersion = m_pReply->property(INSTALL_VERISON).toString();
    const AppsConfig::AppMap* pUpdateMap = m_AppsConfig.GetAppMap(type);
    if (!pUpdateMap)
        return;

    AppsConfig::AppMap::const_iterator appIter = pUpdateMap->find(appName);
    if (appIter == pUpdateMap->end())
        return;

    AppsConfig::AppVersion::const_iterator iter = appIter.value().find(appVersion);
    if (iter == appIter.value().end())
        return;

    const AppConfig& updateConfig = iter.value();

    QByteArray data = m_pReply->readAll();
    if (!data.size()) {
        Logger::GetInstance()->AddLog(tr("Error download app"));
        return;
    }

    //save archive
    QString tempFilePath = DirectoryManager::GetInstance()->GetDownloadDir() + APP_DOWNLOAD;
    QFile tempFile(tempFilePath);
    if (!tempFile.open(QFile::WriteOnly | QFile::Truncate)) {
        Logger::GetInstance()->AddLog(tr("Error save archive"));
        return;
    }
    tempFile.write(data);
    tempFile.close();

    //unpack archive
    QString tempDir = DirectoryManager::GetInstance()->GetDownloadDir() + APP_TEMP_DIR;
    if (!DirectoryManager::DeleteDir(tempDir)) {
        Logger::GetInstance()->AddLog(tr("Error delete old directory"));
        return;
    }
    if (!QDir().mkdir(tempDir)) {
        Logger::GetInstance()->AddLog(tr("Error create temp directory"));
        return;
    }

    //if file is a zip-archive - unpack, otherwise - just move to the tempDir
    //check is performed by server's file extension
    QFileInfo serverFileInfo(updateConfig.m_Url.toString());
    QString serverFileName = serverFileInfo.fileName();

    if (DirectoryManager::IsFilePacked(serverFileName)) {
        if (!zipHelper::unZipFile(tempFilePath, tempDir)) {
            Logger::GetInstance()->AddLog(tr("Error unpack archive"));
            return;
        }
    } else {
        if (!DirectoryManager::MoveFileToDir(tempFilePath, tempDir, serverFileName)) {
            Logger::GetInstance()->AddLog(tr("Error move file to the temp directory"));
            return;
        }
    }

    //copy to destination
    QString installPath = GetInstallPath(type);

    //no install just copy file to new folder
    QStringList installedFiles = DirectoryManager::GetDirectoryStructure(tempDir);

    bool bInstalled = false;
#ifdef Q_OS_WIN
    if (updateConfig.m_InstallCmd.isEmpty()) {
#endif
        bInstalled = DirectoryManager::CopyAllFromDir(tempDir, installPath);
        if (!bInstalled) {
            Logger::GetInstance()->AddLog(tr("Error copy apps to destination"));
        }
#ifdef Q_OS_WIN
    }else {
        QString InstallerPath;
        do {
            //copy installer
            //create path for save installer
            QString InstallersPath = installPath + APP_INSTALLER_DIR;
            if (!QDir().exists(InstallersPath) &&
                !QDir().mkdir(InstallersPath)) {
                Logger::GetInstance()->AddLog(tr("Error create installers path"));
                break;
            }
            //create app installer path
            InstallerPath = InstallersPath + "/" + appName;
            DirectoryManager::DeleteDir(InstallerPath);
            if (!QDir().mkdir(InstallerPath)) {
                Logger::GetInstance()->AddLog(tr("Error create installer path"));
                break;
            }
            //copy installer
            if (!DirectoryManager::CopyAllFromDir(tempDir, InstallerPath)) {
                Logger::GetInstance()->AddLog(tr("Error copy installer"));
                break;
            }
            QString installer = InstallerPath + "/" + updateConfig.m_InstallCmd;

            QFile aFile(installer);
            if (!aFile.exists()) {
                Logger::GetInstance()->AddLog(tr("Error running installer - file not found"));
                break;
            }

            QString params = updateConfig.m_InstallParams;
            int nExitCode = RunAndWaitForFinish(installer, params);

            if (updateConfig.m_nSuccessInstallCode == nExitCode)
                bInstalled = true;
        } while(false);

        if (!bInstalled) {
            //hack after cancel install directory can't be delete at once
            //so we rename it and then delete
            QString temp = InstallerPath + QString::number(QDateTime().currentMSecsSinceEpoch());
            DirectoryManager::DeleteDir(QDir().rename(InstallerPath, temp) ? temp : InstallerPath);
        }
    }
#endif

    if (bInstalled) {
        AppConfig config;

        //const AppConfig installedConfig = installedApp.value(name);
        config.m_Name = appName;
        if (!updateConfig.m_RunPath.isEmpty())
            config.m_RunPath = updateConfig.m_RunPath;
        config.m_InstalledFiles = installedFiles;
        config.m_Version = updateConfig.m_Version;
        config.m_InstallCmd = updateConfig.m_InstallCmd;
        config.m_UninstallCmd = updateConfig.m_UninstallCmd;
        config.m_InstallParams = updateConfig.m_InstallParams;
        config.m_UninstallParams = updateConfig.m_UninstallParams;

        AppsConfig setting = Settings::GetInstance()->GetCurrentConfig();
        AppsConfig::AppMap* pSettingMap = setting.GetAppMap(type);
        if (pSettingMap) {
            pSettingMap->remove(config.m_Name);
            //pSettingMap->insert(appName, config);
            (*pSettingMap)[config.m_Name][config.m_Version] = config;
        }
        Settings::GetInstance()->UpdateConfig(setting);
    }

    //delete temp files
    DirectoryManager::DeleteDir(tempDir);
    QFile().remove(tempFilePath);

    UpdateAvailableSoftware();
    if (bInstalled) {
        Logger::GetInstance()->AddLog(tr("%1 installed.").arg(appName));
        CheckForUpdate();
    }
}