app/models/trace.rb

   1 # == Schema Information
   2 #
   3 # Table name: gpx_files
   4 #
   5 #  id          :integer          not null, primary key
   6 #  user_id     :integer          not null
   7 #  visible     :boolean          default(TRUE), not null
   8 #  name        :string           default(""), not null
   9 #  size        :integer
  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 < ActiveRecord::Base
  29   self.table_name = "gpx_files"
  30
  31   belongs_to :user, :counter_cache => true
  32   has_many :tags, :class_name => "Tracetag", :foreign_key => "gpx_id", :dependent => :delete_all
  33   has_many :points, :class_name => "Tracepoint", :foreign_key => "gpx_id", :dependent => :delete_all
  34
  35   scope :visible, -> { where(:visible => true) }
  36   scope :visible_to, ->(u) { visible.where("visibility IN ('public', 'identifiable') OR user_id = ?", u) }
  37   scope :visible_to_all, -> { where(:visibility => %w[public identifiable]) }
  38   scope :tagged, ->(t) { joins(:tags).where(:gpx_file_tags => { :tag => t }) }
  39
  40   validates :user, :presence => true, :associated => true
  41   validates :name, :presence => true, :length => 1..255, :characters => true
  42   validates :description, :presence => { :on => :create }, :length => 1..255, :characters => true
  43   validates :timestamp, :presence => true
  44   validates :visibility, :inclusion => %w[private public trackable identifiable]
  45
  46   def destroy
  47     super
  48     FileUtils.rm_f(trace_name)
  49     FileUtils.rm_f(icon_picture_name)
  50     FileUtils.rm_f(large_picture_name)
  51   end
  52
  53   def tagstring
  54     tags.collect(&:tag).join(", ")
  55   end
  56
  57   def tagstring=(s)
  58     self.tags = if s.include? ","
  59                   s.split(/\s*,\s*/).reject { |tag| tag =~ /^\s*$/ }.collect do |tag|
  60                     tt = Tracetag.new
  61                     tt.tag = tag
  62                     tt
  63                   end
  64                 else
  65                   # do as before for backwards compatibility:
  66                   s.split.collect do |tag|
  67                     tt = Tracetag.new
  68                     tt.tag = tag
  69                     tt
  70                   end
  71                 end
  72   end
  73
  74   def public?
  75     visibility == "public" || visibility == "identifiable"
  76   end
  77
  78   def trackable?
  79     visibility == "trackable" || visibility == "identifiable"
  80   end
  81
  82   def identifiable?
  83     visibility == "identifiable"
  84   end
  85
  86   def large_picture=(data)
  87     f = File.new(large_picture_name, "wb")
  88     f.syswrite(data)
  89     f.close
  90   end
  91
  92   def icon_picture=(data)
  93     f = File.new(icon_picture_name, "wb")
  94     f.syswrite(data)
  95     f.close
  96   end
  97
  98   def large_picture
  99     f = File.new(large_picture_name, "rb")
 100     data = f.sysread(File.size(f.path))
 101     f.close
 102     data
 103   end
 104
 105   def icon_picture
 106     f = File.new(icon_picture_name, "rb")
 107     data = f.sysread(File.size(f.path))
 108     f.close
 109     data
 110   end
 111
 112   def large_picture_name
 113     "#{GPX_IMAGE_DIR}/#{id}.gif"
 114   end
 115
 116   def icon_picture_name
 117     "#{GPX_IMAGE_DIR}/#{id}_icon.gif"
 118   end
 119
 120   def trace_name
 121     "#{GPX_TRACE_DIR}/#{id}.gpx"
 122   end
 123
 124   def mime_type
 125     filetype = `/usr/bin/file -Lbz #{trace_name}`.chomp
 126     gzipped = filetype =~ /gzip compressed/
 127     bzipped = filetype =~ /bzip2 compressed/
 128     zipped = filetype =~ /Zip archive/
 129     tarred = filetype =~ /tar archive/
 130
 131     mimetype = if gzipped
 132                  "application/x-gzip"
 133                elsif bzipped
 134                  "application/x-bzip2"
 135                elsif zipped
 136                  "application/x-zip"
 137                elsif tarred
 138                  "application/x-tar"
 139                else
 140                  "application/gpx+xml"
 141                end
 142
 143     mimetype
 144   end
 145
 146   def extension_name
 147     filetype = `/usr/bin/file -Lbz #{trace_name}`.chomp
 148     gzipped = filetype =~ /gzip compressed/
 149     bzipped = filetype =~ /bzip2 compressed/
 150     zipped = filetype =~ /Zip archive/
 151     tarred = filetype =~ /tar archive/
 152
 153     extension = if tarred && gzipped
 154                   ".tar.gz"
 155                 elsif tarred && bzipped
 156                   ".tar.bz2"
 157                 elsif tarred
 158                   ".tar"
 159                 elsif gzipped
 160                   ".gpx.gz"
 161                 elsif bzipped
 162                   ".gpx.bz2"
 163                 elsif zipped
 164                   ".zip"
 165                 else
 166                   ".gpx"
 167                 end
 168
 169     extension
 170   end
 171
 172   def to_xml
 173     doc = OSM::API.new.get_xml_doc
 174     doc.root << to_xml_node
 175     doc
 176   end
 177
 178   def to_xml_node
 179     el1 = XML::Node.new "gpx_file"
 180     el1["id"] = id.to_s
 181     el1["name"] = name.to_s
 182     el1["lat"] = latitude.to_s if inserted
 183     el1["lon"] = longitude.to_s if inserted
 184     el1["user"] = user.display_name
 185     el1["visibility"] = visibility
 186     el1["pending"] = inserted ? "false" : "true"
 187     el1["timestamp"] = timestamp.xmlschema
 188
 189     el2 = XML::Node.new "description"
 190     el2 << description
 191     el1 << el2
 192
 193     tags.each do |tag|
 194       el2 = XML::Node.new("tag")
 195       el2 << tag.tag
 196       el1 << el2
 197     end
 198
 199     el1
 200   end
 201
 202   def update_from_xml(xml, create = false)
 203     p = XML::Parser.string(xml, :options => XML::Parser::Options::NOERROR)
 204     doc = p.parse
 205
 206     doc.find("//osm/gpx_file").each do |pt|
 207       return update_from_xml_node(pt, create)
 208     end
 209
 210     raise OSM::APIBadXMLError.new("trace", xml, "XML doesn't contain an osm/gpx_file element.")
 211   rescue LibXML::XML::Error, ArgumentError => ex
 212     raise OSM::APIBadXMLError.new("trace", xml, ex.message)
 213   end
 214
 215   def update_from_xml_node(pt, create = false)
 216     raise OSM::APIBadXMLError.new("trace", pt, "visibility missing") if pt["visibility"].nil?
 217
 218     self.visibility = pt["visibility"]
 219
 220     unless create
 221       raise OSM::APIBadXMLError.new("trace", pt, "ID is required when updating.") if pt["id"].nil?
 222
 223       id = pt["id"].to_i
 224       # .to_i will return 0 if there is no number that can be parsed.
 225       # We want to make sure that there is no id with zero anyway
 226       raise OSM::APIBadUserInput, "ID of trace cannot be zero when updating." if id.zero?
 227       raise OSM::APIBadUserInput, "The id in the url (#{self.id}) is not the same as provided in the xml (#{id})" unless self.id == id
 228     end
 229
 230     # We don't care about the time, as it is explicitly set on create/update/delete
 231     # We don't care about the visibility as it is implicit based on the action
 232     # and set manually before the actual delete
 233     self.visible = true
 234
 235     description = pt.find("description").first
 236     raise OSM::APIBadXMLError.new("trace", pt, "description missing") if description.nil?
 237
 238     self.description = description.content
 239
 240     self.tags = pt.find("tag").collect do |tag|
 241       Tracetag.new(:tag => tag.content)
 242     end
 243   end
 244
 245   def xml_file
 246     # TODO: *nix specific, could do to work on windows... would be functionally inferior though - check for '.gz'
 247     filetype = `/usr/bin/file -Lbz #{trace_name}`.chomp
 248     gzipped = filetype =~ /gzip compressed/
 249     bzipped = filetype =~ /bzip2 compressed/
 250     zipped = filetype =~ /Zip archive/
 251     tarred = filetype =~ /tar archive/
 252
 253     if gzipped || bzipped || zipped || tarred
 254       tmpfile = Tempfile.new("trace.#{id}")
 255
 256       if tarred && gzipped
 257         system("tar -zxOf #{trace_name} > #{tmpfile.path}")
 258       elsif tarred && bzipped
 259         system("tar -jxOf #{trace_name} > #{tmpfile.path}")
 260       elsif tarred
 261         system("tar -xOf #{trace_name} > #{tmpfile.path}")
 262       elsif gzipped
 263         system("gunzip -c #{trace_name} > #{tmpfile.path}")
 264       elsif bzipped
 265         system("bunzip2 -c #{trace_name} > #{tmpfile.path}")
 266       elsif zipped
 267         system("unzip -p #{trace_name} -x '__MACOSX/*' > #{tmpfile.path} 2> /dev/null")
 268       end
 269
 270       tmpfile.unlink
 271
 272       file = tmpfile.file
 273     else
 274       file = File.open(trace_name)
 275     end
 276
 277     file
 278   end
 279
 280   def import
 281     logger.info("GPX Import importing #{name} (#{id}) from #{user.email}")
 282
 283     gpx = ::GPX::File.new(xml_file)
 284
 285     f_lat = 0
 286     f_lon = 0
 287     first = true
 288
 289     # If there are any existing points for this trace then delete them
 290     Tracepoint.where(:gpx_id => id).delete_all
 291
 292     gpx.points do |point|
 293       if first
 294         f_lat = point.latitude
 295         f_lon = point.longitude
 296         first = false
 297       end
 298
 299       tp = Tracepoint.new
 300       tp.lat = point.latitude
 301       tp.lon = point.longitude
 302       tp.altitude = point.altitude
 303       tp.timestamp = point.timestamp
 304       tp.gpx_id = id
 305       tp.trackid = point.segment
 306       tp.save!
 307     end
 308
 309     if gpx.actual_points.positive?
 310       max_lat = Tracepoint.where(:gpx_id => id).maximum(:latitude)
 311       min_lat = Tracepoint.where(:gpx_id => id).minimum(:latitude)
 312       max_lon = Tracepoint.where(:gpx_id => id).maximum(:longitude)
 313       min_lon = Tracepoint.where(:gpx_id => id).minimum(:longitude)
 314
 315       max_lat = max_lat.to_f / 10000000
 316       min_lat = min_lat.to_f / 10000000
 317       max_lon = max_lon.to_f / 10000000
 318       min_lon = min_lon.to_f / 10000000
 319
 320       self.latitude = f_lat
 321       self.longitude = f_lon
 322       self.large_picture = gpx.picture(min_lat, min_lon, max_lat, max_lon, gpx.actual_points)
 323       self.icon_picture = gpx.icon(min_lat, min_lon, max_lat, max_lon)
 324       self.size = gpx.actual_points
 325       self.inserted = true
 326       save!
 327     end
 328
 329     logger.info "done trace #{id}"
 330
 331     gpx
 332   end
 333 end