da3522d118
- Add Rails parameterize for server-side slug generation (name-venue-city format) - Configure client-side slug library with RFC3986 mode for consistency - Remove slug field from edit forms to prevent URL changes after publication - Enable image_processing gem for Active Storage variants - Make geocoding notifications visible indefinitely on promoter event forms - Add server-side slug generation fallback with uniqueness validation - Update promoter controller to allow slug only for new events 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
412 lines
13 KiB
Ruby
Executable File
412 lines
13 KiB
Ruby
Executable File
# Event model representing nightlife events and events
|
|
# Manages event details, location data, and publication state
|
|
require "net/http"
|
|
require "json"
|
|
|
|
class Event < ApplicationRecord
|
|
# Define states for Event lifecycle management
|
|
# draft: Initial state when Event is being created
|
|
# published: Event is visible to public and can be discovered
|
|
# canceled: Event has been canceled by organizer
|
|
# sold_out: Event has reached capacity and tickets are no longer available
|
|
enum :state, {
|
|
draft: 0,
|
|
published: 1,
|
|
canceled: 2,
|
|
sold_out: 3
|
|
}, default: :draft
|
|
|
|
# === Relations ===
|
|
belongs_to :user
|
|
has_many :ticket_types
|
|
has_many :tickets, through: :ticket_types
|
|
has_many :orders
|
|
has_many :promotion_codes
|
|
has_one_attached :image
|
|
|
|
|
|
# === Callbacks ===
|
|
before_validation :generate_slug, if: :should_generate_slug?
|
|
before_validation :geocode_address, if: :should_geocode_address?
|
|
before_update :handle_image_replacement, if: :image_attached?
|
|
|
|
# Validations for Event attributes
|
|
# Basic information
|
|
validates :name, presence: true, length: { minimum: 3, maximum: 100 }
|
|
validates :slug, presence: true, length: { minimum: 3, maximum: 100 }
|
|
validates :description, presence: true, length: { minimum: 10, maximum: 2000 }
|
|
validates :state, presence: true, inclusion: { in: states.keys }
|
|
validate :image_format, if: -> { image.attached? }
|
|
validate :image_size, if: -> { image.attached? }
|
|
|
|
# Venue information
|
|
validates :venue_name, presence: true, length: { maximum: 100 }
|
|
validates :venue_address, presence: true, length: { maximum: 200 }
|
|
|
|
# Geographic coordinates for map display
|
|
validates :latitude, presence: true, numericality: {
|
|
greater_than_or_equal_to: -90,
|
|
less_than_or_equal_to: 90
|
|
}
|
|
validates :longitude, presence: true, numericality: {
|
|
greater_than_or_equal_to: -180,
|
|
less_than_or_equal_to: 180
|
|
}
|
|
|
|
# Scopes for querying events with common filters
|
|
scope :featured, -> { where(featured: true) } # Get featured events for homepage
|
|
scope :published, -> { where(state: :published) } # Get publicly visible events
|
|
scope :search_by_name, ->(query) { where("name ILIKE ?", "%#{query}%") } # Search by name (case-insensitive)
|
|
|
|
# Scope for published events ordered by start time
|
|
scope :upcoming, -> { published.where("start_time >= ?", Time.current).order(start_time: :asc) }
|
|
|
|
# === Instance Methods ===
|
|
|
|
# Generate SEO-friendly slug from name, venue name, and city
|
|
def generate_slug
|
|
return if name.blank? && venue_name.blank? && venue_address.blank?
|
|
|
|
# Extract city from venue address
|
|
city = extract_city_from_address(venue_address)
|
|
|
|
# Build slug parts
|
|
slug_parts = []
|
|
slug_parts << name if name.present?
|
|
slug_parts << venue_name if venue_name.present?
|
|
slug_parts << city if city.present?
|
|
|
|
# Generate slug using Rails' parameterize
|
|
slug_value = slug_parts.join('-').parameterize
|
|
|
|
# Ensure minimum length
|
|
if slug_value.length < 3
|
|
slug_value = "event-#{Time.current.to_i}".parameterize
|
|
end
|
|
|
|
# Make sure slug is unique
|
|
base_slug = slug_value
|
|
counter = 1
|
|
while Event.where.not(id: id).where(slug: slug_value).exists?
|
|
slug_value = "#{base_slug}-#{counter}".parameterize
|
|
counter += 1
|
|
end
|
|
|
|
self.slug = slug_value
|
|
end
|
|
|
|
# Check if slug should be generated
|
|
def should_generate_slug?
|
|
# Generate slug if it's blank or if it's a new record
|
|
slug.blank? || new_record?
|
|
end
|
|
|
|
# Extract city from address
|
|
def extract_city_from_address(address)
|
|
return "" if address.blank?
|
|
|
|
# Look for French postal code pattern (5 digits) + city
|
|
match = address.match(/(\d{5})\s+([^,]+)/)
|
|
if match
|
|
return match[2].strip
|
|
end
|
|
|
|
# Fallback: extract last part after comma (assume it's city)
|
|
parts = address.split(',')
|
|
if parts.length > 1
|
|
return parts[parts.length - 1].strip
|
|
end
|
|
|
|
# Another fallback: look for common French city indicators
|
|
city_indicators = ["Paris", "Lyon", "Marseille", "Toulouse", "Nice", "Nantes", "Strasbourg", "Montpellier", "Bordeaux", "Lille"]
|
|
for city in city_indicators
|
|
if address.downcase.include?(city.downcase)
|
|
return city
|
|
end
|
|
end
|
|
|
|
""
|
|
end
|
|
|
|
# Get image URL prioritizing old image field if it exists
|
|
def display_image_url
|
|
# First check if old image field exists and has a value
|
|
return self[:image] if self[:image].present?
|
|
|
|
# Fall back to attached image
|
|
return nil unless image.attached?
|
|
|
|
# Return the URL for the attached image
|
|
Rails.application.routes.url_helpers.rails_blob_url(image, only_path: true)
|
|
end
|
|
|
|
# Get image variants for different display sizes
|
|
def event_image_variant(size = :medium)
|
|
# For old image field, return the URL directly
|
|
return self[:image] if self[:image].present?
|
|
|
|
# For attached images, process variants
|
|
return nil unless image.attached?
|
|
|
|
case size
|
|
when :large
|
|
image.variant(resize_to_limit: [1200, 630])
|
|
when :medium
|
|
image.variant(resize_to_limit: [800, 450])
|
|
when :small
|
|
image.variant(resize_to_limit: [400, 225])
|
|
else
|
|
image
|
|
end
|
|
end
|
|
|
|
# Check if event has any image (old field or attached)
|
|
def has_image?
|
|
self[:image].present? || image.attached?
|
|
end
|
|
|
|
# Check if coordinates were successfully geocoded or are fallback coordinates
|
|
def geocoding_successful?
|
|
coordinates_look_valid?
|
|
end
|
|
|
|
# Get a user-friendly status message about geocoding
|
|
def geocoding_status_message
|
|
return nil if geocoding_successful?
|
|
|
|
"Les coordonnées exactes n'ont pas pu être déterminées automatiquement. Une localisation approximative a été utilisée."
|
|
end
|
|
|
|
# Check if ticket booking is currently allowed for this event
|
|
def booking_allowed?
|
|
return false unless published?
|
|
return false if sold_out?
|
|
return false if canceled?
|
|
|
|
# Check if event has started and if booking during event is disabled
|
|
if event_started? && !allow_booking_during_event?
|
|
return false
|
|
end
|
|
|
|
true
|
|
end
|
|
|
|
# Check if the event has already started
|
|
def event_started?
|
|
return false if start_time.blank?
|
|
Time.current >= start_time
|
|
end
|
|
|
|
# Check if the event has ended
|
|
def event_ended?
|
|
return false if end_time.blank?
|
|
Time.current >= end_time
|
|
end
|
|
|
|
# Check if booking is allowed during the event
|
|
# This is a simple attribute reader that defaults to false if nil
|
|
def allow_booking_during_event?
|
|
!!allow_booking_during_event
|
|
end
|
|
|
|
# Duplicate an event with all its ticket types
|
|
def duplicate(clone_ticket_types: true)
|
|
# Duplicate the event
|
|
new_event = self.dup
|
|
new_event.name = "Copie de #{name}"
|
|
new_event.slug = "#{slug}-copy-#{Time.current.to_i}"
|
|
new_event.state = :draft
|
|
new_event.created_at = Time.current
|
|
new_event.updated_at = Time.current
|
|
|
|
Event.transaction do
|
|
if new_event.save
|
|
# Duplicate all ticket types if requested
|
|
if clone_ticket_types
|
|
ticket_types.each do |ticket_type|
|
|
new_ticket_type = ticket_type.dup
|
|
new_ticket_type.event = new_event
|
|
new_ticket_type.save!
|
|
end
|
|
end
|
|
new_event
|
|
else
|
|
nil
|
|
end
|
|
end
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
# Validate image format
|
|
def image_format
|
|
return unless image.attached?
|
|
|
|
allowed_types = %w[image/jpeg image/jpg image/png image/webp]
|
|
unless allowed_types.include?(image.content_type)
|
|
errors.add(:image, "doit être au format JPG, PNG ou WebP")
|
|
end
|
|
end
|
|
|
|
# Validate image size
|
|
def image_size
|
|
return unless image.attached?
|
|
|
|
if image.byte_size > 5.megabytes
|
|
errors.add(:image, "doit faire moins de 5MB")
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
# Check if image is attached for the callback
|
|
def image_attached?
|
|
image.attached?
|
|
end
|
|
|
|
# Handle image replacement when a new image is uploaded
|
|
def handle_image_replacement
|
|
# Clear the old image field if a new image is being attached
|
|
if image.attached?
|
|
self[:image] = nil
|
|
end
|
|
end
|
|
|
|
# Determine if we should perform server-side geocoding
|
|
def should_geocode_address?
|
|
# Don't geocode if address is blank
|
|
return false if venue_address.blank?
|
|
|
|
# Don't geocode if we already have valid coordinates (likely from frontend)
|
|
return false if coordinates_look_valid?
|
|
|
|
# Only geocode if address changed and we don't have coordinates
|
|
venue_address_changed?
|
|
end
|
|
|
|
# Check if the current coordinates look like they were set by frontend geocoding
|
|
def coordinates_look_valid?
|
|
return false if latitude.blank? || longitude.blank?
|
|
|
|
lat_f = latitude.to_f
|
|
lng_f = longitude.to_f
|
|
|
|
# Basic sanity checks for coordinate ranges
|
|
return false if lat_f < -90 || lat_f > 90
|
|
return false if lng_f < -180 || lng_f > 180
|
|
|
|
# Check if coordinates are not the default fallback coordinates
|
|
fallback_lat = 46.603354
|
|
fallback_lng = 1.888334
|
|
|
|
# Check if coordinates are not exactly 0,0 (common invalid default)
|
|
return false if lat_f == 0.0 && lng_f == 0.0
|
|
|
|
# Coordinates are valid if they're not exactly the fallback coordinates
|
|
!(lat_f == fallback_lat && lng_f == fallback_lng)
|
|
end
|
|
|
|
# Automatically geocode address to get latitude and longitude
|
|
# This only runs when no valid coordinates are provided (fallback for non-JS users)
|
|
def geocode_address
|
|
Rails.logger.info "Running server-side geocoding for '#{venue_address}' (no frontend coordinates provided)"
|
|
|
|
# Store original coordinates in case we need to fall back
|
|
original_lat = latitude
|
|
original_lng = longitude
|
|
|
|
begin
|
|
# Use OpenStreetMap Nominatim API for geocoding
|
|
encoded_address = URI.encode_www_form_component(venue_address.strip)
|
|
uri = URI("https://nominatim.openstreetmap.org/search?q=#{encoded_address}&format=json&limit=1&addressdetails=1")
|
|
|
|
http = Net::HTTP.new(uri.host, uri.port)
|
|
http.use_ssl = true
|
|
|
|
request = Net::HTTP::Get.new(uri)
|
|
request["User-Agent"] = "AperoNight Event Platform/1.0 (https://aperonight.com)"
|
|
request["Accept"] = "application/json"
|
|
|
|
response = http.request(request)
|
|
|
|
if response.code == "200"
|
|
data = JSON.parse(response.body)
|
|
|
|
if data.any?
|
|
result = data.first
|
|
self.latitude = result["lat"].to_f.round(6)
|
|
self.longitude = result["lon"].to_f.round(6)
|
|
Rails.logger.info "Server-side geocoded '#{venue_address}' to coordinates: #{latitude}, #{longitude}"
|
|
return
|
|
end
|
|
end
|
|
|
|
# If we reach here, geocoding failed
|
|
handle_geocoding_failure(original_lat, original_lng)
|
|
|
|
rescue => e
|
|
Rails.logger.error "Server-side geocoding failed for '#{venue_address}': #{e.message}"
|
|
handle_geocoding_failure(original_lat, original_lng)
|
|
end
|
|
end
|
|
|
|
# Handle geocoding failure with fallback strategies
|
|
def handle_geocoding_failure(original_lat, original_lng)
|
|
# Strategy 1: Keep existing coordinates if this is an update
|
|
if original_lat.present? && original_lng.present?
|
|
self.latitude = original_lat
|
|
self.longitude = original_lng
|
|
Rails.logger.warn "Geocoding failed for '#{venue_address}', keeping existing coordinates: #{latitude}, #{longitude}"
|
|
return
|
|
end
|
|
|
|
# Strategy 2: Try to extract country/city and use approximate coordinates
|
|
fallback_coordinates = get_fallback_coordinates_from_address
|
|
if fallback_coordinates
|
|
self.latitude = fallback_coordinates[:lat]
|
|
self.longitude = fallback_coordinates[:lng]
|
|
Rails.logger.warn "Using fallback coordinates for '#{venue_address}': #{latitude}, #{longitude}"
|
|
return
|
|
end
|
|
|
|
# Strategy 3: Use default coordinates (center of France) as last resort
|
|
# This ensures the event can still be created
|
|
self.latitude = 46.603354 # Center of France
|
|
self.longitude = 1.888334
|
|
Rails.logger.warn "Using default coordinates for '#{venue_address}' due to geocoding failure: #{latitude}, #{longitude}"
|
|
end
|
|
|
|
# Extract country/city from address and return approximate coordinates
|
|
def get_fallback_coordinates_from_address
|
|
address_lower = venue_address.downcase
|
|
|
|
# Common French cities with approximate coordinates
|
|
french_cities = {
|
|
"paris" => { lat: 48.8566, lng: 2.3522 },
|
|
"lyon" => { lat: 45.7640, lng: 4.8357 },
|
|
"marseille" => { lat: 43.2965, lng: 5.3698 },
|
|
"toulouse" => { lat: 43.6047, lng: 1.4442 },
|
|
"nice" => { lat: 43.7102, lng: 7.2620 },
|
|
"nantes" => { lat: 47.2184, lng: -1.5536 },
|
|
"montpellier" => { lat: 43.6110, lng: 3.8767 },
|
|
"strasbourg" => { lat: 48.5734, lng: 7.7521 },
|
|
"bordeaux" => { lat: 44.8378, lng: -0.5792 },
|
|
"lille" => { lat: 50.6292, lng: 3.0573 }
|
|
}
|
|
|
|
# Check if any known city is mentioned in the address
|
|
french_cities.each do |city, coords|
|
|
if address_lower.include?(city)
|
|
return coords
|
|
end
|
|
end
|
|
|
|
# Check for common country indicators
|
|
if address_lower.include?("france") || address_lower.include?("french")
|
|
return { lat: 46.603354, lng: 1.888334 } # Center of France
|
|
end
|
|
|
|
nil
|
|
end
|
|
end
|