]> git.openstreetmap.org Git - rails.git/blob - app/controllers/users_controller.rb
Fix new rubocop warnings
[rails.git] / app / controllers / users_controller.rb
1 class UsersController < ApplicationController
2   include SessionMethods
3   include UserMethods
4
5   layout "site"
6
7   skip_before_action :verify_authenticity_token, :only => [:auth_success]
8   before_action :disable_terms_redirect, :only => [:terms, :save]
9   before_action :authorize_web
10   before_action :set_locale
11   before_action :check_database_readable
12
13   authorize_resource
14
15   before_action :check_database_writable, :only => [:new, :go_public]
16   before_action :require_cookies, :only => [:new]
17   before_action :lookup_user_by_name, :only => [:set_status, :destroy]
18   before_action :allow_thirdparty_images, :only => [:show]
19
20   def terms
21     @legale = params[:legale] || OSM.ip_to_country(request.remote_ip) || Settings.default_legale
22     @text = OSM.legal_text_for_country(@legale)
23
24     if request.xhr?
25       render :partial => "terms"
26     else
27       @title = t "users.terms.title"
28
29       if current_user&.terms_agreed?
30         # Already agreed to terms, so just show settings
31         redirect_to edit_account_path
32       elsif current_user.nil? && session[:new_user].nil?
33         redirect_to login_path(:referer => request.fullpath)
34       end
35     end
36   end
37
38   def save
39     @title = t "users.new.title"
40
41     if params[:decline] || !(params[:read_tou] && params[:read_ct])
42       if current_user
43         current_user.terms_seen = true
44
45         flash[:notice] = { :partial => "users/terms_declined_flash" } if current_user.save
46
47         referer = safe_referer(params[:referer]) if params[:referer]
48
49         redirect_to referer || edit_account_path
50       elsif params[:decline]
51         redirect_to t("users.terms.declined")
52       else
53         redirect_to :action => :terms
54       end
55     elsif current_user
56       unless current_user.terms_agreed?
57         current_user.consider_pd = params[:user][:consider_pd]
58         current_user.tou_agreed = Time.now.utc
59         current_user.terms_agreed = Time.now.utc
60         current_user.terms_seen = true
61
62         flash[:notice] = t "users.new.terms accepted" if current_user.save
63       end
64
65       referer = safe_referer(params[:referer]) if params[:referer]
66
67       redirect_to referer || edit_account_path
68     else
69       self.current_user = session.delete(:new_user)
70
71       if check_signup_allowed(current_user.email)
72         current_user.data_public = true
73         current_user.description = "" if current_user.description.nil?
74         current_user.creation_ip = request.remote_ip
75         current_user.languages = http_accept_language.user_preferred_languages
76         current_user.terms_agreed = Time.now.utc
77         current_user.tou_agreed = Time.now.utc
78         current_user.terms_seen = true
79
80         if current_user.auth_uid.blank?
81           current_user.auth_provider = nil
82           current_user.auth_uid = nil
83         end
84
85         if current_user.save
86           flash[:matomo_goal] = Settings.matomo["goals"]["signup"] if defined?(Settings.matomo)
87
88           referer = welcome_path
89
90           begin
91             uri = URI(session[:referer])
92             %r{map=(.*)/(.*)/(.*)}.match(uri.fragment) do |m|
93               editor = Rack::Utils.parse_query(uri.query).slice("editor")
94               referer = welcome_path({ "zoom" => m[1],
95                                        "lat" => m[2],
96                                        "lon" => m[3] }.merge(editor))
97             end
98           rescue StandardError
99             # Use default
100           end
101
102           if current_user.status == "active"
103             session[:referer] = referer
104             successful_login(current_user)
105           else
106             session[:token] = current_user.tokens.create.token
107             UserMailer.signup_confirm(current_user, current_user.tokens.create(:referer => referer)).deliver_later
108             redirect_to :controller => :confirmations, :action => :confirm, :display_name => current_user.display_name
109           end
110         else
111           render :action => "new", :referer => params[:referer]
112         end
113       end
114     end
115   end
116
117   def go_public
118     current_user.data_public = true
119     current_user.save
120     flash[:notice] = t "users.go_public.flash success"
121     redirect_to edit_account_path
122   end
123
124   def new
125     @title = t "users.new.title"
126     @referer = if params[:referer]
127                  safe_referer(params[:referer])
128                else
129                  session[:referer]
130                end
131
132     append_content_security_policy_directives(
133       :form_action => %w[accounts.google.com *.facebook.com login.live.com github.com meta.wikimedia.org]
134     )
135
136     if current_user
137       # The user is logged in already, so don't show them the signup
138       # page, instead send them to the home page
139       redirect_to @referer || { :controller => "site", :action => "index" }
140     elsif params.key?(:auth_provider) && params.key?(:auth_uid)
141       self.current_user = User.new(:email => params[:email],
142                                    :email_confirmation => params[:email],
143                                    :display_name => params[:nickname],
144                                    :auth_provider => params[:auth_provider],
145                                    :auth_uid => params[:auth_uid])
146
147       flash.now[:notice] = render_to_string :partial => "auth_association"
148     else
149       check_signup_allowed
150
151       self.current_user = User.new
152     end
153   end
154
155   def create
156     self.current_user = User.new(user_params)
157
158     if check_signup_allowed(current_user.email)
159       session[:referer] = safe_referer(params[:referer]) if params[:referer]
160
161       Rails.logger.info "create: #{session[:referer]}"
162
163       if current_user.auth_provider.present? && current_user.pass_crypt.empty?
164         # We are creating an account with external authentication and
165         # no password was specified so create a random one
166         current_user.pass_crypt = SecureRandom.base64(16)
167         current_user.pass_crypt_confirmation = current_user.pass_crypt
168       end
169
170       if current_user.invalid?
171         # Something is wrong with a new user, so rerender the form
172         render :action => "new"
173       elsif current_user.auth_provider.present?
174         # Verify external authenticator before moving on
175         session[:new_user] = current_user
176         redirect_to auth_url(current_user.auth_provider, current_user.auth_uid), :status => :temporary_redirect
177       else
178         # Save the user record
179         session[:new_user] = current_user
180         redirect_to :action => :terms
181       end
182     end
183   end
184
185   def show
186     @user = User.find_by(:display_name => params[:display_name])
187
188     if @user &&
189        (@user.visible? || current_user&.administrator?)
190       @title = @user.display_name
191     else
192       render_unknown_user params[:display_name]
193     end
194   end
195
196   ##
197   # sets a user's status
198   def set_status
199     @user.activate! if params[:event] == "activate"
200     @user.confirm! if params[:event] == "confirm"
201     @user.unconfirm! if params[:event] == "unconfirm"
202     @user.hide! if params[:event] == "hide"
203     @user.unhide! if params[:event] == "unhide"
204     @user.unsuspend! if params[:event] == "unsuspend"
205     redirect_to user_path(:display_name => params[:display_name])
206   end
207
208   ##
209   # destroy a user, marking them as deleted and removing personal data
210   def destroy
211     @user.soft_destroy!
212     redirect_to user_path(:display_name => params[:display_name])
213   end
214
215   ##
216   # display a list of users matching specified criteria
217   def index
218     if request.post?
219       ids = params[:user].keys.collect(&:to_i)
220
221       User.where(:id => ids).update_all(:status => "confirmed") if params[:confirm]
222       User.where(:id => ids).update_all(:status => "deleted") if params[:hide]
223
224       redirect_to url_for(:status => params[:status], :ip => params[:ip], :page => params[:page])
225     else
226       @params = params.permit(:status, :ip)
227
228       conditions = {}
229       conditions[:status] = @params[:status] if @params[:status]
230       conditions[:creation_ip] = @params[:ip] if @params[:ip]
231
232       @user_pages, @users = paginate(:users,
233                                      :conditions => conditions,
234                                      :order => :id,
235                                      :per_page => 50)
236     end
237   end
238
239   ##
240   # omniauth success callback
241   def auth_success
242     auth_info = request.env["omniauth.auth"]
243
244     provider = auth_info[:provider]
245     uid = auth_info[:uid]
246     name = auth_info[:info][:name]
247     email = auth_info[:info][:email]
248
249     email_verified = case provider
250                      when "openid"
251                        uid.match(%r{https://www.google.com/accounts/o8/id?(.*)}) ||
252                        uid.match(%r{https://me.yahoo.com/(.*)})
253                      when "google", "facebook"
254                        true
255                      else
256                        false
257                      end
258
259     if settings = session.delete(:new_user_settings)
260       current_user.auth_provider = provider
261       current_user.auth_uid = uid
262
263       update_user(current_user, settings)
264
265       flash.discard
266
267       session[:user_errors] = current_user.errors.as_json
268
269       redirect_to edit_account_path
270     elsif session[:new_user]
271       session[:new_user].auth_provider = provider
272       session[:new_user].auth_uid = uid
273
274       session[:new_user].activate if email_verified && email == session[:new_user].email
275
276       redirect_to :action => "terms"
277     else
278       user = User.find_by(:auth_provider => provider, :auth_uid => uid)
279
280       if user.nil? && provider == "google"
281         openid_url = auth_info[:extra][:id_info]["openid_id"]
282         user = User.find_by(:auth_provider => "openid", :auth_uid => openid_url) if openid_url
283         user&.update(:auth_provider => provider, :auth_uid => uid)
284       end
285
286       if user
287         case user.status
288         when "pending"
289           unconfirmed_login(user)
290         when "active", "confirmed"
291           successful_login(user, request.env["omniauth.params"]["referer"])
292         when "suspended"
293           failed_login t("sessions.new.account is suspended", :webmaster => "mailto:#{Settings.support_email}").html_safe
294         else
295           failed_login t("sessions.new.auth failure")
296         end
297       else
298         redirect_to :action => "new", :nickname => name, :email => email,
299                     :auth_provider => provider, :auth_uid => uid
300       end
301     end
302   end
303
304   ##
305   # omniauth failure callback
306   def auth_failure
307     flash[:error] = t(params[:message], :scope => "users.auth_failure", :default => t("users.auth_failure.unknown_error"))
308
309     origin = safe_referer(params[:origin]) if params[:origin]
310
311     redirect_to origin || login_url
312   end
313
314   private
315
316   ##
317   # ensure that there is a "user" instance variable
318   def lookup_user_by_name
319     @user = User.find_by(:display_name => params[:display_name])
320   rescue ActiveRecord::RecordNotFound
321     redirect_to :action => "view", :display_name => params[:display_name] unless @user
322   end
323
324   ##
325   # return permitted user parameters
326   def user_params
327     params.require(:user).permit(:email, :email_confirmation, :display_name,
328                                  :auth_provider, :auth_uid,
329                                  :pass_crypt, :pass_crypt_confirmation)
330   end
331
332   ##
333   # check signup acls
334   def check_signup_allowed(email = nil)
335     domain = if email.nil?
336                nil
337              else
338                email.split("@").last
339              end
340
341     mx_servers = if domain.nil?
342                    nil
343                  else
344                    domain_mx_servers(domain)
345                  end
346
347     if blocked = Acl.no_account_creation(request.remote_ip, :domain => domain, :mx => mx_servers)
348       logger.info "Blocked signup from #{request.remote_ip} for #{email}"
349
350       render :action => "blocked"
351     end
352
353     !blocked
354   end
355
356   ##
357   # get list of MX servers for a domains
358   def domain_mx_servers(domain)
359     Resolv::DNS.open do |dns|
360       dns.getresources(domain, Resolv::DNS::Resource::IN::MX).collect(&:exchange).collect(&:to_s)
361     end
362   end
363 end