void ZipRW::CpFileText(QString source, QString dest, QString File, QString Text)
{
QuaZip qz2(dest);
qz2.open(QuaZip::mdCreate);
QuaZipFile qzf(&qz2);
qzf.open(QFile::WriteOnly, QuaZipNewInfo(File));
qzf.write(Text.toUtf8().data());
qzf.close();
QuaZip qz(source);
qz.open(QuaZip::mdUnzip);
QList<QuaZipFileInfo> lst = qz.getFileInfoList();
foreach (QuaZipFileInfo itm, lst) {
if (itm.name != File) {
qz.setCurrentFile(itm.name, QuaZip::csInsensitive);
QuaZipFile qf(&qz);
qf.open(QFile::ReadOnly);
QByteArray ba = qf.readAll();
qf.close();
QuaZipFile qzf2(&qz2);
qzf2.open(QFile::WriteOnly, QuaZipNewInfo(itm.name));
qzf2.write(ba);
qzf2.close();
}
}
qz.close();
qz2.close();
}
void ZipRW::SetFileText(QString ZipFile, QString File, QString Text)
{
QFile(ZipFile).rename(ZipFile + ".old");
QuaZip qz2(ZipFile);
qz2.open(QuaZip::mdCreate);
QuaZipFile qzf(&qz2);
qzf.open(QFile::WriteOnly, QuaZipNewInfo(File));
qzf.write(Text.toLatin1());
qzf.close();
QuaZip qz(ZipFile + ".old");
qz.open(QuaZip::mdUnzip);
QList<QuaZipFileInfo> lst = qz.getFileInfoList();
foreach (QuaZipFileInfo itm, lst) {
if (itm.name != File) {
qz.setCurrentFile(itm.name, QuaZip::csInsensitive);
QuaZipFile qf(&qz);
qf.open(QFile::ReadOnly);
QByteArray ba = qf.readAll();
qf.close();
QuaZipFile qzf2(&qz2);
qzf2.open(QFile::WriteOnly, QuaZipNewInfo(itm.name));
qzf2.write(ba);
qzf2.close();
}
}
qz.close();
qz2.close();
QFile(ZipFile + ".old").remove();
}
/**
* @brief Exports the portfolios to the archive.
* The portfolios must have been sets before with addPortfolios.
*/
void ExportManager::exportArchive() {
QuaZip zip(this->archivePath);
if(!zip.open(QuaZip::mdCreate)) {
throw ExportException("Cannot create archive "+this->archivePath+".");
}
QuaZipFile archivedFile(&zip);
// Adds the descriptor file in the archive:
QByteArray data = writeDescriptor();
if(!archivedFile.open(QIODevice::WriteOnly, QuaZipNewInfo("portfolios.json"))) {
throw ExportException("Cannot create descriptor file in archive.");
}
archivedFile.write(data);
archivedFile.close();
// Adds the reports and assets' files to the archive:
QDir resourcesFolder(SQLiteManager::getSessionFolder() + QDir::separator() + "Resources");
addToArchive(resourcesFolder, "Reports", archivedFile);
addToArchive(resourcesFolder, "Assets", archivedFile);
zip.close();
if(zip.getZipError() != 0) {
throw ExportException("Error while archiving ("+QString::number(zip.getZipError())+").");
}
}
foreach(QFileInfo fileInfo, files) {
if (!fileInfo.isFile()) {
continue;
}
QString fileNameWithRelativePath (fileInfo.filePath().remove(0, dir.absolutePath().length() + 1));
inFile.setFileName(fileInfo.filePath());
//KeyProvider kp;
if (!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileNameWithRelativePath, fileInfo.filePath())/*, kp.GetKey().toAscii()*/)) {
return false;
}
if (!inFile.open(QIODevice::ReadOnly)) {
return false;
}
while (inFile.getChar(&c) && outFile.putChar(c));
if (outFile.getZipError() != UNZ_OK) {
return false;
}
outFile.close();
if (outFile.getZipError() != UNZ_OK) {
return false;
}
inFile.close();
}
/**
* @brief Adds the content of a folder to the archive.
* @param resourcesFolder Resources' folder.
* @param folderName Folder to add to the archive.
* @param archivedFile The archive file opened with QuaZip.
*/
void ExportManager::addToArchive(QDir resourcesFolder, QString folderName, QuaZipFile& archivedFile) {
QDir folder = resourcesFolder.absolutePath() + QDir::separator() + folderName;
QDirIterator it(folder.absolutePath());
while(it.hasNext()) {
QString filePath = it.next();
QString filename = filePath;
filename.remove(0, folder.absolutePath().size()+1);
if(filename=="." || filename=="..") {
continue;
}
QFile file(filePath);
if(!file.open(QIODevice::ReadOnly)) {
throw ExportException("Cannot open file "+filePath+".");
}
// Creates the file in the archive:
QString filePathInArchive = filePath;
filePathInArchive.remove(0, resourcesFolder.absolutePath().size()+1); // Removes '[..]/Resources/'.
if(!archivedFile.open(QIODevice::WriteOnly, QuaZipNewInfo(filePathInArchive))) {
throw ExportException("Cannot create file "+filePathInArchive+" in archive.");
}
// Writes the file's content:
char c;
while(file.getChar(&c) && archivedFile.putChar(c));
archivedFile.close();
file.close();
}
}
//! @brief append a single file to current archive
//!
bool ZipUtil::appendFileToArchive(QString& file, QString& basedir)
{
bool result = true;
if(!m_zip || !m_zip->isOpen()) {
qDebug() << "[ZipUtil] Zip file not open!";
return false;
}
// skip folders, we can't add them.
QFileInfo fileinfo(file);
if(fileinfo.isDir()) {
return false;
}
QString infile = fileinfo.canonicalFilePath();
QString newfile = infile;
newfile.remove(QDir(basedir).canonicalPath() + "/");
QuaZipFile fout(m_zip);
QFile fin(file);
if(!fin.open(QFile::ReadOnly)) {
qDebug() << "[ZipUtil] Could not open file for reading:" << file;
return false;
}
if(!fout.open(QIODevice::WriteOnly, QuaZipNewInfo(newfile, infile))) {
fin.close();
qDebug() << "[ZipUtil] Could not open file for writing:" << newfile;
return false;
}
result = (fout.write(fin.readAll()) < 0) ? false : true;
fin.close();
fout.close();
return result;
}
int main()
{
QString zipName("test.zip");
char c;
QFile file("quazip.pro");
QuaZip zip(zipName);
if (!zip.open(QuaZip::mdCreate))
return false;
QuaZipFile outFile(&zip);
if (!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(file.fileName())))
return false;
if (!file.open(QIODevice::ReadOnly))
return false;
while (file.getChar(&c) && outFile.putChar(c)) {};
outFile.close();
file.close();
zip.close();
if (zip.getZipError() != 0) {
return false;
}
return 0;
}
/**OK
* Comprime il file fileName, nell'oggetto zip, con il nome fileDest.
*
* La funzione fallisce se:
* * zip==NULL;
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
* * non e possibile aprire il file d'origine;
* * non e possibile creare il file all'interno dell'oggetto zip;
* * si e rilevato un errore nella copia dei dati;
* * non e stato possibile chiudere il file all'interno dell'oggetto zip;
*/
bool JlCompress::compressFile(QuaZip* zip, QString fileName, QString fileDest) {
// zip: oggetto dove aggiungere il file
// fileName: nome del file reale
// fileDest: nome del file all'interno del file compresso
// Controllo l'apertura dello zip
if (!zip) return false;
if (zip->getMode()!=QuaZip::mdCreate &&
zip->getMode()!=QuaZip::mdAppend &&
zip->getMode()!=QuaZip::mdAdd) return false;
// Apro il file originale
QFile inFile;
inFile.setFileName(fileName);
if(!inFile.open(QIODevice::ReadOnly)) return false;
// Apro il file risulato
QuaZipFile outFile(zip);
if(!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileDest, inFile.fileName()))) return false;
// Copio i dati
if (!copyData(inFile, outFile) || outFile.getZipError()!=UNZ_OK) {
return false;
}
// Chiudo i file
outFile.close();
if (outFile.getZipError()!=UNZ_OK) return false;
inFile.close();
return true;
}
bool EasyZip::Zip(QString fileToZip, QString zipFileName){
QuaZip zip(zipFileName);
if(!zip.open(QuaZip::mdCreate)) {
qWarning("testCreate(): zip.open(): %d", zip.getZipError());
return false;
}
zip.setFileNameCodec("UTF-8");
/* Pour lire le fichier par blocs de 64Ko */
QByteArray buffer(65536, Qt::Uninitialized);
QDir dir(fileToZip);
QDirIterator iter(fileToZip, QDir::Files, QDirIterator::Subdirectories);
while(iter.hasNext())
{
iter.next();
if(iter.fileInfo() == QFileInfo(zipFileName))
continue;
QString sourceFilename = iter.fileInfo().absoluteFilePath();
/* Le nom de fichier qui sera stocké dans le .zip */
QString zipFilename = dir.relativeFilePath(sourceFilename);
QFile inFile(iter.filePath());
if(!inFile.open(QIODevice::ReadOnly)) {
qWarning("testCreate(): inFile.open(): %s", inFile.errorString().toLocal8Bit().constData());
return false;
}
QuaZipFile outFile(&zip);
if(!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(zipFilename, sourceFilename))) {
qWarning("testCreate(): outFile.open(): %d", outFile.getZipError());
return false;
}
while(!inFile.atEnd())
{
qint64 nbRead = inFile.read(buffer.data(), buffer.size());
outFile.write(buffer.data(), nbRead);
}
if(outFile.getZipError()!=UNZ_OK) {
qWarning("testCreate(): outFile.putChar(): %d", outFile.getZipError());
return false;
}
outFile.close();
if(outFile.getZipError()!=UNZ_OK) {
qWarning("testCreate(): outFile.close(): %d", outFile.getZipError());
return false;
}
inFile.close();
}
zip.close();
if(zip.getZipError()!=0) {
qWarning("testCreate(): zip.close(): %d", zip.getZipError());
return false;
}
return true;
}
bool Project::save()
{
saveOpenTexts();
serializeConfigurationXml();
// indebted to: http://stackoverflow.com/questions/2598117/zipping-a-folder-file-using-qt
QuaZip zip(mProjectPath);
QuaZipFile outFile(&zip);
if (!zip.open(QuaZip::mdCreate))
{
qWarning() << "zip.open()" << zip.getZipError();
return false;
}
char c;
QFile inFile;
QDir tempDir = getTempDir();
tempDir.setNameFilters(QStringList("*"));
QStringList files = tempDir.entryList(QDir::Files,QDir::Name);
for(int i=0; i<files.count(); i++)
{
inFile.setFileName( tempDir.absoluteFilePath(files.at(i)) );
if( !inFile.open(QIODevice::ReadOnly))
{
qWarning() << inFile.errorString();
return false;
}
if( !outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(files.at(i) , tempDir.absoluteFilePath(files.at(i)) )))
{
qWarning() << outFile.errorString();
return false;
}
while (inFile.getChar(&c) && outFile.putChar(c));
if (outFile.getZipError() != UNZ_OK)
{
qWarning() << outFile.getZipError();
return false;
}
outFile.close();
if (outFile.getZipError() != UNZ_OK)
{
qWarning() << outFile.getZipError();
return false;
}
inFile.close();
}
mChanged = false;
return true;
}
bool CZipper::zip_directory (const QString &archpath, const QString &dir2pack)
{
QString archname = qstring_get_last_after (dir2pack, "/");
QString zipname (archpath); //zip name has a full path ending with .zip
zipname.append ("/").append (archname).append (".zip");
QuaZip zip (zipname, settings->value ("zip_charset_out", "UTF-8").toString().trimmed());
if (! zip.open (QuaZip::mdCreate))
return false;
QDir dir (dir2pack);
QFileInfoList files = dir.entryInfoList();
QFile inFile;
QuaZipFile outFile(&zip);
foreach (QFileInfo file, files)
{
if (! file.isFile())
continue;
inFile.setFileName (file.absoluteFilePath());
if (! inFile.open (QIODevice::ReadOnly))
return false;
QString outfname (archname);
outfname.append ("/").append (file.fileName());
if (! outFile.open (QIODevice::WriteOnly, QuaZipNewInfo (outfname, inFile.fileName())))
return false;
QByteArray ba = inFile.readAll();
outFile.write (ba);
outFile.close();
if (outFile.getZipError() != UNZ_OK)
return false;
inFile.close();
emit new_iteration (file);
}
zip.close();
if (zip.getZipError() != 0)
return false;
return true;
}
/**OK
* Comprime la cartella dir nel file fileCompressed, se recursive e true allora
* comprime anche le sotto cartelle. I nomi dei file preceduti dal path creato
* togliendo il pat della cartella origDir al path della cartella dir.
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
* di creare.
*
* La funzione fallisce se:
* * zip==NULL;
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
* * la cartella dir non esiste;
* * la compressione di una sotto cartella fallisce (1);
* * la compressione di un file fallisce;
* (1) La funzione si richiama in maniera ricorsiva per comprimere le sotto cartelle
* dunque gli errori di compressione di una sotto cartella sono gli stessi di questa
* funzione.
*/
bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, const int LEVEL, bool recursive) {
// zip: oggetto dove aggiungere il file
// dir: cartella reale corrente
// origDir: cartella reale originale
// (path(dir)-path(origDir)) = path interno all'oggetto zip
// Controllo l'apertura dello zip
if (!zip) return false;
if (zip->getMode()!=QuaZip::mdCreate &&
zip->getMode()!=QuaZip::mdAppend &&
zip->getMode()!=QuaZip::mdAdd) return false;
// Controllo la cartella
QDir directory(dir);
if (!directory.exists()) return false;
QDir origDirectory(origDir);
if (dir != origDir) {
QuaZipFile dirZipFile(zip);
const int METHOD = LEVEL != 0 ? Z_DEFLATED : Z_BINARY;
if (!dirZipFile.open(QIODevice::WriteOnly,
QuaZipNewInfo(origDirectory.relativeFilePath(dir) + "/", dir), NULL, 0, METHOD, LEVEL)) {
return false;
}
dirZipFile.close();
}
// Se comprimo anche le sotto cartelle
if (recursive) {
// Per ogni sotto cartella
QFileInfoList files = directory.entryInfoList(QDir::AllDirs|QDir::NoDotAndDotDot);
Q_FOREACH (QFileInfo file, files) {
// Comprimo la sotto cartella
if(!compressSubDir(zip,file.absoluteFilePath(),origDir,LEVEL,recursive)) return false;
}
}
// Per ogni file nella cartella
QFileInfoList files = directory.entryInfoList(QDir::Files);
Q_FOREACH (QFileInfo file, files) {
// Se non e un file o e il file compresso che sto creando
if(!file.isFile()||file.absoluteFilePath()==zip->getZipName()) continue;
// Creo il nome relativo da usare all'interno del file compresso
QString filename = origDirectory.relativeFilePath(file.absoluteFilePath());
// Comprimo il file
if (!compressFile(zip,file.absoluteFilePath(),filename,LEVEL)) return false;
}
return true;
}
void TestQuaZipFile::zipUnzip()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QByteArray, fileNameCodec);
QFETCH(QByteArray, password);
QFETCH(bool, zip64);
QFile testFile(zipName);
if (testFile.exists()) {
if (!testFile.remove()) {
QFAIL("Couldn't remove existing archive to create a new one");
}
}
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files for zipping");
}
QuaZip testZip(&testFile);
testZip.setZip64Enabled(zip64);
if (!fileNameCodec.isEmpty())
testZip.setFileNameCodec(fileNameCodec);
QVERIFY(testZip.open(QuaZip::mdCreate));
QString comment = "Test comment";
testZip.setComment(comment);
foreach (QString fileName, fileNames) {
QFile inFile("tmp/" + fileName);
if (!inFile.open(QIODevice::ReadOnly)) {
qDebug("File name: %s", fileName.toUtf8().constData());
QFAIL("Couldn't open input file");
}
QuaZipFile outFile(&testZip);
QVERIFY(outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileName,
inFile.fileName()),
password.isEmpty() ? NULL : password.constData()));
for (qint64 pos = 0, len = inFile.size(); pos < len; ) {
char buf[4096];
qint64 readSize = qMin(static_cast<qint64>(4096), len - pos);
qint64 l;
if ((l = inFile.read(buf, readSize)) != readSize) {
qDebug("Reading %ld bytes from %s at %ld returned %ld",
static_cast<long>(readSize),
fileName.toUtf8().constData(),
static_cast<long>(pos),
static_cast<long>(l));
QFAIL("Read failure");
}
QVERIFY(outFile.write(buf, readSize));
pos += readSize;
}
inFile.close();
outFile.close();
QCOMPARE(outFile.getZipError(), ZIP_OK);
}
bool KTPackageHandler::compress(QuaZip *zip, const QString &path)
{
QFile inFile;
QuaZipFile outFile(zip);
char c;
QFileInfoList files= QDir(path).entryInfoList();
foreach(QFileInfo file, files)
{
QString filePath = path+"/"+file.fileName();
if ( file.fileName().startsWith(".") ) continue;
if ( file.isDir() )
{
compress(zip, file.path()+"/"+file.fileName());
continue;
}
inFile.setFileName(filePath);
if(!inFile.open(QIODevice::ReadOnly))
{
dError() << "Error opening file " << inFile.fileName() << " : " << inFile.errorString();
return false;
}
if(!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(stripRepositoryFromPath(filePath), stripRepositoryFromPath(filePath) )))
{
return false;
}
while(inFile.getChar(&c) && outFile.putChar(c));
if(outFile.getZipError()!=UNZ_OK)
{
return false;
}
outFile.close();
if(outFile.getZipError()!=UNZ_OK)
{
return false;
}
inFile.close();
}
bool CZipper::pack_prepared()
{
if (archive_fullpath.isEmpty())
return false;
QString zipname (archive_fullpath);
QuaZip zip (zipname, settings->value ("zip_charset_out", "UTF-8").toString().trimmed());
if (! zip.open (QuaZip::mdCreate))
return false;
QFile inFile;
QuaZipFile outFile (&zip);
foreach (QString fi, files_list)
{
QFileInfo file (fi);
if (! file.isFile())
continue;
inFile.setFileName (file.absoluteFilePath());
if (! inFile.open (QIODevice::ReadOnly))
return false;
QString outfname (archive_name);
outfname.append ("/").append (file.fileName());
if (! outFile.open (QIODevice::WriteOnly, QuaZipNewInfo (outfname, inFile.fileName())))
return false;
QByteArray ba = inFile.readAll();
outFile.write (ba);
outFile.close();
if (outFile.getZipError() != UNZ_OK)
return false;
inFile.close();
emit new_iteration (file);
}
void ProjectExporter::writeZip(QString path, QString base)
{
if(base == "")
base = path;
if(path == "")
{
addError(tr("Couldn't locate project directory"));
return;
}
QDir dir(path);
/* First adding any files in the directory */
QFileInfoList files = dir.entryInfoList(QDir::Files);
for(int i = 0; i < files.count(); i++)
{
QFileInfo current = files[i];
QString newPath = current.absoluteFilePath().replace(base, "/.rockbox");
QuaZipFile fout(&zipFile);
QFile fin(current.absoluteFilePath());
fin.open(QFile::ReadOnly | QFile::Text);
fout.open(QIODevice::WriteOnly,
QuaZipNewInfo(newPath, current.absoluteFilePath()));
fout.write(fin.readAll());
fin.close();
fout.close();
}
/* Then recursively adding any directories */
QFileInfoList dirs = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
for(int i = 0; i < dirs.count(); i++)
{
QFileInfo current = dirs[i];
writeZip(current.absoluteFilePath(), base);
}
}
void QZip::zipDir(QuaZipFile &outFile,const QString &zipPath,const QString &zipTPath){
QDir dir(zipPath);
dir.setCurrent(zipPath);
QFileInfoList files=dir.entryInfoList();
QFile inFile;
char c;
foreach(QFileInfo file, files) {
if(file.isDir()){
if(!file.absoluteFilePath().endsWith(".")){
QString zipDirecName = zipTPath==""?file.fileName():zipTPath+"\\"+file.fileName();
zipDir(outFile,file.absoluteFilePath(),zipDirecName);
dir.setCurrent(zipPath);
}
continue;//
}
inFile.setFileName(file.fileName());
if(!inFile.open(QIODevice::ReadOnly)) {
qWarning("testCreate(): inFile.open(): %s", inFile.errorString().toLocal8Bit().constData());
return;
}
QString zipDirName = zipTPath==""?inFile.fileName():zipTPath+"\\"+inFile.fileName();
if(!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(zipDirName, inFile.fileName()))) {
qWarning("testCreate(): outFile.open(): %d", outFile.getZipError());
return;
}
while(inFile.getChar(&c)&&outFile.putChar(c));
if(outFile.getZipError()!=UNZ_OK) {
qWarning("testCreate(): outFile.putChar(): %d", outFile.getZipError());
return;
}
outFile.close();
if(outFile.getZipError()!=UNZ_OK) {
qWarning("testCreate(): outFile.close(): %d", outFile.getZipError());
return;
}
inFile.close();
}
}
bool compressDir(const QString& sourceDir, const QString& subDir, const QString& targetFile, bool isUtf8)
{
QStringList compressFileList;
compressFileList.push_back(subDir);
QString sourceFolderPath = sourceDir;
if (!sourceFolderPath.endsWith("/"))
sourceFolderPath.append("/");
QStringList findFilesList;
QDir wDir(sourceFolderPath + subDir);
findFoldersAndFiles(wDir, findFilesList);
wDir.setPath(sourceDir);
for (int i = 0; i < findFilesList.size(); ++i)
{
QString rPath = wDir.relativeFilePath(findFilesList.at(i));
compressFileList.push_back(rPath);
}
if (!isUtf8)
QTextCodec::setCodecForLocale(QTextCodec::codecForName("GBK"));
QuaZip zip(targetFile);
//zip.setFileNameCodec("GBK");
if (!zip.open(QuaZip::mdCreate))
{
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
return false;
}
QuaZipFile outFile(&zip);
for (int i = 0; i < compressFileList.size(); i++)
{
QString sourceFolderPath = compressFileList.at(i);
QFileInfo fileInfo(wDir.absoluteFilePath(compressFileList.at(i)));
if (fileInfo.isDir())
{
if (!sourceFolderPath.endsWith("/"))
sourceFolderPath.append("/");
if (!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(sourceFolderPath, fileInfo.absoluteFilePath())))
{
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
return false;
}
outFile.close();
}
else if (fileInfo.isFile())
{
QFile inFile(fileInfo.absoluteFilePath());
if (!inFile.open(QIODevice::ReadOnly))
{
zip.close();
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
return false;
}
if (!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(sourceFolderPath, fileInfo.absoluteFilePath())))
{
inFile.close();
zip.close();
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
return false;
}
QByteArray buffer;
int chunksize = 1024;
buffer = inFile.read(chunksize);
while (!buffer.isEmpty())
{
outFile.write(buffer);
buffer = inFile.read(chunksize);
}
outFile.close();
inFile.close();
}
}
zip.close();
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
if (zip.getZipError())
return false;
return true;
}
void Parse::postPML( QString type, QString title, QString description, QByteArray pml_file, QString keywords )
{
qWarning()<<"postPML, ready:"<<isReady();
while (!isReady()) { }
setEndPoint("classes/Pml");
QJsonObject obj;
QJsonObject owner{
{"__type","Pointer"},
{"className","_User"},
{"objectId",userId}
};
obj.insert("owner",owner);
obj.insert("type",type);
QByteArray zipdata;
if (type=="pml") {
QBuffer buf(&zipdata);
QuaZip zip(&buf);
zip.open(QuaZip::mdCreate);
QuaZipFile file(&zip);
file.open(QIODevice::WriteOnly, QuaZipNewInfo("session.pml"));
file.write(pml_file);
file.close();
zip.close();
}
if (type=="psk") {
zipdata = pml_file;
QBuffer buf(&zipdata);
QuaZip zip(&buf);
zip.open(QuaZip::mdUnzip);
// check Package.json exist
if (!zip.setCurrentFile("package.json")) {
// ERROR
qWarning()<<"ERROR - package.json missing";
ask(mainwindow,"Invalid skin package.\n'package.json' file missing",1);
return;
}
// open Package.json
QuaZipFile file(&zip);
file.open(QIODevice::ReadOnly);
QByteArray _ba = file.readAll();
QJsonDocument json = QJsonDocument::fromJson(_ba);
if (json.object().value("model").isUndefined()) {
// ERROR
qWarning()<<"ERROR model empty";
ask(mainwindow,"Invalid skin package.\nModel not defined in package.json file",1);
return;
}
QString _model = json.object().value("model").toString();
QString _title = json.object().value("title").toString();
QString _description = json.object().value("description").toString();
QString _author = json.object().value("author").toString();
QString _email = json.object().value("email").toString();
QString _url = json.object().value("url").toString();
title = _title;
description = _description + "\r\n" +
"Author : "+_author + "\r\n" +
"Email : "+_email + "\r\n" +
"Url : "+_url;
// "Email :<a href=\"mailto://"+_email +"\">"+_email+"</a>\r\n" +
// "Url :<a href=\""+_url +"\">"+_url+"</a>";
file.close();
}
obj.insert("data",QString(zipdata.toBase64()));
QJsonObject acl{
{ userId, QJsonObject{
{"read", true},
{"write", true}
}
}
};
obj.insert("ACL",acl);
obj.insert("title",title);
obj.insert("description",description);
obj.insert("keywords",keywords);
// parse pml to generate objetcs list
// This should be moved to parse.Cloud
// DONE
// QDomDocument document;
// document.setContent( pml_file );
// QDomElement documentElement = document.documentElement();
// QDomNodeList elements = documentElement.elementsByTagName( "object" );
// QString keywords = "|";
// for (int i=0; i<elements.size();i++ )
// {
// QDomElement object = elements.at(i).toElement();
// QString name = object.attribute("name");
// keywords.append( name + QString("|") );
// qWarning()<<keywords;
// }
// obj.insert("keywords",keywords);
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
// qWarning()<<"disconnect"<<m_conn;
disconnect(m_conn);
if ( getHttpCode() == 201 ){
qWarning()<<"postPML Result:"<<json.object();
emit pmlUploaded();
}
} );
qWarning()<<"connect"<<m_conn;
initHeaders();
request( BaaS::POST, QJsonDocument(obj).toJson());
}
bool LocalZipTask::zip()
{
const QString source = get_source(), destination = get_destination();
// 在临时文件区新建zip文件
QTemporaryFile tmp("XXXXXX.zip");
tmp.open();
QuaZip zip(tmp.fileName());
zip.setFileNameCodec("UTF8");
zip.open(QuaZip::mdCreate);
// 添加注释
zip.setComment("Create automatically by organic/syncer.");
// 添加文件
IgnoreList ignore_list;
stack<QString> relatives;
relatives.push("");
while (!relatives.empty())
{
const QString r = relatives.top();
relatives.pop();
// 执行栈里的特殊操作
if (r == SPECIAL_ID)
{
ignore_list.pop_config();
continue;
}
update_state(r + " ...");
// 处理中断操作
if (RUNNING != get_state())
{
set_msg("Cancled.");
return false;
}
// 处理忽略列表
const QString p = path_join(source, r);
if (ignore_list.is_ignored(r))
{
_compressed_files += count_files(p);
continue;
}
if (!QFileInfo(p).isDir())
{
QFile in(p);
if (!in.open(QIODevice::ReadOnly))
{
set_msg("Failed to open file: " + p);
set_has_error(true);
return false;
}
QuaZipFile out(&zip);
const QString rr = (r.isEmpty() ? QFileInfo(source).fileName() : r);
out.open(QIODevice::WriteOnly, QuaZipNewInfo(rr, p));
const qint64 BUF_LEN = 64 * 1024;
char buf[BUF_LEN];
for (qint64 pos = 0, len = in.size(); pos < len; )
{
qint64 readSize = qMin(BUF_LEN, len - pos);
if (in.read(buf, readSize) != readSize)
{
set_msg("Failed to read file: " + rr);
set_has_error(true);
return false;
}
out.write(buf, readSize);
pos += readSize;
}
in.close();
out.close();
++_compressed_files;
}
else
{
// 处理忽略列表
if (QFileInfo(path_join(p, IGNORE_FILE1)).exists())
{
ignore_list.push_config(r, path_join(p, IGNORE_FILE1));
relatives.push(SPECIAL_ID);
}
else if (QFileInfo(path_join(p, IGNORE_FILE2)).exists())
{
ignore_list.push_config(r, path_join(p, IGNORE_FILE2));
relatives.push(SPECIAL_ID);
}
else if (QFileInfo(path_join(p, IGNORE_FILE3)).exists())
{
ignore_list.push_config(r, path_join(p, IGNORE_FILE3));
relatives.push(SPECIAL_ID);
}
// 遍历文件夹
QStringList children = QDir(p).entryList(QDir::Files | QDir::Dirs | QDir::AccessMask | QDir::NoDotAndDotDot);
for (size_t i = 0, size = children.size(); i < size; ++i)
{
const QString& e = children.at(i);
relatives.push(path_join(r, e));
}
}
}
zip.close();
tmp.close();
// 拷贝临时文件到目标地址
if (QFileInfo(destination).exists() && !remove_file(destination))
{
set_msg("Failed to remove old destination ZIP file.");
set_has_error(true);
return false;
}
if (!copy_file(tmp.fileName(), destination))
{
set_msg("Failed to copy tmp file to destination ZIP file.");
set_has_error(true);
return false;
}
tmp.remove();
return true;
}
