CQtDeployer/Deploy/Distributions/idistribution.cpp

#include "idistribution.h"
#include <typeinfo>
#include <QFile>
#include <QTextStream>
#include <QDir>
#include <cassert>
#include <filemanager.h>
#include "deploycore.h"
#include "pathutils.h"
#include <QMap>
#include <distromodule.h>

iDistribution::~iDistribution() = default;

iDistribution::iDistribution(FileManager *fileManager) {
    _fileManager = fileManager;
    assert(_fileManager);
}

QString iDistribution::getClassName() const {
    return typeid(*this).name();
}

QString iDistribution::getLocation() const {
    return _location;
}

void iDistribution::setLocation(const QString &location) {
    _location = location;
}

bool iDistribution::unpackFile(const QFileInfo &resource,
                               const QString &target,
                               const TemplateInfo &info) const {
    QFile file(resource.absoluteFilePath());
    if (!file.open(QIODevice::ReadOnly)) {
        return false;
    }

    QString inputData = file.readAll();
    file.close();

    if (!QDir().mkpath(target))
        return false;

    file.setFileName(target + "/" +  resource.fileName());

    if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        return false;
    }

    inputData.replace("$NAME", info.Name);
    inputData.replace("$DESCRIPTION", info.Description);
    inputData.replace("$VERSION", info.Version);
    inputData.replace("$RELEASEDATA", info.ReleaseData);
    inputData.replace("$ICON", info.Icon);
    inputData.replace("$PUBLISHER", info.Publisher);

    for (auto it = info.Custom.cbegin(); it != info.Custom.cend(); ++it) {
        inputData.replace(it.key(), it.value());
    }

    QTextStream stream(&file);
    stream << inputData;

    file.close();

    return _fileManager->addToDeployed(target + "/" +  resource.fileName());
}

bool iDistribution::unpackDir(const QString &resource,
                              const QString &target,
                              const TemplateInfo &info) const {


    QDir res(resource);
    auto list = res.entryInfoList();

    for (const auto & item :list) {

        if (item.isFile()) {
            if (!unpackFile(item, target, info)) {
                return false;
            }
        } else {
            if (!unpackDir(item.absoluteFilePath(),
                           target + "/" + item.fileName(),
                           info)) {

                return false;
            }
        }
    }

    return true;
}

bool iDistribution::moveData(const QString &from,
                             const QString &to,
                             const QString& ignore) const {
    return _fileManager->moveFolder(from, to, ignore);
}

bool iDistribution::copyFile(const QString &from, const QString &to) const {
    return _fileManager->copyFile(from, to);
}

QString iDistribution::findProcess(const QString &env, const QString& proc) const {
    auto list = env.split(DeployCore::getEnvSeparator());

    for (const auto& path : list) {
        auto files = QDir(path).entryInfoList(QDir::NoDotAndDotDot | QDir::Files);

        for (const auto& bin : files) {
            if (bin.fileName().compare(proc, ONLY_WIN_CASE_INSENSIATIVE) == 0) {
                return bin.absoluteFilePath();
            }
        }
    }

    return "";
}

QMap<int ,QPair<QString, const DistroModule*>>
iDistribution::sortPrefixes(const QHash<QString, DistroModule> &input) {
    QMap<int ,QPair<QString, const DistroModule *>> result;
    for (auto it = input.cbegin(); it != input.cend(); ++it ) {
        result.insertMulti(0xFFFF - it.key().size(), {it.key(), &it.value()});
    }

    return result;
}