]> git.openstreetmap.org Git - rails.git/blob - app/models/trace.rb
feefc077387b9ca32ea05ad247c2184de992ae8d
[rails.git] / 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