ATBTariffCalculator/CalculatorCInterface/local_git_repository.cpp

#include "local_git_repository.h"

#include <QDir>
#include <QFile>
#include <QTextStream>
#include <QJsonDocument>
#include <QByteArray>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QFile>


QString LocalGitRepository::m_repoRootDirectory = "H:\\";

void LocalGitRepository::SetReposRootDirectory(QString s) {
    m_repoRootDirectory = s;
}

QString LocalGitRepository::GetReposRootDirectory() {
    return m_repoRootDirectory;
}

LocalGitRepository::LocalGitRepository(QString const &localRepository)
    : m_localRepository(localRepository)
    , m_fileMenu("{}")
    , m_fileMenuSize(-1) {
}

int32_t LocalGitRepository::GetFileMenuSizeInternal() const {
    return m_fileMenuSize;
}

QByteArray LocalGitRepository::GetFileMenuInternal() {
    if (m_fileMenuSize == -1) {
        QFile f(QDir::cleanPath(m_repoRootDirectory + QDir::separator()
                              + m_localRepository + QDir::separator()
                              + "etc/psa_webinterface/menu_config.json"));
        if (f.exists()) {
            if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
                m_fileMenu = QTextStream(&f).readAll().toUtf8();

                if (m_fileMenu.isValidUtf8()) {
                    QString const &s = QString::fromUtf8(m_fileMenu);
                    m_fileMenuSize = s.toLocal8Bit().size();
                }
            }
        }
    }
    return m_fileMenu;
}

QByteArray LocalGitRepository::GetFileNameInternal(QString const &fId) {
    QRegularExpressionMatch match;
    static const QRegularExpression re("(master|[0-9]+)");
    if (fId.lastIndexOf(re, -1, &match) != -1) {
        int idx = fId.indexOf("/");
        if (idx != -1) {
            QString path = fId.mid(idx);
            idx = path.indexOf(":");
            if (idx != -1) {
                path = path.mid(0, idx);
                QString s = match.captured(match.lastCapturedIndex());
                if (s != "master") {
                    if (fId.contains("psa_tariff")) {
                        QString fn(QDir::cleanPath(
                            m_repoRootDirectory + QDir::separator() +
                            QString(m_localRepository) + QDir::separator()
                            + path + QDir::separator()
                            + QString("tariff%1.json").arg(s.toUInt(), 2, 10, QChar('0'))));
                        return fn.toUtf8();
                    }
                }
            }
        }
    }
    return QByteArray();
}

QByteArray LocalGitRepository::GetFileInternal(QString const &fId) {
    QByteArray a = GetFileNameInternal(fId);
    if (a.isValidUtf8()) {
        QFile fn(a);
        if (fn.exists()) {
            if (fn.open(QIODevice::ReadOnly)) {
                return fn.readAll();
            }
        }
    }

    return QByteArray("{}");
}

int32_t LocalGitRepository::GetFileSize(QString const &fId) {
    QByteArray a = GetFileNameInternal(fId);
    if (a.isValidUtf8()) {
        QFile fn(a);
        if (fn.exists()) {
            return fn.size();
        }
    }
    return -1;
}

bool LocalGitRepository::SetFileInternal(QString const &fId, QByteArray const &json) {
    QByteArray a = GetFileNameInternal(fId);
    if (a.isValidUtf8()) {
        QFile fn(a);
        if (fn.exists()) {
            if (fn.open(QIODevice::WriteOnly)) {
                qint64 bytesWritten = 0;
                qint64 bytesToWrite = json.size();
                while (bytesToWrite > 0 &&
                      (bytesWritten = fn.write(json.constData(), bytesToWrite)) != -1) {
                    bytesToWrite -= bytesWritten;
                }
                fn.flush();
                return (bytesToWrite == 0);
            }
        }

    }
    return false;
}