initial casefile -noinputs

Author: RuiZhang-kwf8

src/gui/mainWindow.cpp

@@ -30,8 +30,8 @@
 #include "mainWindow.h"
 #include <vector>
 #include <string>
-#include <iostream>
 #include <fstream>
+#include <iostream>
 #include "cpl_vsi.h"
 #include "cpl_error.h"
 #include "cpl_string.h"
@@ -1669,10 +1669,13 @@ void mainWindow::openOutputPath()
 
 int mainWindow::solve()
 {
+  CaseFile casefile;  
+      std::string getdir = tree->solve->outputDirectory().toStdString();
+      std::string inputpath = getdir + "/config.cfg";
+   
+      std::ofstream outFile(inputpath);
 
- std::ofstream outFile("config.cfg");
 
-    // Check if the file was opened successfully
     if (!outFile) {
         std::cerr << "Error: Could not open the file for writing!" << std::endl;
         return 1;
@@ -1688,6 +1691,8 @@ int mainWindow::solve()
     //dem file
     std::string demFile = inputFileName.toStdString();
         outFile << "--elevation_file " + demFile;
+  
+
 
 
 #ifdef NINJAFOAM
@@ -1707,7 +1712,6 @@ int mainWindow::solve()
         vegetation = WindNinjaInputs::trees;
       outFile << "--vegetation " + vegetation;
     }
-
     //mesh
     int meshIndex = tree->surface->meshResComboBox->currentIndex();
     Mesh::eMeshChoice meshChoice;
@@ -1728,17 +1732,21 @@ int mainWindow::solve()
     else
         meshUnits = lengthUnits::meters;
     }
-        outFile << "--meshchoice " + meshChoice;
-         outFile << "--mesh_resolution " + std::to_string(meshRes);
-
-         outFile << "--units_mesh_resolution " + meshUnits;
-         
-          std::string zipFilePath = "example.zip";
 
-         outFile.close(); 
+        ///outFile << "--meshchoice " + meshChoice;f
+       // outFile << "--mesh_resolution " + std::to_string(meshRes);
 
-         addFileToZip(zipFilePath, "config.cfg", "config.cfg"); 
-         
+        //outFile << "--units_mesh_resolution " + meshUnits;
+      
+        std::string getfileName = casefile.parse("file", inputFileName.toStdString()); 
+        std::string zipFilePath = getdir + "/" + getfileName + "-" + casefile.getTime() + ".ninja";
+          casefile.setdir(getdir); 
+        casefile.setzip(zipFilePath); 
+        outFile.close(); 
+        
+        casefile.addFileToZip(zipFilePath, getdir, getfileName, inputFileName.toStdString()); 
+        casefile.addFileToZip(zipFilePath, getdir, "config.cfg", inputpath); 
+        casefile.deleteFileFromPath(getdir, "config.cfg"); 
 
 #ifdef NINJAFOAM
     WindNinjaInputs::eNinjafoamMeshChoice ninjafoamMeshChoice;
@@ -1782,17 +1790,17 @@ int mainWindow::solve()
     std::string timeZone = temp.toString().toStdString();
 
 
-    outFile << "--time_zone " + timeZone;
+    //outFile << "--time_zone " + timeZone;
 
     //diurnal
     bool useDiurnal = tree->diurnal->diurnalGroupBox->isChecked();
 
-    outFile << "--diurnal_winds " + useDiurnal;
+   // outFile << "--diurnal_winds " + useDiurnal;
 
     //stability
     bool useStability = tree->stability->stabilityGroupBox->isChecked();
 
-    outFile << "--non_neutral_stability " + useStability;
+   // outFile << "--non_neutral_stability " + useStability;
     //initialization method
     WindNinjaInputs::eInitializationMethod initMethod;
     if( tree->wind->windGroupBox->isChecked() )

src/gui/mainWindow.h

@@ -185,7 +185,6 @@ class mainWindow : public QMainWindow
   bool getLatLon();
 
   void test();
-  void addFileToZip(const std::string& zipFilePath, const std::string& fileToAdd, const std::string& zipEntryName);
   int solve();
   void cancelSolve();
   int countRuns();

src/ninja/casefile.cpp

@@ -1,69 +1,219 @@
 #include "casefile.h"
 
