Resource Download table

SerialPrograms/Source/CommonFramework/GlobalSettingsPanel.cpp

@@ -248,6 +248,7 @@ GlobalSettings::GlobalSettings()
     PA_ADD_OPTION(TEMP_FOLDER);
     PA_ADD_OPTION(THEME);
     PA_ADD_OPTION(USE_PADDLE_OCR);
+    PA_ADD_OPTION(RESOURCE_DOWNLOAD_TABLE);
     PA_ADD_OPTION(WINDOW_SIZE);
     PA_ADD_OPTION(LOG_WINDOW_SIZE);
     PA_ADD_OPTION(LOG_WINDOW_STARTUP);

SerialPrograms/Source/CommonFramework/GlobalSettingsPanel.h

@@ -17,6 +17,7 @@
 #include "Common/Cpp/Options/StringOption.h"
 #include "CommonFramework/Panels/SettingsPanel.h"
 #include "CommonFramework/Panels/PanelTools.h"
+#include "CommonFramework/ResourceDownload/ResourceDownloadTable.h"
 
 //#include <iostream>
 //using std::cout;
@@ -124,6 +125,7 @@ class GlobalSettings : public BatchOption, private ConfigOption::Listener, priva
 
     Pimpl<ThemeSelectorOption> THEME;
     BooleanCheckBoxOption USE_PADDLE_OCR;
+    ResourceDownloadTable RESOURCE_DOWNLOAD_TABLE;
     Pimpl<ResolutionOption> WINDOW_SIZE;
     Pimpl<ResolutionOption> LOG_WINDOW_SIZE;
     BooleanCheckBoxOption LOG_WINDOW_STARTUP;

SerialPrograms/Source/CommonFramework/ResourceDownload/ResourceDownloadHelpers.cpp

