app/models/trace.rb

   1 # == Schema Information
   2 #
   3 # Table name: gpx_files
   4 #
   5 #  id          :bigint(8)        not null, primary key
   6 #  user_id     :bigint(8)        not null
   7 #  visible     :boolean          default(TRUE), not null
   8 #  name        :string           default(""), not null
   9 #  size        :bigint(8)
  10 #  latitude    :float
  11 #  longitude   :float
  12 #  timestamp   :datetime         not null
  13 #  description :string           default(""), not null
  14 #  inserted    :boolean          not null
  15 #  visibility  :enum             default("public"), not null
  16 #
  17 # Indexes
  18 #
  19 #  gpx_files_timestamp_idx           (timestamp)
  20 #  gpx_files_user_id_idx             (user_id)
  21 #  gpx_files_visible_visibility_idx  (visible,visibility)
  22 #
  23 # Foreign Keys
  24 #
  25 #  gpx_files_user_id_fkey  (user_id => users.id)
  26 #
  27
  28 class Trace < ApplicationRecord
  29   require "open3"
  30
  31   self.table_name = "gpx_files"
  32
  33   belongs_to :user, :counter_cache => true
  34   has_many :tags, :class_name => "Tracetag", :foreign_key => "gpx_id", :dependent => :delete_all, :inverse_of => "trace"
  35   has_many :points, :class_name => "Tracepoint", :foreign_key => "gpx_id", :dependent => :delete_all, :inverse_of => "trace"
  36
  37   scope :visible, -> { where(:visible => true) }
  38   scope :visible_to, ->(u) { visible.where("visibility IN ('public', 'identifiable') OR user_id = ?", u) }
  39   scope :visible_to_all, -> { where(:visibility => %w[public identifiable]) }
  40   scope :tagged, ->(t) { joins(:tags).where(:gpx_file_tags => { :tag => t }) }
  41
  42   has_one_attached :file, :service => Settings.trace_file_storage
  43   has_one_attached :image, :service => Settings.trace_image_storage
  44   has_one_attached :icon, :service => Settings.trace_icon_storage
  45
  46   validates :user, :presence => true, :associated => true
  47   validates :name, :presence => true, :length => 1..255, :characters => true
  48   validates :description, :presence => { :on => :create }, :length => 1..255, :characters => true
  49   validates :timestamp, :presence => true
  50   validates :visibility, :inclusion => %w[private public trackable identifiable]
  51
  52   after_destroy :remove_files
  53   after_save :set_filename
  54
  55   def tagstring
  56     tags.collect(&:tag).join(", ")
  57   end
  58
  59   def tagstring=(s)
  60     self.tags = if s.include? ","
  61                   s.split(/\s*,\s*/).grep_v(/^\s*$/).collect do |tag|
  62                     tt = Tracetag.new
  63                     tt.tag = tag
  64                     tt
  65                   end
  66                 else
  67                   # do as before for backwards compatibility:
  68                   s.split.collect do |tag|
  69                     tt = Tracetag.new
  70                     tt.tag = tag
  71                     tt
  72                   end
  73                 end
  74   end
  75
  76   def file=(attachable)
  77     case attachable
  78     when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
  79       super(:io => attachable,
  80             :filename => attachable.original_filename,
  81             :content_type => content_type(attachable.path),
  82             :identify => false)
  83     else
  84       super(attachable)
  85     end
  86   end
  87
  88   def public?
  89     visibility == "public" || visibility == "identifiable"
  90   end
  91
  92   def trackable?
  93     visibility == "trackable" || visibility == "identifiable"
  94   end
  95
  96   def identifiable?
  97     visibility == "identifiable"
  98   end
  99
 100   def large_picture
 101     if image.attached?
 102       data = image.blob.download
 103     else
 104       f = File.new(large_picture_name, "rb")
 105       data = f.sysread(File.size(f.path))
 106       f.close
 107     end
 108
 109     data
 110   end
 111
 112   def icon_picture
 113     if icon.attached?
 114       data = icon.blob.download
 115     else
 116       f = File.new(icon_picture_name, "rb")
 117       data = f.sysread(File.size(f.path))
 118       f.close
 119     end
 120
 121     data
 122   end
 123
 124   def large_picture_name
 125     "#{Settings.gpx_image_dir}/#{id}.gif"
 126   end
 127
 128   def icon_picture_name
 129     "#{Settings.gpx_image_dir}/#{id}_icon.gif"
 130   end
 131
 132   def trace_name
 133     "#{Settings.gpx_trace_dir}/#{id}.gpx"
 134   end
 135
 136   def mime_type
 137     if file.attached?
 138       file.content_type
 139     else
 140       content_type(trace_name)
 141     end
 142   end
 143
 144   def extension_name
 145     case mime_type
 146     when "application/x-tar+gzip" then ".tar.gz"
 147     when "application/x-tar+x-bzip2" then ".tar.bz2"
 148     when "application/x-tar" then ".tar"
 149     when "application/zip" then ".zip"
 150     when "application/gzip" then ".gpx.gz"
 151     when "application/x-bzip2" then ".gpx.bz2"
 152     else ".gpx"
 153     end
 154   end
 155
 156   def update_from_xml(xml, create: false)
 157     p = XML::Parser.string(xml, :options => XML::Parser::Options::NOERROR)
 158     doc = p.parse
 159     pt = doc.find_first("//osm/gpx_file")
 160
 161     if pt
 162       update_from_xml_node(pt, :create => create)
 163     else
 164       raise OSM::APIBadXMLError.new("trace", xml, "XML doesn't contain an osm/gpx_file element.")
 165     end
 166   rescue LibXML::XML::Error, ArgumentError => e
 167     raise OSM::APIBadXMLError.new("trace", xml, e.message)
 168   end
 169
 170   def update_from_xml_node(pt, create: false)
 171     raise OSM::APIBadXMLError.new("trace", pt, "visibility missing") if pt["visibility"].nil?
 172
 173     self.visibility = pt["visibility"]
 174
 175     unless create
 176       raise OSM::APIBadXMLError.new("trace", pt, "ID is required when updating.") if pt["id"].nil?
 177
 178       id = pt["id"].to_i
 179       # .to_i will return 0 if there is no number that can be parsed.
 180       # We want to make sure that there is no id with zero anyway
 181       raise OSM::APIBadUserInput, "ID of trace cannot be zero when updating." if id.zero?
 182       raise OSM::APIBadUserInput, "The id in the url (#{self.id}) is not the same as provided in the xml (#{id})" unless self.id == id
 183     end
 184
 185     # We don't care about the time, as it is explicitly set on create/update/delete
 186     # We don't care about the visibility as it is implicit based on the action
 187     # and set manually before the actual delete
 188     self.visible = true
 189
 190     description = pt.find("description").first
 191     raise OSM::APIBadXMLError.new("trace", pt, "description missing") if description.nil?
 192
 193     self.description = description.content
 194
 195     self.tags = pt.find("tag").collect do |tag|
 196       Tracetag.new(:tag => tag.content)
 197     end
 198   end
 199
 200   def xml_file
 201     with_trace_file do |trace_name|
 202       filetype = Open3.capture2("/usr/bin/file", "-Lbz", trace_name).first.chomp
 203       gzipped = filetype.include?("gzip compressed")
 204       bzipped = filetype.include?("bzip2 compressed")
 205       zipped = filetype.include?("Zip archive")
 206       tarred = filetype.include?("tar archive")
 207
 208       if gzipped || bzipped || zipped || tarred
 209         file = Tempfile.new("trace.#{id}")
 210
 211         if tarred && gzipped
 212           system("tar", "-zxOf", trace_name, :out => file.path)
 213         elsif tarred && bzipped
 214           system("tar", "-jxOf", trace_name, :out => file.path)
 215         elsif tarred
 216           system("tar", "-xOf", trace_name, :out => file.path)
 217         elsif gzipped
 218           system("gunzip", "-c", trace_name, :out => file.path)
 219         elsif bzipped
 220           system("bunzip2", "-c", trace_name, :out => file.path)
 221         elsif zipped
 222           system("unzip", "-p", trace_name, "-x", "__MACOSX/*", :out => file.path, :err => "/dev/null")
 223         end
 224
 225         file.unlink
 226       else
 227         file = File.open(trace_name)
 228       end
 229
 230       file
 231     end
 232   end
 233
 234   def import
 235     logger.info("GPX Import importing #{name} (#{id}) from #{user.email}")
 236
 237     with_trace_file do |trace_name|
 238       gpx = GPX::File.new(trace_name)
 239
 240       f_lat = 0
 241       f_lon = 0
 242       first = true
 243
 244       # If there are any existing points for this trace then delete them
 245       Tracepoint.where(:gpx_id => id).delete_all
 246
 247       gpx.points.each_slice(1_000) do |points|
 248         # Gather the trace points together for a bulk import
 249         tracepoints = []
 250
 251         points.each do |point|
 252           if first
 253             f_lat = point.latitude
 254             f_lon = point.longitude
 255             first = false
 256           end
 257
 258           tp = Tracepoint.new
 259           tp.lat = point.latitude
 260           tp.lon = point.longitude
 261           tp.altitude = point.altitude
 262           tp.timestamp = point.timestamp
 263           tp.gpx_id = id
 264           tp.trackid = point.segment
 265           tracepoints << tp
 266         end
 267
 268         # Run the before_save and before_create callbacks, and then import them in bulk with activerecord-import
 269         tracepoints.each do |tp|
 270           tp.run_callbacks(:save) { false }
 271           tp.run_callbacks(:create) { false }
 272         end
 273
 274         Tracepoint.import!(tracepoints)
 275       end
 276
 277       if gpx.actual_points.positive?
 278         max_lat = Tracepoint.where(:gpx_id => id).maximum(:latitude)
 279         min_lat = Tracepoint.where(:gpx_id => id).minimum(:latitude)
 280         max_lon = Tracepoint.where(:gpx_id => id).maximum(:longitude)
 281         min_lon = Tracepoint.where(:gpx_id => id).minimum(:longitude)
 282
 283         max_lat = max_lat.to_f / 10000000
 284         min_lat = min_lat.to_f / 10000000
 285         max_lon = max_lon.to_f / 10000000
 286         min_lon = min_lon.to_f / 10000000
 287
 288         self.latitude = f_lat
 289         self.longitude = f_lon
 290         image.attach(:io => gpx.picture(min_lat, min_lon, max_lat, max_lon, gpx.actual_points), :filename => "#{id}.gif", :content_type => "image/gif")
 291         icon.attach(:io => gpx.icon(min_lat, min_lon, max_lat, max_lon), :filename => "#{id}_icon.gif", :content_type => "image/gif")
 292         self.size = gpx.actual_points
 293         self.inserted = true
 294         save!
 295       end
 296
 297       logger.info "done trace #{id}"
 298
 299       gpx
 300     end
 301   end
 302
 303   def migrate_to_storage!
 304     file.attach(:io => File.open(trace_name),
 305                 :filename => name,
 306                 :content_type => content_type(trace_name),
 307                 :identify => false)
 308
 309     if inserted
 310       image.attach(:io => File.open(large_picture_name),
 311                    :filename => "#{id}.gif",
 312                    :content_type => "image/gif")
 313       icon.attach(:io => File.open(icon_picture_name),
 314                   :filename => "#{id}_icon.gif",
 315                   :content_type => "image/gif")
 316     end
 317
 318     save!
 319
 320     remove_files
 321   end
 322
 323   private
 324
 325   def content_type(file)
 326     case Open3.capture2("/usr/bin/file", "-Lbz", file).first.chomp
 327     when /.*\btar archive\b.*\bgzip\b/ then "application/x-tar+gzip"
 328     when /.*\btar archive\b.*\bbzip2\b/ then "application/x-tar+x-bzip2"
 329     when /.*\btar archive\b/ then "application/x-tar"
 330     when /.*\bZip archive\b/ then "application/zip"
 331     when /.*\bXML\b.*\bgzip\b/ then "application/gzip"
 332     when /.*\bXML\b.*\bbzip2\b/ then "application/x-bzip2"
 333     else "application/gpx+xml"
 334     end
 335   end
 336
 337   def with_trace_file
 338     if file.attached?
 339       file.open do |file|
 340         yield file.path
 341       end
 342     else
 343       yield trace_name
 344     end
 345   end
 346
 347   def set_filename
 348     file.blob.update(:filename => "#{id}#{extension_name}") if file.attached?
 349   end
 350
 351   def remove_files
 352     FileUtils.rm_f(trace_name)
 353     FileUtils.rm_f(icon_picture_name)
 354     FileUtils.rm_f(large_picture_name)
 355   end
 356 end