-class CaseFile {
-public:
-    void addFileToZip(const std::string& zipFilePath, const std::string& fileToAdd, const std::string& zipEntryName) {
-        VSILFILE *fin;
-        fin = VSIFOpenL(fileToAdd.c_str(), "r");
-        if (fin == NULL) {
-            std::cerr << "Failed to open file: " << fileToAdd << std::endl;
-            return;
-        }
+std::string CaseFile::zipfilename = "";
+std::string CaseFile::directory = "";
 
-        vsi_l_offset offset;
-        VSIFSeekL(fin, 0, SEEK_END);
-        offset = VSIFTellL(fin);
-        VSIRewindL(fin);
+std::mutex zipMutex;
 
-        char *data = (char*)CPLMalloc(offset * sizeof(char));
-        if (data == NULL) {
-            std::cerr << "Failed to allocate memory for file data." << std::endl;
-            VSIFCloseL(fin);
-            return;
-        }
-        if (VSIFReadL(data, 1, offset, fin) != offset) {
-            std::cerr << "Failed to read file contents: " << fileToAdd << std::endl;
-            CPLFree(data);
-            VSIFCloseL(fin);
-            return;
+CaseFile::CaseFile() {
+}
+
+bool CaseFile::isCfgFile(const std::string& filePath) {
+    const std::string extension = ".cfg";
+    if (filePath.length() >= extension.length()) {
+        std::string fileExtension = filePath.substr(filePath.length() - extension.length());
+        return fileExtension == extension;
+    } else {
+        return false;
+    }
+}
+
+bool CaseFile::isVTKFile(const std::string& filePath) {
+    const std::string extension = ".vtk";
+    if (filePath.length() >= extension.length()) {
+        std::string fileExtension = filePath.substr(filePath.length() - extension.length());
+        return fileExtension == extension;
+    } else {
+        return false;
+    }
+}
+
+bool CaseFile::lookforzip(const std::string& zipFilePath, const std::string& directory) {
+    char** papszDir = VSIReadDir(directory.c_str());
+    if (papszDir != nullptr) {
+        
+    for (int i = 0; papszDir[i] != nullptr; i++) {
+        std::string entry = papszDir[i];
+
+        if (entry == "." || entry == "..") {
+            continue;
         }
-        VSIFCloseL(fin);
 
-        void* zipHandle = CPLCreateZip(zipFilePath.c_str(), NULL);
-        if (zipHandle == NULL) {
-            std::cerr << "Failed to create or open zip file: " << zipFilePath << std::endl;
-            CPLFree(data);
-            return;
+        if (entry == parse("file", getzip())) {
+            return true;
         }
+    }
+
+    CSLDestroy(papszDir);
+    }
+    return false;
+}
 
-        if (CPLCreateFileInZip(zipHandle, zipEntryName.c_str(), NULL) != CE_None) {
-            std::cerr << "Failed to create file in zip: " << zipEntryName << std::endl;
-            CPLFree(data);
-            CPLCloseZip(zipHandle);
+bool CaseFile::lookfordate(const std::string& date) {
+    return false; 
+}
+
+
+std::string CaseFile::parse(const std::string& type, const std::string& path) {
+            size_t found = path.find_last_of("/");
+            if (found != std::string::npos) {
+                if (strcmp(type.c_str(), "directory") == 0) {
+                    return path.substr(0, found); 
+
+                }
+                else 
+                if (strcmp(type.c_str(), "file") == 0) {
+                    return path.substr(found + 1); // Extract substring after the last '/'
+                }
+            }
+}
+
+
+void CaseFile::addFileToZip(const std::string& zipFilePath, const std::string& dirPath, const std::string& fileToAdd, const std::string& usrlocalpath) {
+    // Enable CPL logging
+    std::lock_guard<std::mutex> lock(zipMutex); // for multithreading issue?? not sure I think i busted it
+    CPLSetConfigOption("CPL_DEBUG", "ON");
+
+    std::cout << "ZIP File Path: " << zipFilePath << std::endl;
+    std::cout << "Directory Path: " << dirPath << std::endl;
+    std::cout << "File to Add Path: " << usrlocalpath << std::endl;
+    std::cout << "File to Add: " << fileToAdd << std::endl;
+
+    bool foundzip = lookforzip(zipFilePath, dirPath);
+    std::cout << "Found ZIP: " << foundzip << std::endl;
+
+    if (foundzip) {
+        std::ifstream infile(zipFilePath);
+        if (!infile.good()) {
+            std::cerr << "ZIP file does not exist: " << zipFilePath << std::endl;
             return;
         }
+    }
 
-        if (CPLWriteFileInZip(zipHandle, data, static_cast<int>(offset)) != CE_None) {
-            std::cerr << "Failed to write data to file in zip: " << zipEntryName << std::endl;
-        }
+    zipFile zip;
+    if (!foundzip) {
+        zip = cpl_zipOpen(zipFilePath.c_str(), APPEND_STATUS_CREATE);
+        std::cout << "Creating new ZIP file: " << zipFilePath << std::endl;
+    } else {
+        zip = cpl_zipOpen(zipFilePath.c_str(), APPEND_STATUS_ADDINZIP);
+        std::cout << "Appending to existing ZIP file: " << zipFilePath << std::endl;
+    }
 
-        if (CPLCloseFileInZip(zipHandle) != CE_None) {
-            std::cerr << "Failed to close file in zip: " << zipEntryName << std::endl;
-        }
+    if (zip == NULL) {
+        std::cerr << "Failed to open ZIP file: " << zipFilePath << std::endl;
+        CPLError(CE_Failure, CPLE_OpenFailed, "Failed to open ZIP file %s", zipFilePath.c_str());
+        const char* errMsg = CPLGetLastErrorMsg();
+        std::cerr << "GDAL Error: " << errMsg << std::endl;
+        return;
+    }
 
-        CPLCloseZip(zipHandle);
+    zip_fileinfo zi = {0};
+    if (cpl_zipOpenNewFileInZip(zip, fileToAdd.c_str(), &zi, nullptr, 0, nullptr, 0, nullptr, Z_DEFLATED, Z_DEFAULT_COMPRESSION) != ZIP_OK) {
+        std::cerr << "Could not open new file in ZIP: " << fileToAdd << std::endl;
+        CPLError(CE_Failure, CPLE_FileIO, "Could not open new file in ZIP %s", fileToAdd.c_str());
+        cpl_zipClose(zip, nullptr);
+        return;
+    }
+
+    VSILFILE *file = VSIFOpenL(usrlocalpath.c_str(), "rb");
+    if (file == nullptr) {
+        std::cerr << "Could not open file for reading with VSIL: " << usrlocalpath << std::endl;
+        CPLError(CE_Failure, CPLE_FileIO, "Could not open file for reading with VSIL %s", usrlocalpath.c_str());
+        cpl_zipCloseFileInZip(zip);
+        cpl_zipClose(zip, nullptr);
+        return;
+    }
+
+    VSIFSeekL(file, 0, SEEK_END);
+    vsi_l_offset fileSize = VSIFTellL(file);
+    VSIFSeekL(file, 0, SEEK_SET);
 
+    char *data = (char*)CPLMalloc(fileSize);
+    if (data == nullptr) {
+        std::cerr << "Failed to allocate memory for file data." << std::endl;
+        CPLError(CE_Failure, CPLE_OutOfMemory, "Failed to allocate memory for file data.");
+        VSIFCloseL(file);
+        cpl_zipCloseFileInZip(zip);
+        cpl_zipClose(zip, nullptr);
+        return;
+    }
+
+    if (VSIFReadL(data, 1, fileSize, file) != fileSize) {
+        std::cerr << "Failed to read file contents: " << fileToAdd << std::endl;
+        CPLError(CE_Failure, CPLE_FileIO, "Failed to read file contents %s", fileToAdd.c_str());
         CPLFree(data);
+        VSIFCloseL(file);
+        cpl_zipCloseFileInZip(zip);
+        cpl_zipClose(zip, nullptr);
+        return;
+    }
 
-        std::cout << "File added to ZIP: " << zipEntryName << std::endl;
+    if (cpl_zipWriteInFileInZip(zip, data, static_cast<unsigned int>(fileSize)) != ZIP_OK) {
+        std::cerr << "Error writing data to ZIP file: " << fileToAdd << std::endl;
+        CPLError(CE_Failure, CPLE_FileIO, "Error writing data to ZIP file %s", fileToAdd.c_str());
     }
 
-    void deleteFileFromPath(std::string directoryPath, std::string Filename) {
-        for (const auto& entry : std::filesystem::directory_iterator(directoryPath)) {
-            if (entry.is_regular_file() && entry.path().filename() == Filename) {
-                std::filesystem::remove(entry.path()); // Use std::filesystem explicitly
-                std::cout << "Deleted file: " << entry.path() << std::endl;
-            }
+    CPLFree(data);
+    VSIFCloseL(file);
+    cpl_zipCloseFileInZip(zip);
+
+    if (cpl_zipClose(zip, nullptr) != ZIP_OK) {
+        std::cerr << "Error closing ZIP file" << std::endl;
+        CPLError(CE_Failure, CPLE_FileIO, "Error closing ZIP file %s", zipFilePath.c_str());
+    }
+    std::cout << "File added to ZIP: " << fileToAdd << std::endl; 
+}
+
+
+
+std::string CaseFile::getTime() {
+            auto now = std::chrono::system_clock::now(); 
+    
+            std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
+    
+            std::tm* local_tm = std::localtime(&now_time_t);
+    
+            std::ostringstream oss;
+            oss << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S"); 
+            return oss.str();
+}
+
+
+void CaseFile::deleteFileFromPath(std::string directoryPath, std::string filename) {
+     
+    char** papszDir = VSIReadDir(directoryPath.c_str());
+    if (papszDir != nullptr) {
+        
+    for (int i = 0; papszDir[i] != nullptr; i++) {
+        std::string entry = papszDir[i];
+
+        if (entry == "." || entry == "..") {
+            continue;
+        }
+
+        std::string fullPath = directoryPath + "/" + entry;
+
+        if (entry == filename) {
+        VSIUnlink(fullPath.c_str()); 
         }
+
+    }
+
+    CSLDestroy(papszDir);
+    }
+}
+   void CaseFile::setdir(std::string dir) {
+        directory = dir; 
+    }
+
+   std::string CaseFile::getzip() {
+        return zipfilename;
+    }
+
+   void CaseFile::setzip(std::string zip) {
+        zipfilename = zip; 
+    }
+
+   std::string CaseFile::getdir() {
+        return directory;
     }
-};