@@ -0,0 +1,141 @@
+/*  Resource Download Helpers
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "CommonFramework/Globals.h"
+#include "CommonFramework/Logging/Logger.h"
+// #include "CommonFramework/Tools/GlobalThreadPools.h"
+#include "CommonFramework/Tools/FileDownloader.h"
+#include "CommonFramework/Exceptions/OperationFailedException.h"
+#include "Common/Cpp/Json/JsonArray.h"
+#include "Common/Cpp/Json/JsonObject.h"
+#include "Common/Cpp/Filesystem.h"
+#include "ResourceDownloadHelpers.h"
+
+// #include <filesystem>
+// #include <thread>
+// #include <unordered_set>
+
+#include <iostream>
+using std::cout;
+using std::endl;
+
+namespace PokemonAutomation{
+
+
+ResourceType get_resource_type_from_string(std::string type){
+    if (type == "ZippedFolder"){
+        return ResourceType::ZIP_FILE;
+    }else{
+        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "get_resource_type_from_string: Unknown string.");
+    }
+
+}
+
+std::vector<DownloadedResourceMetadata> deserialize_resource_list_json(const JsonValue& json){
+    std::vector<DownloadedResourceMetadata> resources;    
+
+    try{
+        const JsonObject& obj = json.to_object_throw();
+        const JsonArray& resource_list = obj.get_array_throw("resourceList");
+        for (const JsonValue& resource_val : resource_list){
+            const JsonObject& resource_obj = resource_val.to_object_throw();
+
+            std::string resource_name = resource_obj.get_string_throw("resourceName");
+            std::optional<uint16_t> version_num = (uint16_t)resource_obj.get_integer_throw("version");
+            ResourceType resource_type = get_resource_type_from_string(resource_obj.get_string_throw("Type"));
+            size_t compressed_bytes = (size_t)resource_obj.get_integer_throw("CompressedBytes");
+            size_t decompressed_bytes = (size_t)resource_obj.get_integer_throw("DecompressedBytes");
+            std::string url = resource_obj.get_string_throw("URL");
+            std::string sha_256 = resource_obj.get_string_throw("SHA_256");
+
+            DownloadedResourceMetadata resource = {
+                resource_name,
+                version_num,
+                resource_type,
+                compressed_bytes,
+                decompressed_bytes,
+                url,
+                sha_256
+            };
+
+            resources.emplace_back(std::move(resource));
+
+        }
+
+    }catch (ParseException&){
+        std::cerr << "JSON parsing error. Given JSON file doesn't match the expected format." << endl;
+        // throw ParseException("JSON parsing error. Given JSON file doesn't match the expected format.");
+        return std::vector<DownloadedResourceMetadata>();
+    }
+
+    return resources;
+}
+
+
+const std::vector<DownloadedResourceMetadata>& local_resource_download_list(){
+    // cout << "local_resource_download_list" << endl;
+    static std::vector<DownloadedResourceMetadata> local_resources = deserialize_resource_list_json(load_json_file(RESOURCE_PATH() + "ResourceDownloadList.json"));
+
+    return local_resources;
+}
+
+
+JsonValue fetch_resource_download_list_json_from_remote(){
+    Logger& logger = global_logger_tagged();
+    JsonValue json = 
+        FileDownloader::download_json_file(
+            logger,
+            "https://raw.githubusercontent.com/jw098/Packages/refs/heads/download/Resources/ResourceDownloadList.json"
+        );
+
+    return json;
+}
+
+const JsonValue& remote_resource_download_list_json(){
+    static const JsonValue json = fetch_resource_download_list_json_from_remote();
+
+    return json;
+}
+
+const std::vector<DownloadedResourceMetadata>& remote_resource_download_list(){
+    // cout << "remote_resource_download_list" << endl;
+    static std::vector<DownloadedResourceMetadata> remote_resources = deserialize_resource_list_json(remote_resource_download_list_json());
+
+    return remote_resources;
+}
+
+std::optional<uint16_t> get_resource_version_num(Filesystem::Path folder_path){
+    try{
+        std::string file_name = folder_path.string() + "/version.json";
+        const JsonValue& json = load_json_file(file_name);
+
+        const JsonObject& obj = json.to_object_throw();
+        uint16_t version_num = (uint16_t)obj.get_integer_throw("version");
+        return version_num;
+    }catch(...){
+        std::cerr << "Unable to determine the version number from version.json." << endl;
+        return std::nullopt;
+    }
+
+}
+
+ResourceVersionStatus get_version_status(uint16_t expected_version_num, std::optional<uint16_t> current_version_num){
+    if (!current_version_num.has_value()){
+        return ResourceVersionStatus::NOT_APPLICABLE;
+    }
+
+    if (current_version_num < expected_version_num){
+        return ResourceVersionStatus::OUTDATED;
+    }else if (current_version_num == expected_version_num){
+        return ResourceVersionStatus::CURRENT;
+    }else{ // current > expected
+        return ResourceVersionStatus::FUTURE_VERSION;
+    }
+}
+
+
+
+}

SerialPrograms/Source/CommonFramework/ResourceDownload/ResourceDownloadHelpers.h

@@ -0,0 +1,61 @@
+/*  Resource Download Helpers
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_ResourceDownloadHelpers_H
+#define PokemonAutomation_ResourceDownloadHelpers_H
+
+#include <string>
+#include <optional>
+
+
+namespace PokemonAutomation{
+
+namespace Filesystem{
+    class Path;
+}
+
+
+enum class ResourceType{
+    ZIP_FILE,
+};
+
+struct DownloadedResourceMetadata{
+    std::string resource_name;
+    std::optional<uint16_t> version_num;
+    ResourceType resource_type;
+    size_t size_compressed_bytes;
+    size_t size_decompressed_bytes;
+    std::string url;
+    std::string sha_256;
+};
+
+enum class ResourceVersionStatus{
+    CURRENT,
+    OUTDATED, // still used, but newer version available
+    FUTURE_VERSION, // current version number is greater than the expected version number
+    NOT_APPLICABLE, // resource not downloaded locally, so can't get its version
+    // RETIRED, // no longer used
+    // BLANK, // not yet fetched version info from remote
+};
+
+enum class RemoteMetadataStatus{
+    UNINITIALIZED,
+    NOT_AVAILABLE,
+    AVAILABLE,
+};
+struct RemoteMetadata {
+    RemoteMetadataStatus status = RemoteMetadataStatus::UNINITIALIZED;
+    DownloadedResourceMetadata metadata;
+};
+
+
+const std::vector<DownloadedResourceMetadata>& local_resource_download_list();
+const std::vector<DownloadedResourceMetadata>& remote_resource_download_list();
+std::optional<uint16_t> get_resource_version_num(Filesystem::Path folder_path);
+ResourceVersionStatus get_version_status(uint16_t expected_version_num, std::optional<uint16_t> current_version_num);
+
+}
+#endif

SerialPrograms/Source/CommonFramework/ResourceDownload/ResourceDownloadOptions.cpp

@@ -0,0 +1,46 @@
+/*  Resource Download Row
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "ResourceDownloadRow.h"
+#include "ResourceDownloadOptions.h"
+
+// #include <thread>
+
+#include <iostream>
+using std::cout;
+using std::endl;
+
+namespace PokemonAutomation{
+
+// ResourceDownloadButton::~ResourceDownloadButton(){}
+ResourceDownloadButton::ResourceDownloadButton(ResourceDownloadRow& p_row)
+    : ConfigOptionImpl<ResourceDownloadButton>(LockMode::UNLOCK_WHILE_RUNNING)
+    , row(p_row)
+    , m_enabled(true)
+{}
+
+
+ResourceDeleteButton::ResourceDeleteButton(ResourceDownloadRow& p_row)
+    : ConfigOptionImpl<ResourceDeleteButton>(LockMode::UNLOCK_WHILE_RUNNING)
+    , row(p_row)
+    , m_enabled(true)
+{}
+
+
+ResourceCancelButton::ResourceCancelButton(ResourceDownloadRow& p_row)
+    : ConfigOptionImpl<ResourceCancelButton>(LockMode::UNLOCK_WHILE_RUNNING)
+    , row(p_row)
+    , m_enabled(true)
+{}
+
+
+ResourceProgressBar::ResourceProgressBar(ResourceDownloadRow& p_row)
+    : ConfigOptionImpl<ResourceProgressBar>(LockMode::UNLOCK_WHILE_RUNNING)
+    , row(p_row)
+{}
+
+
+}

SerialPrograms/Source/CommonFramework/ResourceDownload/ResourceDownloadOptions.h

@@ -0,0 +1,89 @@
+/*  Resource Download Row
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_ResourceDownloadOptions_H
+#define PokemonAutomation_ResourceDownloadOptions_H
+
+#include <QObject>
+// #include "Common/Cpp/Containers/Pimpl.h"
+// #include "Common/Cpp/Concurrency/AsyncTask.h"
+// #include "Common/Cpp/Options/StaticTableOption.h"
+// #include "ResourceDownloadHelpers.h"
+
+
+namespace PokemonAutomation{
+
+class ResourceDownloadRow;
+
+
+class ResourceDownloadButton : public QObject, public ConfigOptionImpl<ResourceDownloadButton>{
+    Q_OBJECT
+public:
+    // ~ResourceDownloadButton();
+    ResourceDownloadButton(ResourceDownloadRow& p_row);
+
+public:
+    inline bool get_enabled(){ return m_enabled; }
+    inline void set_enabled(bool enabled){ 
+        m_enabled = enabled; 
+    }
+
+public:
+    ResourceDownloadRow& row;
+
+private:
+    bool m_enabled;  // button should be blocked during an active task. m_enabled is false when blocked
+
+
+
+
+};
+
+class ResourceDeleteButton : public ConfigOptionImpl<ResourceDeleteButton>{
+public:
+    ResourceDeleteButton(ResourceDownloadRow& p_row);
+
+public:
+    inline bool get_enabled(){ return m_enabled; }
+    inline void set_enabled(bool enabled){ 
+        m_enabled = enabled; 
+    }
+
+public:
+    ResourceDownloadRow& row;
+
+private:
+    bool m_enabled;
+};
+
+class ResourceCancelButton : public ConfigOptionImpl<ResourceCancelButton>{
+public:
+    ResourceCancelButton(ResourceDownloadRow& p_row);
+
+public:
+    inline bool get_enabled(){ return m_enabled; }
+    inline void set_enabled(bool enabled){ 
+        m_enabled = enabled; 
+    }
+
+public:
+    ResourceDownloadRow& row;
+
+private:
+    bool m_enabled;    
+};
+
+class ResourceProgressBar : public ConfigOptionImpl<ResourceProgressBar>{
+public:
+    ResourceProgressBar(ResourceDownloadRow& p_row);
+
+    ResourceDownloadRow& row;
+};
+
+
+
+}
+#endif