<%= number_with_delimiter import.processed %>
- <% if DawarichSettings.store_geodata? %>
- |
- <%= number_with_delimiter import.reverse_geocoded_points_count %>
- |
- <% end %>
+ <%#= import.status %> |
<%= human_datetime(import.created_at) %> |
+
+ <% if import.file.present? %>
+ <%= link_to 'Download', rails_blob_path(import.file, disposition: 'attachment'), class: "px-4 py-2 bg-blue-500 text-white rounded-md", download: import.name %>
+ <% end %>
+ <%= link_to 'Delete', import, data: { confirm: "Are you sure?", turbo_confirm: "Are you sure?", turbo_method: :delete }, method: :delete, class: "px-4 py-2 bg-red-500 text-white rounded-md" %>
+ |
<% end %>
diff --git a/spec/services/users/export_data_spec.rb b/spec/services/users/export_data_spec.rb
index 4fd45749..cc603d75 100644
--- a/spec/services/users/export_data_spec.rb
+++ b/spec/services/users/export_data_spec.rb
@@ -109,8 +109,9 @@ RSpec.describe Users::ExportData, type: :service do
it 'creates a zip file with proper compression settings' do
expect(Zip::File).to receive(:open).with(zip_file_path, Zip::File::CREATE)
- expect(zip_file_double).to receive(:default_compression=).with(Zip::Entry::DEFLATED)
- expect(zip_file_double).to receive(:default_compression_level=).with(9)
+ expect(Zip).to receive(:default_compression).and_return(-1) # Mock original compression
+ expect(Zip).to receive(:default_compression=).with(Zip::Entry::DEFLATED)
+ expect(Zip).to receive(:default_compression=).with(-1) # Restoration
service.export
end
diff --git a/spec/services/users/export_import_integration_spec.rb b/spec/services/users/export_import_integration_spec.rb
new file mode 100644
index 00000000..ed9fd3e8
--- /dev/null
+++ b/spec/services/users/export_import_integration_spec.rb
@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Users Export-Import Integration', type: :service do
+ let(:original_user) { create(:user, email: 'original@example.com') }
+ let(:target_user) { create(:user, email: 'target@example.com') }
+ let(:temp_archive_path) { Rails.root.join('tmp', 'test_export.zip') }
+
+ after do
+ # Clean up any test files
+ File.delete(temp_archive_path) if File.exist?(temp_archive_path)
+ end
+
+ describe 'complete export-import cycle' do
+ before do
+ # Create comprehensive test data for original user
+ create_full_user_dataset(original_user)
+ end
+
+ it 'exports and imports all user data while preserving relationships' do
+ # Step 1: Export original user data
+ export_record = Users::ExportData.new(original_user).export
+
+ expect(export_record).to be_present
+ expect(export_record.status).to eq('completed')
+ expect(export_record.file).to be_attached
+
+ # Download export file to temporary location
+ File.open(temp_archive_path, 'wb') do |file|
+ export_record.file.download { |chunk| file.write(chunk) }
+ end
+
+ expect(File.exist?(temp_archive_path)).to be true
+
+ # Step 2: Capture original counts
+ original_counts = calculate_user_entity_counts(original_user)
+
+ # Debug: Check what was exported
+ debug_export_data(temp_archive_path)
+
+ # Debug: Enable detailed logging
+ original_log_level = Rails.logger.level
+ Rails.logger.level = Logger::DEBUG
+
+ begin
+ # Step 3: Import data into target user
+ import_stats = Users::ImportData.new(target_user, temp_archive_path).import
+ ensure
+ # Restore original log level
+ Rails.logger.level = original_log_level
+ end
+
+ # Debug: Check import stats
+ puts "Import stats: #{import_stats.inspect}"
+
+ # Step 4: Calculate user-generated notification count for comparisons
+ # Only user-generated notifications are exported, not system notifications
+ user_notifications_count = original_user.notifications.where.not(
+ title: ['Data import completed', 'Data import failed', 'Export completed', 'Export failed']
+ ).count
+
+ # Verify entity counts match
+ target_counts = calculate_user_entity_counts(target_user)
+
+ # Debug: Show count comparison
+ puts "Original counts: #{original_counts.inspect}"
+ puts "Target counts: #{target_counts.inspect}"
+
+ # Compare all entity counts
+ expect(target_counts[:areas]).to eq(original_counts[:areas])
+ expect(target_counts[:imports]).to eq(original_counts[:imports])
+ expect(target_counts[:exports]).to eq(original_counts[:exports])
+ expect(target_counts[:trips]).to eq(original_counts[:trips])
+ expect(target_counts[:stats]).to eq(original_counts[:stats])
+ # Target should have user notifications + import success notification
+ # Original count includes export success, but export filters that out
+ # Import creates its own success notification, so target should have user notifications + import success
+ expect(target_counts[:notifications]).to eq(user_notifications_count + 1) # +1 for import success
+ expect(target_counts[:points]).to eq(original_counts[:points])
+ expect(target_counts[:visits]).to eq(original_counts[:visits])
+ expect(target_counts[:places]).to eq(original_counts[:places])
+
+ # Verify import stats match expectations
+ expect(import_stats[:areas_created]).to eq(original_counts[:areas])
+ expect(import_stats[:imports_created]).to eq(original_counts[:imports])
+ expect(import_stats[:exports_created]).to eq(original_counts[:exports])
+ expect(import_stats[:trips_created]).to eq(original_counts[:trips])
+ expect(import_stats[:stats_created]).to eq(original_counts[:stats])
+ expect(import_stats[:notifications_created]).to eq(user_notifications_count)
+ expect(import_stats[:points_created]).to eq(original_counts[:points])
+ expect(import_stats[:visits_created]).to eq(original_counts[:visits])
+ # Places are global entities, so they may already exist and not be recreated
+ # The count in target_counts shows the user has access to the places (through visits)
+ # but places_created shows how many NEW places were actually created during import
+ # Since places may be global duplicates, we just verify they're accessible
+ expect(target_counts[:places]).to eq(original_counts[:places]) # User still has access to places
+
+ # Step 5: Verify relationships are preserved
+ verify_relationships_preserved(original_user, target_user)
+
+ # Step 6: Verify settings are preserved
+ verify_settings_preserved(original_user, target_user)
+
+ # Step 7: Verify files are restored
+ verify_files_restored(original_user, target_user)
+ end
+
+ it 'is idempotent - running import twice does not create duplicates' do
+ # First export and import
+ export_record = Users::ExportData.new(original_user).export
+
+ File.open(temp_archive_path, 'wb') do |file|
+ export_record.file.download { |chunk| file.write(chunk) }
+ end
+
+ # First import
+ first_import_stats = Users::ImportData.new(target_user, temp_archive_path).import
+ first_counts = calculate_user_entity_counts(target_user)
+
+ # Second import (should not create duplicates)
+ second_import_stats = Users::ImportData.new(target_user, temp_archive_path).import
+ second_counts = calculate_user_entity_counts(target_user)
+
+ # Counts should be identical
+ expect(second_counts).to eq(first_counts)
+
+ # Second import should create no new entities
+ expect(second_import_stats[:areas_created]).to eq(0)
+ expect(second_import_stats[:imports_created]).to eq(0)
+ expect(second_import_stats[:exports_created]).to eq(0)
+ expect(second_import_stats[:trips_created]).to eq(0)
+ expect(second_import_stats[:stats_created]).to eq(0)
+ expect(second_import_stats[:notifications_created]).to eq(0)
+ expect(second_import_stats[:points_created]).to eq(0)
+ expect(second_import_stats[:visits_created]).to eq(0)
+ expect(second_import_stats[:places_created]).to eq(0)
+ end
+
+ it 'does not trigger background processing for imported imports' do
+ # Mock the job to ensure it's not called
+ expect(Import::ProcessJob).not_to receive(:perform_later)
+
+ export_record = Users::ExportData.new(original_user).export
+
+ File.open(temp_archive_path, 'wb') do |file|
+ export_record.file.download { |chunk| file.write(chunk) }
+ end
+
+ Users::ImportData.new(target_user, temp_archive_path).import
+ end
+ end
+
+ private
+
+ def debug_export_data(archive_path)
+ require 'zip'
+
+ puts "\n=== DEBUGGING EXPORT DATA ==="
+
+ # Extract and read the data.json file
+ Zip::File.open(archive_path) do |zip_file|
+ data_entry = zip_file.find { |entry| entry.name == 'data.json' }
+ if data_entry
+ json_content = data_entry.get_input_stream.read
+ data = JSON.parse(json_content)
+
+ puts "Export counts: #{data['counts'].inspect}"
+ puts "Points in export: #{data['points']&.size || 0}"
+ puts "Places in export: #{data['places']&.size || 0}"
+ puts "First point sample: #{data['points']&.first&.slice('timestamp', 'longitude', 'latitude', 'import_reference', 'country_info', 'visit_reference')}"
+ puts "First place sample: #{data['places']&.first&.slice('name', 'latitude', 'longitude', 'source')}"
+ puts "Imports in export: #{data['imports']&.size || 0}"
+ puts "Countries referenced: #{data['points']&.map { |p| p['country_info']&.dig('name') }&.compact&.uniq || []}"
+ else
+ puts "No data.json found in export!"
+ end
+ end
+
+ puts "=== END DEBUG ==="
+ end
+
+ def create_full_user_dataset(user)
+ # Set custom user settings
+ user.update!(settings: {
+ 'distance_unit' => 'km',
+ 'timezone' => 'America/New_York',
+ 'immich_url' => 'https://immich.example.com',
+ 'immich_api_key' => 'test-api-key'
+ })
+
+ # Create countries (global entities)
+ usa = create(:country, name: 'United States', iso_a2: 'US', iso_a3: 'USA')
+ canada = create(:country, name: 'Canada', iso_a2: 'CA', iso_a3: 'CAN')
+
+ # Create places (global entities)
+ office = create(:place, name: 'Office Building', latitude: 40.7589, longitude: -73.9851)
+ home = create(:place, name: 'Home Sweet Home', latitude: 40.7128, longitude: -74.0060)
+
+ # Create user-specific areas
+ create_list(:area, 3, user: user)
+
+ # Create imports with files
+ import1 = create(:import, user: user, name: 'March 2024 Data', source: :google_semantic_history)
+ import2 = create(:import, user: user, name: 'OwnTracks Data', source: :owntracks)
+
+ # Attach files to imports
+ import1.file.attach(
+ io: StringIO.new('{"timelineObjects": []}'),
+ filename: 'march_2024.json',
+ content_type: 'application/json'
+ )
+ import2.file.attach(
+ io: StringIO.new('{"_type": "location"}'),
+ filename: 'owntracks.json',
+ content_type: 'application/json'
+ )
+
+ # Create exports with files
+ export1 = create(:export, user: user, name: 'Q1 2024 Export', file_format: :json, file_type: :points)
+ export1.file.attach(
+ io: StringIO.new('{"type": "FeatureCollection", "features": []}'),
+ filename: 'q1_2024.json',
+ content_type: 'application/json'
+ )
+
+ # Create trips
+ create_list(:trip, 2, user: user)
+
+ # Create stats
+ create(:stat, user: user, year: 2024, month: 1, distance: 150.5, daily_distance: [[1, 5.2], [2, 8.1]])
+ create(:stat, user: user, year: 2024, month: 2, distance: 200.3, daily_distance: [[1, 6.5], [2, 9.8]])
+
+ # Create notifications
+ create_list(:notification, 4, user: user)
+
+ # Create visits (linked to places)
+ visit1 = create(:visit, user: user, place: office, name: 'Work Visit')
+ visit2 = create(:visit, user: user, place: home, name: 'Home Visit')
+ visit3 = create(:visit, user: user, place: nil, name: 'Unknown Location')
+
+ # Create points with various relationships
+ # Points linked to import1, usa, and visit1
+ create_list(:point, 5,
+ user: user,
+ import: import1,
+ country: usa,
+ visit: visit1,
+ latitude: 40.7589,
+ longitude: -73.9851
+ )
+
+ # Points linked to import2, canada, and visit2
+ create_list(:point, 3,
+ user: user,
+ import: import2,
+ country: canada,
+ visit: visit2,
+ latitude: 40.7128,
+ longitude: -74.0060
+ )
+
+ # Points with no relationships (orphaned)
+ create_list(:point, 2,
+ user: user,
+ import: nil,
+ country: nil,
+ visit: nil
+ )
+
+ # Points linked to visit3 (no place)
+ create_list(:point, 2,
+ user: user,
+ import: import1,
+ country: usa,
+ visit: visit3
+ )
+
+ puts "Created dataset with #{user.tracked_points.count} points"
+ end
+
+ def calculate_user_entity_counts(user)
+ {
+ areas: user.areas.count,
+ imports: user.imports.count,
+ exports: user.exports.count,
+ trips: user.trips.count,
+ stats: user.stats.count,
+ notifications: user.notifications.count,
+ points: user.tracked_points.count,
+ visits: user.visits.count,
+ places: user.places.count
+ }
+ end
+
+ def verify_relationships_preserved(original_user, target_user)
+ # Verify points maintain their relationships
+ original_points_with_imports = original_user.tracked_points.where.not(import_id: nil).count
+ target_points_with_imports = target_user.tracked_points.where.not(import_id: nil).count
+ expect(target_points_with_imports).to eq(original_points_with_imports)
+
+ original_points_with_countries = original_user.tracked_points.where.not(country_id: nil).count
+ target_points_with_countries = target_user.tracked_points.where.not(country_id: nil).count
+ expect(target_points_with_countries).to eq(original_points_with_countries)
+
+ original_points_with_visits = original_user.tracked_points.where.not(visit_id: nil).count
+ target_points_with_visits = target_user.tracked_points.where.not(visit_id: nil).count
+ expect(target_points_with_visits).to eq(original_points_with_visits)
+
+ # Verify visits maintain their place relationships
+ original_visits_with_places = original_user.visits.where.not(place_id: nil).count
+ target_visits_with_places = target_user.visits.where.not(place_id: nil).count
+ expect(target_visits_with_places).to eq(original_visits_with_places)
+
+ # Verify specific relationship consistency
+ # Check that points with same coordinates have same relationships
+ original_office_points = original_user.tracked_points.where(
+ latitude: 40.7589, longitude: -73.9851
+ ).first
+ target_office_points = target_user.tracked_points.where(
+ latitude: 40.7589, longitude: -73.9851
+ ).first
+
+ if original_office_points && target_office_points
+ expect(target_office_points.import.name).to eq(original_office_points.import.name) if original_office_points.import
+ expect(target_office_points.country.name).to eq(original_office_points.country.name) if original_office_points.country
+ expect(target_office_points.visit.name).to eq(original_office_points.visit.name) if original_office_points.visit
+ end
+ end
+
+ def verify_settings_preserved(original_user, target_user)
+ # Verify user settings are correctly applied
+ expect(target_user.safe_settings.distance_unit).to eq(original_user.safe_settings.distance_unit)
+ expect(target_user.safe_settings.timezone).to eq(original_user.safe_settings.timezone)
+ expect(target_user.settings['immich_url']).to eq(original_user.settings['immich_url'])
+ expect(target_user.settings['immich_api_key']).to eq(original_user.settings['immich_api_key'])
+ end
+
+ def verify_files_restored(original_user, target_user)
+ # Verify import files are restored
+ original_imports_with_files = original_user.imports.joins(:file_attachment).count
+ target_imports_with_files = target_user.imports.joins(:file_attachment).count
+ expect(target_imports_with_files).to eq(original_imports_with_files)
+
+ # Verify export files are restored
+ original_exports_with_files = original_user.exports.joins(:file_attachment).count
+ target_exports_with_files = target_user.exports.joins(:file_attachment).count
+ expect(target_exports_with_files).to eq(original_exports_with_files)
+
+ # Verify specific file details
+ original_import = original_user.imports.find_by(name: 'March 2024 Data')
+ target_import = target_user.imports.find_by(name: 'March 2024 Data')
+
+ if original_import&.file&.attached? && target_import&.file&.attached?
+ expect(target_import.file.filename.to_s).to eq(original_import.file.filename.to_s)
+ expect(target_import.file.content_type).to eq(original_import.file.content_type)
+ end
+ end
+end
diff --git a/spec/services/users/import_data/imports_spec.rb b/spec/services/users/import_data/imports_spec.rb
index 9934d2d8..f9ef66e9 100644
--- a/spec/services/users/import_data/imports_spec.rb
+++ b/spec/services/users/import_data/imports_spec.rb
@@ -38,9 +38,6 @@ RSpec.describe Users::ImportData::Imports, type: :service do
# Create mock files
File.write(files_directory.join('import_1_2023_MARCH.json'), '{"test": "data"}')
File.write(files_directory.join('import_2_2023_APRIL.json'), '{"more": "data"}')
-
- # Mock the Import job to prevent it from being enqueued
- allow(Import::ProcessJob).to receive(:perform_later)
end
after do
@@ -98,6 +95,20 @@ RSpec.describe Users::ImportData::Imports, type: :service do
service.call
end
+
+ it 'does not trigger background processing jobs' do
+ expect(Import::ProcessJob).not_to receive(:perform_later)
+
+ service.call
+ end
+
+ it 'sets skip_background_processing flag on created imports' do
+ service.call
+
+ user.imports.each do |import|
+ expect(import.skip_background_processing).to be_truthy
+ end
+ end
end
context 'with duplicate imports' do
diff --git a/test_output.log b/test_output.log
new file mode 100644
index 00000000..0610ce83
--- /dev/null
+++ b/test_output.log
@@ -0,0 +1,92 @@
+Run options: include {locations: {"./spec/services/users/export_import_integration_spec.rb" => [21]}}
+Created dataset with 12 points
+
+=== DEBUGGING EXPORT DATA ===
+Export counts: {"areas" => 3, "imports" => 2, "exports" => 2, "trips" => 2, "stats" => 2, "notifications" => 4, "points" => 12, "visits" => 3, "places" => 2}
+Points in export: 12
+Places in export: 2
+First point sample: {"timestamp" => 1714559220, "longitude" => -73.9851, "latitude" => 40.7589, "import_reference" => {"name" => "March 2024 Data", "source" => 0, "created_at" => "2025-06-30T16:10:46.550Z"}, "country_info" => {"name" => "United States", "iso_a2" => "US", "iso_a3" => "USA"}, "visit_reference" => {"name" => "Work Visit", "started_at" => "2025-06-30T16:10:46.711Z", "ended_at" => "2025-06-30T17:10:46.711Z"}}
+First place sample: {"name" => "Office Building", "latitude" => "40.7589", "longitude" => "-73.9851", "source" => "manual"}
+Imports in export: 2
+Countries referenced: ["United States", "Canada"]
+=== END DEBUG ===
+Import stats: {settings_updated: true, areas_created: 3, places_created: 0, imports_created: 2, exports_created: 2, trips_created: 2, stats_created: 2, notifications_created: 4, visits_created: 3, points_created: 0, files_restored: 3}
+Original counts: {areas: 3, imports: 2, exports: 2, trips: 2, stats: 2, notifications: 5, points: 12, visits: 3, places: 2}
+Target counts: {areas: 3, imports: 2, exports: 2, trips: 2, stats: 2, notifications: 5, points: 0, visits: 3, places: 2}
+F/Users/frey/.rvm/rubies/ruby-3.4.1/bin/ruby -I/Users/frey/.rvm/gems/ruby-3.4.1/gems/rspec-core-3.13.3/lib:/Users/frey/.rvm/gems/ruby-3.4.1/gems/rspec-support-3.13.3/lib /Users/frey/.rvm/gems/ruby-3.4.1/gems/rspec-core-3.13.3/exe/rspec --pattern spec/swagger/\*\*/\*_spec.rb --format Rswag::Specs::SwaggerFormatter --dry-run --order defined
+Generating Swagger docs ...
+Swagger doc generated at /Users/frey/projects/dawarich/dawarich/swagger/v1/swagger.yaml
+
+Top 10 slowest examples (0.00002 seconds, 0.6% of total time):
+ Areas API /api/v1/areas post area created returns a 201 response
+ 0.00001 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Stats API /api/v1/stats get stats found returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Areas API /api/v1/areas post invalid request returns a 422 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Areas API /api/v1/areas/{id} delete area deleted returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Health API /api/v1/health get Healthy returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Points API /api/v1/points get points found returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Users API /api/v1/users/me get user found returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Settings API /api/v1/settings get settings found returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Settings API /api/v1/settings patch settings updated returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+ Points API /api/v1/points/{id} delete point deleted returns a 200 response
+ 0 seconds /Users/frey/.rvm/gems/ruby-3.4.1/gems/rswag-specs-2.16.0/lib/rswag/specs/example_group_helpers.rb:143
+
+Top 10 slowest example groups:
+ Health API
+ 0.00039 seconds average (0.00039 seconds / 1 example) ./spec/swagger/api/v1/health_controller_spec.rb:5
+ Points API
+ 0.00016 seconds average (0.00065 seconds / 4 examples) ./spec/swagger/api/v1/points_controller_spec.rb:5
+ Areas API
+ 0.00013 seconds average (0.00052 seconds / 4 examples) ./spec/swagger/api/v1/areas_controller_spec.rb:5
+ Stats API
+ 0.00013 seconds average (0.00013 seconds / 1 example) ./spec/swagger/api/v1/stats_controller_spec.rb:5
+ Users API
+ 0.00012 seconds average (0.00012 seconds / 1 example) ./spec/swagger/api/v1/users_controller_spec.rb:5
+ Settings API
+ 0.00011 seconds average (0.00021 seconds / 2 examples) ./spec/swagger/api/v1/settings_controller_spec.rb:5
+ Overland Batches API
+ 0.0001 seconds average (0.0002 seconds / 2 examples) ./spec/swagger/api/v1/overland/batches_controller_spec.rb:5
+ Api::V1::Countries::VisitedCities
+ 0.00009 seconds average (0.00017 seconds / 2 examples) ./spec/swagger/api/v1/countries/visited_cities_spec.rb:5
+ OwnTracks Points API
+ 0.00009 seconds average (0.00017 seconds / 2 examples) ./spec/swagger/api/v1/owntracks/points_controller_spec.rb:5
+ Api::V1::PhotosController
+ 0.00008 seconds average (0.00025 seconds / 3 examples) ./spec/swagger/api/v1/photos_controller_spec.rb:5
+
+Finished in 0.00388 seconds (files took 1.87 seconds to load)
+24 examples, 0 failures
+
+Coverage report generated for RSpec to /Users/frey/projects/dawarich/dawarich/coverage.
+Line Coverage: 61.36% (670 / 1092)
+
+
+Failures:
+
+ 1) Users Export-Import Integration complete export-import cycle exports and imports all user data while preserving relationships
+ Failure/Error: expect(target_counts[:points]).to eq(original_counts[:points])
+ Expected 0 to eq 12.
+ # ./spec/services/users/export_import_integration_spec.rb:71:in 'block (3 levels) in