Pipeline: City rename, add address/postal-code generation, add xeger generation (#232)

tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc

@@ -13,10 +13,12 @@ BiergartenPipelineOrchestrator::BiergartenPipelineOrchestrator(
     std::unique_ptr<DataGenerator> generator,
     std::unique_ptr<IExportService> exporter,
     std::unique_ptr<ICuratedDataService> curated_data_service,
+    std::unique_ptr<IPostalCodeService> postal_code_service,
     const ApplicationOptions& application_options)
     : logger_(std::move(logger)),
       context_service_(std::move(context_service)),
       generator_(std::move(generator)),
       exporter_(std::move(exporter)),
       curated_data_service_(std::move(curated_data_service)),
+      postal_code_service_(std::move(postal_code_service)),
       application_options_(application_options) {}

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc

@@ -22,12 +22,15 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
 
   const auto generate_record =
       [this, &skipped_count](
-          const Location& location,
-          const std::string& region_context) -> std::optional<BreweryRecord> {
+          const EnrichedCity& enriched_city) -> std::optional<BreweryRecord> {
     try {
-      const BreweryResult brewery =
-          generator_->GenerateBrewery(location, region_context);
-      return BreweryRecord{.location = location, .brewery = brewery};
+      const BreweryResult brewery = generator_->GenerateBrewery(enriched_city);
+      const std::string postal_code =
+          postal_code_service_->GeneratePostalCode(enriched_city.location);
+      return BreweryRecord{
+          .address = BreweryAddress{.city = enriched_city.location,
+                                    .postal_code = postal_code},
+          .brewery = brewery};
     } catch (const std::exception& e) {
       ++skipped_count;
 
@@ -36,7 +39,8 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
            .phase = PipelinePhase::BreweryAndBeerGeneration,
            .message = std::format("[Pipeline] Skipping city '{}' ({}): brewery "
                                   "generation failed: {}",
-                                  location.city, location.country, e.what())});
+                                  enriched_city.location.city,
+                                  enriched_city.location.country, e.what())});
       return std::nullopt;
     }
   };
@@ -47,19 +51,18 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
       exporter_->ProcessRecord(record);
     } catch (const std::exception& export_exception) {
       ++export_failed_count;
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message = std::format("[Pipeline] Generated brewery for '{}' ({}) "
-                                  "but SQLite export failed: {}",
-                                  record.location.city, record.location.country,
-                                  export_exception.what())});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::BreweryAndBeerGeneration,
+                    .message = std::format(
+                        "[Pipeline] Generated brewery for '{}' ({}) "
+                        "but SQLite export failed: {}",
+                        record.address.city.city, record.address.city.country,
+                        export_exception.what())});
     }
   };
 
-  for (const auto& [location, region_context] : cities) {
-    const std::optional<BreweryRecord> record =
-        generate_record(location, region_context);
+  for (const EnrichedCity& enriched_city : cities) {
+    const std::optional<BreweryRecord> record = generate_record(enriched_city);
     if (!record.has_value()) {
       continue;
     }

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_users.cc

@@ -135,9 +135,12 @@ void BiergartenPipelineOrchestrator::GenerateUsers(
     try {
       const UserResult user =
           generator_->GenerateUser(city, persona, sampled_name);
+      const std::string postal_code =
+          postal_code_service_->GeneratePostalCode(city.location);
 
       return UserRecord{
-          .location = city.location,
+          .address =
+              UserAddress{.city = city.location, .postal_code = postal_code},
           .user = user,
           .email = BuildEmail(sampled_name, used_email_local_parts),
           .date_of_birth = GenerateDateOfBirth(rng),
@@ -161,13 +164,13 @@ void BiergartenPipelineOrchestrator::GenerateUsers(
     } catch (const std::exception& export_exception) {
       ++export_failed_count;
 
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("[Pipeline] Generated user for '{}' ({}) but "
-                                  "SQLite export failed: {}",
-                                  record.location.city, record.location.country,
-                                  export_exception.what())});
+      logger_->Log({.level = LogLevel::Warn,
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::format(
+                        "[Pipeline] Generated user for '{}' ({}) but "
+                        "SQLite export failed: {}",
+                        record.address.city.city, record.address.city.country,
+                        export_exception.what())});
     }
   };
 

tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc

@@ -14,20 +14,20 @@
 void BiergartenPipelineOrchestrator::LogResults() const {
   boost::json::array brewery_output;
 
-  for (const auto& [location, brewery] : generated_breweries_) {
+  for (const auto& [address, brewery] : generated_breweries_) {
+    const City& city = address.city;
     brewery_output.push_back(boost::json::object{
         {"name_en", brewery.name_en},
         {"description_en", brewery.description_en},
         {"name_local", brewery.name_local},
         {"description_local", brewery.description_local},
-        {"location", boost::json::object{
-                         {"city", location.city},
-                         {"country", location.country},
-                         {"state_province", location.state_province},
-                         {"iso3166_2", location.iso3166_2},
-                         {"latitude", location.latitude},
-                         {"longitude", location.longitude},
-                     }}});
+        {"address", boost::json::object{
+                        {"city", city.city},
+                        {"country", city.country},
+                        {"state_province", city.state_province},
+                        {"iso3166_2", city.iso3166_2},
+                        {"postal_code", address.postal_code},
+                    }}});
   }
 
   std::ostringstream brewery_oss;

tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc

@@ -14,13 +14,13 @@
 #include "services/curated_data/curated_json_data_service.h"
 #include "services/logging/logger.h"
 
-std::vector<Location>
-BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
+std::vector<City>
+BiergartenPipelineOrchestrator::QueryLocations() {
   logger_->Log({.level = LogLevel::Info,
                 .phase = PipelinePhase::Startup,
                 .message = "=== GEOGRAPHIC DATA OVERVIEW ==="});
 
-  const std::vector<Location>& all_locations =
+  const std::vector<City>& all_locations =
       curated_data_service_->LoadLocations();
 
   const size_t sample_count = std::min(
@@ -31,7 +31,7 @@ BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
       static_cast<std::iter_difference_t<decltype(all_locations.cbegin())>>(
           sample_count);
 
-  std::vector<Location> sampled_locations;
+  std::vector<City> sampled_locations;
   sampled_locations.reserve(sample_count);
 
   std::random_device random_generator;

tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc

@@ -14,7 +14,7 @@ bool BiergartenPipelineOrchestrator::Run() {
   try {
     exporter_->Initialize();
 
-    std::vector<Location> cities = QueryCitiesWithCountries();
+    std::vector<City> cities = QueryLocations();
     std::vector<EnrichedCity> enriched;
     enriched.reserve(cities.size());