app/controllers/trace_controller.rb

   1 class TraceController < ApplicationController
   2   layout 'site'
   3
   4   skip_before_filter :verify_authenticity_token, :only => [:api_create, :api_read, :api_update, :api_delete, :api_data]
   5   before_filter :authorize_web
   6   before_filter :set_locale
   7   before_filter :require_user, :only => [:mine, :create, :edit, :delete]
   8   before_filter :authorize, :only => [:api_create, :api_read, :api_update, :api_delete, :api_data]
   9   before_filter :check_database_readable, :except => [:api_read, :api_data]
  10   before_filter :check_database_writable, :only => [:create, :edit, :delete, :api_create, :api_update, :api_delete]
  11   before_filter :check_api_readable, :only => [:api_read, :api_data]
  12   before_filter :check_api_writable, :only => [:api_create, :api_update, :api_delete]
  13   before_filter :require_allow_read_gpx, :only => [:api_read, :api_data]
  14   before_filter :require_allow_write_gpx, :only => [:api_create, :api_update, :api_delete]
  15   before_filter :offline_warning, :only => [:mine, :view]
  16   before_filter :offline_redirect, :only => [:create, :edit, :delete, :data, :api_create, :api_delete, :api_data]
  17   around_filter :api_call_handle_error, :only => [:api_create, :api_read, :api_update, :api_delete, :api_data]
  18
  19   # Counts and selects pages of GPX traces for various criteria (by user, tags, public etc.).
  20   #  target_user - if set, specifies the user to fetch traces for.  if not set will fetch all traces
  21   def list
  22     # from display name, pick up user id if one user's traces only
  23     display_name = params[:display_name]
  24     if !display_name.blank?
  25       target_user = User.active.where(:display_name => display_name).first
  26       if target_user.nil?
  27         render_unknown_user display_name
  28         return
  29       end
  30     end
  31
  32     # set title
  33     if target_user.nil?
  34       @title = t 'trace.list.public_traces'
  35     elsif @user and @user == target_user
  36       @title = t 'trace.list.your_traces'
  37     else
  38       @title = t 'trace.list.public_traces_from', :user => target_user.display_name
  39     end
  40
  41     @title += t 'trace.list.tagged_with', :tags => params[:tag] if params[:tag]
  42
  43     # four main cases:
  44     # 1 - all traces, logged in = all public traces + all user's (i.e + all mine)
  45     # 2 - all traces, not logged in = all public traces
  46     # 3 - user's traces, logged in as same user = all user's traces
  47     # 4 - user's traces, not logged in as that user = all user's public traces
  48     if target_user.nil? # all traces
  49       if @user
  50         @traces = Trace.visible_to(@user) #1
  51       else
  52         @traces = Trace.public #2
  53       end
  54     else
  55       if @user and @user == target_user
  56         @traces = @user.traces #3 (check vs user id, so no join + can't pick up non-public traces by changing name)
  57       else
  58         @traces = target_user.traces.public #4
  59       end
  60     end
  61
  62     if params[:tag]
  63       @traces = @traces.tagged(params[:tag])
  64     end
  65
  66     @page = (params[:page] || 1).to_i
  67     @page_size = 20
  68
  69     @traces = @traces.visible
  70     @traces = @traces.order("timestamp DESC")
  71     @traces = @traces.offset((@page - 1) * @page_size)
  72     @traces = @traces.limit(@page_size)
  73     @traces = @traces.includes(:user, :tags)
  74
  75     # put together SET of tags across traces, for related links
  76     tagset = Hash.new
  77     @traces.each do |trace|
  78       trace.tags.reload if params[:tag] # if searched by tag, ActiveRecord won't bring back other tags, so do explicitly here
  79       trace.tags.each do |tag|
  80         tagset[tag.tag] = tag.tag
  81       end
  82     end
  83
  84     # final helper vars for view
  85     @target_user = target_user
  86     @display_name = target_user.display_name if target_user
  87     @all_tags = tagset.values
  88   end
  89
  90   def mine
  91     redirect_to :action => :list, :display_name => @user.display_name
  92   end
  93
  94   def view
  95     @trace = Trace.find(params[:id])
  96
  97     if @trace and @trace.visible? and
  98        (@trace.public? or @trace.user == @user)
  99       @title = t 'trace.view.title', :name => @trace.name
 100     else
 101       flash[:error] = t 'trace.view.trace_not_found'
 102       redirect_to :controller => 'trace', :action => 'list'
 103     end
 104   rescue ActiveRecord::RecordNotFound
 105     flash[:error] = t 'trace.view.trace_not_found'
 106     redirect_to :controller => 'trace', :action => 'list'
 107   end
 108
 109   def create
 110     if params[:trace]
 111       logger.info(params[:trace][:gpx_file].class.name)
 112
 113       if params[:trace][:gpx_file].respond_to?(:read)
 114         begin
 115           do_create(params[:trace][:gpx_file], params[:trace][:tagstring],
 116                     params[:trace][:description], params[:trace][:visibility])
 117         rescue => ex
 118           logger.debug ex
 119         end
 120
 121         if @trace.id
 122           logger.info("id is #{@trace.id}")
 123           flash[:notice] = t 'trace.create.trace_uploaded'
 124
 125           if @user.traces.where(:inserted => false).count > 4
 126             flash[:warning] = t 'trace.trace_header.traces_waiting', :count => @user.traces.where(:inserted => false).count
 127           end
 128
 129           redirect_to :action => :list, :display_name => @user.display_name
 130         end
 131       else
 132         @trace = Trace.new({:name => "Dummy",
 133                             :tagstring => params[:trace][:tagstring],
 134                             :description => params[:trace][:description],
 135                             :visibility => params[:trace][:visibility],
 136                             :inserted => false, :user => @user,
 137                             :timestamp => Time.now.getutc})
 138         @trace.valid?
 139         @trace.errors.add(:gpx_file, "can't be blank")
 140       end
 141     else
 142       @trace = Trace.new(:visibility => default_visibility)
 143     end
 144
 145     @title = t 'trace.create.upload_trace'
 146   end
 147
 148   def data
 149     trace = Trace.find(params[:id])
 150
 151     if trace.visible? and (trace.public? or (@user and @user == trace.user))
 152       if Acl.no_trace_download(request.remote_ip)
 153         render :text => "", :status => :forbidden
 154       elsif request.format == Mime::XML or request.format == Mime::GPX
 155         send_file(trace.xml_file, :filename => "#{trace.id}.xml", :type => request.format.to_s, :disposition => 'attachment')
 156       else
 157         send_file(trace.trace_name, :filename => "#{trace.id}#{trace.extension_name}", :type => trace.mime_type, :disposition => 'attachment')
 158       end
 159     else
 160       render :text => "", :status => :not_found
 161     end
 162   rescue ActiveRecord::RecordNotFound
 163     render :text => "", :status => :not_found
 164   end
 165
 166   def edit
 167     @trace = Trace.find(params[:id])
 168
 169     if not @trace.visible?
 170       render :text => "", :status => :not_found
 171     elsif @user.nil? or @trace.user != @user
 172       render :text => "", :status => :forbidden
 173     else
 174       @title = t 'trace.edit.title', :name => @trace.name
 175
 176       if params[:trace]
 177         @trace.description = params[:trace][:description]
 178         @trace.tagstring = params[:trace][:tagstring]
 179         @trace.visibility = params[:trace][:visibility]
 180         if @trace.save
 181           redirect_to :action => 'view', :display_name => @user.display_name
 182         end
 183       end
 184     end
 185   rescue ActiveRecord::RecordNotFound
 186     render :text => "", :status => :not_found
 187   end
 188
 189   def delete
 190     trace = Trace.find(params[:id])
 191
 192     if not trace.visible?
 193       render :text => "", :status => :not_found
 194     elsif @user.nil? or trace.user != @user
 195       render :text => "", :status => :forbidden
 196     else
 197       trace.visible = false
 198       trace.save
 199       flash[:notice] = t 'trace.delete.scheduled_for_deletion'
 200       redirect_to :action => :list, :display_name => @user.display_name
 201     end
 202   rescue ActiveRecord::RecordNotFound
 203     render :text => "", :status => :not_found
 204   end
 205
 206   def georss
 207     @traces = Trace.public.visible
 208
 209     if params[:display_name]
 210       @traces = @traces.joins(:user).where(:users => {:display_name => params[:display_name]})
 211     end
 212
 213     if params[:tag]
 214       @traces = @traces.tagged(params[:tag])
 215     end
 216
 217     @traces = @traces.order("timestamp DESC")
 218     @traces = @traces.limit(20)
 219     @traces = @traces.includes(:user)
 220   end
 221
 222   def picture
 223     trace = Trace.find(params[:id])
 224
 225     if trace.inserted?
 226       if trace.public? or (@user and @user == trace.user)
 227         expires_in 7.days, :private => !trace.public?, :public => trace.public?
 228         send_file(trace.large_picture_name, :filename => "#{trace.id}.gif", :type => 'image/gif', :disposition => 'inline')
 229       else
 230         render :text => "", :status => :forbidden
 231       end
 232     else
 233       render :text => "", :status => :not_found
 234     end
 235   rescue ActiveRecord::RecordNotFound
 236     render :text => "", :status => :not_found
 237   end
 238
 239   def icon
 240     trace = Trace.find(params[:id])
 241
 242     if trace.inserted?
 243       if trace.public? or (@user and @user == trace.user)
 244         expires_in 7.days, :private => !trace.public?, :public => trace.public?
 245         send_file(trace.icon_picture_name, :filename => "#{trace.id}_icon.gif", :type => 'image/gif', :disposition => 'inline')
 246       else
 247         render :text => "", :status => :forbidden
 248       end
 249     else
 250       render :text => "", :status => :not_found
 251     end
 252   rescue ActiveRecord::RecordNotFound
 253     render :text => "", :status => :not_found
 254   end
 255
 256   def api_read
 257     trace = Trace.visible.find(params[:id])
 258
 259     if trace.public? or trace.user == @user
 260       render :text => trace.to_xml.to_s, :content_type => "text/xml"
 261     else
 262       render :text => "", :status => :forbidden
 263     end
 264   end
 265
 266   def api_update
 267     trace = Trace.visible.find(params[:id])
 268
 269     if trace.user == @user
 270       new_trace = Trace.from_xml(request.raw_post)
 271
 272       unless new_trace and new_trace.id == trace.id
 273         raise OSM::APIBadUserInput.new("The id in the url (#{trace.id}) is not the same as provided in the xml (#{new_trace.id})")
 274       end
 275
 276       trace.description = new_trace.description
 277       trace.tags = new_trace.tags
 278       trace.visibility = new_trace.visibility
 279       trace.save!
 280
 281       render :text => "", :status => :ok
 282     else
 283       render :text => "", :status => :forbidden
 284     end
 285   end
 286
 287   def api_delete
 288     trace = Trace.visible.find(params[:id])
 289
 290     if trace.user == @user
 291       trace.visible = false
 292       trace.save!
 293
 294       render :text => "", :status => :ok
 295     else
 296       render :text => "", :status => :forbidden
 297     end
 298   end
 299
 300   def api_data
 301     trace = Trace.find(params[:id])
 302
 303     if trace.public? or trace.user == @user
 304       if request.format == Mime::XML or request.format == Mime::GPX
 305         send_file(trace.xml_file, :filename => "#{trace.id}.xml", :type => request.format.to_s, :disposition => 'attachment')
 306       else
 307         send_file(trace.trace_name, :filename => "#{trace.id}#{trace.extension_name}", :type => trace.mime_type, :disposition => 'attachment')
 308       end
 309     else
 310       render :text => "", :status => :forbidden
 311     end
 312   end
 313
 314   def api_create
 315     tags = params[:tags] || ""
 316     description = params[:description] || ""
 317     visibility = params[:visibility]
 318
 319     if visibility.nil?
 320       if params[:public] && params[:public].to_i.nonzero?
 321         visibility = "public"
 322       else
 323         visibility = "private"
 324       end
 325     end
 326
 327     if params[:file].respond_to?(:read)
 328       do_create(params[:file], tags, description, visibility)
 329
 330       if @trace.id
 331         render :text => @trace.id.to_s, :content_type => "text/plain"
 332       elsif @trace.valid?
 333         render :text => "", :status => :internal_server_error
 334       else
 335         render :text => "", :status => :bad_request
 336       end
 337     else
 338       render :text => "", :status => :bad_request
 339     end
 340   end
 341
 342 private
 343
 344   def do_create(file, tags, description, visibility)
 345     # Sanitise the user's filename
 346     name = file.original_filename.gsub(/[^a-zA-Z0-9.]/, '_')
 347
 348     # Get a temporary filename...
 349     filename = "/tmp/#{rand}"
 350
 351     # ...and save the uploaded file to that location
 352     File.open(filename, "wb") { |f| f.write(file.read) }
 353
 354     # Create the trace object, falsely marked as already
 355     # inserted to stop the import daemon trying to load it
 356     @trace = Trace.new(
 357       :name => name,
 358       :tagstring => tags,
 359       :description => description,
 360       :visibility => visibility,
 361       :inserted => true,
 362       :user => @user,
 363       :timestamp => Time.now.getutc
 364     )
 365
 366     Trace.transaction do
 367       begin
 368         # Save the trace object
 369         @trace.save!
 370
 371         # Rename the temporary file to the final name
 372         FileUtils.mv(filename, @trace.trace_name)
 373       rescue Exception => ex
 374         # Remove the file as we have failed to update the database
 375         FileUtils.rm_f(filename)
 376
 377         # Pass the exception on
 378         raise
 379       end
 380
 381       begin
 382         # Clear the inserted flag to make the import daemon load the trace
 383         @trace.inserted = false
 384         @trace.save!
 385       rescue Exception => ex
 386         # Remove the file as we have failed to update the database
 387         FileUtils.rm_f(@trace.trace_name)
 388
 389         # Pass the exception on
 390         raise
 391       end
 392     end
 393
 394     # Finally save the user's preferred privacy level
 395     if pref = @user.preferences.where(:k => "gps.trace.visibility").first
 396       pref.v = visibility
 397       pref.save
 398     else
 399       @user.preferences.create(:k => "gps.trace.visibility", :v => visibility)
 400     end
 401
 402   end
 403
 404   def offline_warning
 405     flash.now[:warning] = t 'trace.offline_warning.message' if STATUS == :gpx_offline
 406   end
 407
 408   def offline_redirect
 409     redirect_to :action => :offline if STATUS == :gpx_offline
 410   end
 411
 412   def default_visibility
 413     visibility = @user.preferences.where(:k => "gps.trace.visibility").first
 414
 415     if visibility
 416       visibility.v
 417     elsif @user.preferences.where(:k => "gps.trace.public", :v => "default").first.nil?
 418       "private"
 419     else
 420       "public"
 421     end
 422   end
 423
 424 end