Create biergarten brewery pipeline project (#199)

pipeline/src/biergarten_data_generator/biergarten_data_generator.cc

@@ -0,0 +1,14 @@
+/**
+ * @file biergarten_data_generator/biergarten_data_generator.cc
+ * @brief BiergartenDataGenerator constructor implementation.
+ */
+
+#include "biergarten_data_generator.h"
+
+#include <utility>
+
+BiergartenDataGenerator::BiergartenDataGenerator(
+    std::unique_ptr<IEnrichmentService> context_service,
+    std::unique_ptr<DataGenerator> generator)
+    : context_service_(std::move(context_service)),
+      generator_(std::move(generator)) {}

pipeline/src/biergarten_data_generator/generate_breweries.cc

@@ -0,0 +1,39 @@
+/**
+ * @file biergarten_data_generator/generate_breweries.cc
+ * @brief BiergartenDataGenerator::GenerateBreweries() implementation.
+ */
+
+#include <spdlog/spdlog.h>
+
+#include "biergarten_data_generator.h"
+
+void BiergartenDataGenerator::GenerateBreweries(
+    std::span<const EnrichedCity> cities) {
+  spdlog::info("\n=== SAMPLE BREWERY GENERATION ===");
+
+  generated_breweries_.clear();
+  size_t skipped_count = 0;
+
+  for (const auto& [location, region_context] : cities) {
+    try {
+      const BreweryResult brewery =
+          generator_->GenerateBrewery(location, region_context);
+
+      const GeneratedBrewery gen{.location = location, .brewery = brewery};
+
+      generated_breweries_.push_back(gen);
+    } catch (const std::exception& e) {
+      ++skipped_count;
+
+      spdlog::warn(
+          "[Pipeline] Skipping city '{}' ({}): brewery generation failed: "
+          "{}",
+          location.city, location.country, e.what());
+    }
+  }
+
+  if (skipped_count > 0) {
+    spdlog::warn("[Pipeline] Skipped {} city/cities due to generation errors",
+                 skipped_count);
+  }
+}

pipeline/src/biergarten_data_generator/log_results.cc

@@ -0,0 +1,27 @@
+/**
+ * @file biergarten_data_generator/log_results.cc
+ * @brief BiergartenDataGenerator::LogResults() implementation.
+ */
+
+#include <spdlog/spdlog.h>
+
+#include "biergarten_data_generator.h"
+
+void BiergartenDataGenerator::LogResults() const {
+  spdlog::info("\n=== GENERATED DATA DUMP ===");
+  size_t index = 1;
+  for (const auto& [location, brewery] : generated_breweries_) {
+    spdlog::info(
+        "{}. city=\"{}\" country=\"{}\" state=\"{}\" "
+        "iso3166_2={} lat={} lon={}",
+        index, location.city, location.country, location.state_province,
+        location.iso3166_2, location.latitude, location.longitude);
+    spdlog::info("   brewery_name_en=\"{}\"", brewery.name_en);
+    spdlog::info("   brewery_description_en=\"{}\"",
+                 brewery.description_en);
+    spdlog::info("   brewery_name_local=\"{}\"", brewery.name_local);
+    spdlog::info("   brewery_description_local=\"{}\"",
+                 brewery.description_local);
+    ++index;
+  }
+}

pipeline/src/biergarten_data_generator/query_cities_with_countries.cc

@@ -0,0 +1,41 @@
+/**
+ * @file biergarten_data_generator/query_cities_with_countries.cc
+ * @brief BiergartenDataGenerator::QueryCitiesWithCountries() implementation.
+ */
+
+#include <spdlog/spdlog.h>
+
+#include <algorithm>
+#include <filesystem>
+#include <iterator>
+#include <random>
+
+#include "biergarten_data_generator.h"
+#include "json_handling/json_loader.h"
+
+static constexpr size_t kBreweryAmount = 50;
+
+std::vector<Location> BiergartenDataGenerator::QueryCitiesWithCountries() {
+  spdlog::info("\n=== GEOGRAPHIC DATA OVERVIEW ===");
+
+  const std::filesystem::path locations_path = "locations.json";
+
+  auto all_locations = JsonLoader::LoadLocations(locations_path);
+  spdlog::info("  Locations available: {}", all_locations.size());
+
+  const size_t sample_count = std::min(kBreweryAmount, all_locations.size());
+
+  const auto sample_count_signed =
+      static_cast<std::iter_difference_t<decltype(all_locations.cbegin())>>(
+          sample_count);
+
+  std::vector<Location> sampled_locations;
+  sampled_locations.reserve(sample_count);
+
+  std::random_device random_generator;
+  std::ranges::sample(all_locations, std::back_inserter(sampled_locations),
+                      sample_count_signed, random_generator);
+
+  spdlog::info("  Sampled locations: {}", sampled_locations.size());
+  return sampled_locations;
+}

pipeline/src/biergarten_data_generator/run.cc

@@ -0,0 +1,49 @@
+/**
+ * @file biergarten_data_generator/run.cc
+ * @brief BiergartenDataGenerator::Run() implementation.
+ */
+
+#include <utility>
+
+#include <spdlog/spdlog.h>
+
+#include "biergarten_data_generator.h"
+
+bool BiergartenDataGenerator::Run() {
+  try {
+    std::vector<Location> cities = QueryCitiesWithCountries();
+    std::vector<EnrichedCity> enriched;
+    enriched.reserve(cities.size());
+
+    size_t skipped_count = 0;
+    for (auto& city : cities) {
+      try {
+        std::string region_context = context_service_->GetLocationContext(city);
+        spdlog::debug("[Pipeline] Context for '{}' ({}) gathered:\n{}",
+                     city.city, city.country, region_context);
+
+        enriched.push_back(
+            EnrichedCity{.location = std::move(city),
+                         .region_context = std::move(region_context)});
+      } catch (const std::exception& exception) {
+        ++skipped_count;
+        spdlog::warn(
+            "[Pipeline] Skipping city '{}' ({}): context lookup failed: {}",
+            city.city, city.country, exception.what());
+      }
+    }
+
+    if (skipped_count > 0) {
+      spdlog::warn(
+          "[Pipeline] Skipped {} city/cities due to context lookup errors",
+          skipped_count);
+    }
+
+    this->GenerateBreweries(enriched);
+    this->LogResults();
+    return true;
+  } catch (const std::exception& e) {
+    spdlog::error("Pipeline execution failed with error: {}", e.what());
+    return false;
+  }
+}