Implement wifi update command

components/CommandManager/CommandManager/CommandManager.cpp

@@ -8,6 +8,8 @@ std::unique_ptr<Command> CommandManager::createCommand(CommandType type)
     return std::make_unique<PingCommand>();
   case CommandType::SET_WIFI:
     return std::make_unique<setWiFiCommand>(projectConfig);
+  case CommandType::UPDATE_WIFI:
+    return std::make_unique<updateWifiCommand>(projectConfig);
   case CommandType::DELETE_NETWORK:
     return std::make_unique<deleteWifiCommand>(projectConfig);
   default:

components/CommandManager/CommandManager/CommandSchema.hpp

@@ -17,7 +17,7 @@ public:
 class UpdateWifiPayload : public BasePayload
 {
 public:
-  std::optional<std::string> networkName;
+  std::string networkName;
   std::optional<std::string> ssid;
   std::optional<std::string> password;
   std::optional<uint8_t> channel;

components/CommandManager/CommandManager/Commands.cpp

@@ -102,3 +102,75 @@ CommandResult deleteWifiCommand::execute(std::string &jsonPayload)
   projectConfig.deleteWifiConfig(payload.value().networkName, false);
   return CommandResult::getSuccessResult("Config updated");
 }
+
+std::optional<UpdateWifiPayload> updateWifiCommand::parsePayload(std::string &jsonPayload)
+{
+  UpdateWifiPayload payload;
+  cJSON *parsedJson = cJSON_Parse(jsonPayload.c_str());
+
+  if (parsedJson == nullptr)
+    return std::nullopt;
+
+  cJSON *networkName = cJSON_GetObjectItem(parsedJson, "name");
+  if (networkName == nullptr)
+  {
+    cJSON_Delete(parsedJson);
+    return std::nullopt;
+  }
+
+  payload.networkName = std::string(networkName->valuestring);
+
+  cJSON *ssidObject = cJSON_GetObjectItem(parsedJson, "ssid");
+  cJSON *passwordObject = cJSON_GetObjectItem(parsedJson, "password");
+  cJSON *channelObject = cJSON_GetObjectItem(parsedJson, "channel");
+  cJSON *powerObject = cJSON_GetObjectItem(parsedJson, "power");
+
+  if (ssidObject != nullptr && ssidObject->valuestring == "")
+  {
+    // we need ssid to actually connect
+    cJSON_Delete(parsedJson);
+    return std::nullopt;
+  }
+
+  if (ssidObject != nullptr)
+    payload.ssid = std::string(ssidObject->valuestring);
+
+  if (passwordObject != nullptr)
+    payload.password = std::string(passwordObject->valuestring);
+
+  if (channelObject != nullptr)
+    payload.channel = channelObject->valueint;
+
+  if (powerObject != nullptr)
+    payload.power = powerObject->valueint;
+}
+
+CommandResult updateWifiCommand::execute(std::string &jsonPayload)
+{
+  auto payload = parsePayload(jsonPayload);
+  if (!payload.has_value())
+  {
+    return CommandResult::getErrorResult("Invalid payload");
+  }
+
+  auto updatedConfig = payload.value();
+  auto storedNetworks = projectConfig.getWifiConfigs();
+  if (auto networkToUpdate = std::find_if(
+          storedNetworks.begin(),
+          storedNetworks.end(),
+          [&](auto &network)
+          { return network.name == updatedConfig.networkName; });
+      networkToUpdate != storedNetworks.end())
+  {
+    projectConfig.setWifiConfig(
+        updatedConfig.networkName,
+        updatedConfig.ssid.has_value() ? updatedConfig.ssid.value() : networkToUpdate->ssid,
+        updatedConfig.password.has_value() ? updatedConfig.password.value() : networkToUpdate->password,
+        updatedConfig.channel.has_value() ? updatedConfig.channel.value() : networkToUpdate->channel,
+        updatedConfig.power.has_value() ? updatedConfig.power.value() : networkToUpdate->power,
+        false,
+        false);
+  }
+  else
+    return CommandResult::getErrorResult("Requested network does not exist");
+}

components/CommandManager/CommandManager/Commands.hpp

@@ -42,4 +42,14 @@ public:
   std::optional<deleteNetworkPayload> parsePayload(std::string &jsonPayload);
 };
 
+class updateWifiCommand : public Command
+{
+  ProjectConfig &projectConfig;
+
+public:
+  updateWifiCommand(ProjectConfig &projectConfig) : projectConfig(projectConfig) {};
+  CommandResult execute(std::string &jsonPayload) override;
+  std::optional<UpdateWifiPayload> parsePayload(std::string &jsonPayload);
+};
+
 #endif