Strona Andrzeja Kardasia

Jak zmusić szkielet uwierzytelnienia dla RoR Authlogic do obsługi trzech parametrów logowania zamiast standardowo dostępnych dwóch

Authlogic jest jednym z najbardziej popularnych rozwiązań wspomagających uwierzytelnianie dla platformy Ruby on Rails. Jego sukces jest spowodowany wysoką funkcjonalnością i elastycznością. Wykorzystując authlogic możesz wykonać niemalże każde typowe zadanie związane z uwierzytelnianiem użytkownika w swojej aplikacji WWW. Dodatkowo dzięki dostępnym wtyczkom, możesz łatwo zintegrować uwierzytelnienie z wykorzystaniem konta Open ID, Facebook lub Twitter ze swoją stroną Internetową. Jeśli nie zetknąłeś się z Authlogickiem, powinieneś obejrzeć ten i ten film Ryan Bates'a lub wykonać tutorial dostępny w pliku REDME Authlogica.

W 90% aplikacji sieci Web będziesz musiał podać dwa parametry logowanie, nazwę użytkownika lub email i hasło. Taki typ uwierzytelnienie jest domyślnie wbudowany w authlogica. Projekt, nad którym pracowałem wymagał ode mnie podawania 3 parametrów logowania. W tym projekcie mam wiele warsztatów, i każdy z nich może posiadać wiele kont użytkowników, którzy współdzielą między sobą i manipulują jego danymi. W ramach każdego warsztatu chciałbym mieć unikalne nazwy użytkowników, ale pomiędzy warsztatami nazwy użytkowników mogą się powtarzać. Na początku myślałem, że będzie wyjątkowo trudno osiągnąć taki efekt, ale kiedy cierpliwie przeczytałem dokumentację api, elastyczność authlogica i języka ruby pozwoliła mi to zrobić w całkiem prosty sposób. Postaram się podzielić moim rozwiązaniem mając nadzieję, że okaże się ono użyteczne także dla innych lub być może ktoś zasugeruje mi lepsze rozwiązanie tego problemu.

Zakładam, że jeśli to czytasz wiesz jak działa szkielet Ruby On Rails, i możesz czytać ze zrozumieniem kod źródłowy języka ruby. Nie będę się starał wyjaśniać każdej pojedynczej linii kodu, który tutaj znajdziesz. Skupię się na wyjaśnieniu części kodu, które są istotne ze względu na obsługę 3 parometrowego uwierzytelnienia przy użyciu authlogica.

Rozpocznijmy od pokazania części widoku mojego projektu. Poniżej znajdziesz partial odpowiedzialny za wyświetlanie użytkownikowi formularza logowania.

<fieldset id="form">
<legend>Submit login information</legend>
<% form_remote_for @user_session, 
	:url=>{:action=>'create'},
    :html=>{ :autocomplete => :off },
    :before => "Element.show('loging-indicator')", 
    :success => "Element.hide('loging-indicator')" do |f| %>
  <%= f.error_messages %>
  <p>
  	<%= f.label :workshop_unique, "Workshop id:" %><br />
	<%= f.text_field :workshop_unique, :value => @workshop, :size => 30 %> <br />	
  	<%= check_box_tag :remember_workshop,  1, checked = false %>
	<%= label_tag :remember_workshop, "Remeber workshop id" %>
  </p>
  <p>
    <%= f.label :username, "User name: " %><br />
    <%= f.text_field :username, :value => @username %> <br />
	<%= check_box_tag :remember_username,  1, checked = false %>
	<%= label_tag :remember_username, "Remember user name" %>
  </p>
  <p>
    <%= f.label :password, "Password:" %><br />
    <%= f.password_field :password %>
  </p>
  <p><%= f.submit "Zaloguj" %></p>
<% end %>
</fieldset>
<div id="loging-indicator" style="display:none;">
<span>Data manipulation in progress:<br />
	<%= image_tag("processingbar.gif",
              :align => "absmiddle",
              :border => 0) %>
</span>
</div>

Tutaj tworzymy Ajaxowy formularz logowania, używając metody pomocniczej form_remote_for która operuje na obiekcie @user_session. Ten obiekt jest typowym wykorzystaniem API authlogica, co nie jest typowe w tym formularzu to fakt, że mamy 3 pola logowania. Użytkownik będzie musiał wprowadzić swój identyfikator warsztatu, swoją nazwę użytkownika i swoje hasło aby zalogować się do systemu. Znajdziesz tu także pola wyboru, które pozwalają użytkownikowi zapamiętać jego informacje logowania ale są one poza zakresem interesującej nas treści.

Teraz spójrzmy na kod kontrolera, który obsługuje wymianę informacji pomiędzy widokiem i modelem podczas fazy logowania i wylogowywania użytkownika.

class UserSessionsController < ApplicationController
 
  # access control:
  # logged in users can destroy session (and be logged out)
  # anonymous users can create new session (login in to system) 
  access_control :debug => true do
    allow logged_in, :to => [:destroy]
    allow anonymous, :to => [:new, :create]
  end
 
  def new
    @user_session = UserSession.new
    @workshop = cookies[:workshop]
    @username = cookies[:username]
  end
 
  def create
    if params[:remember_workshop]=="1"
      if cookies[:workshop] != nil
        cookies.delete :workshop
      end
      cookies[:workshop] = {:value=> params[:user_session][:workshop_unique], 
:expires => 1.year.from_now}
    end
    if params[:remember_username]=="1"
      if cookies[:username] != nil
        cookies.delete :username
      end
      cookies[:username] = {:value=> params[:user_session][:username], 
:expires => 1.year.from_now}
    end
    login = {:workshop_unique => params[:user_session][:workshop_unique],:username => params[:user_session][:username]}
    @user_session = UserSession.new(:username=>login,:password=>params[:user_session][:password])
    if @user_session.save
        flash[:notice] = "Login succsessfull."
        respond_to do |format|
          format.html { redirect_to root_url }
          format.js {  
          render :update do |page|
            page.redirect_to root_url
          end  
          }
        end
    else
      unless cookies[:workshop].nil?
        @workshop = cookies[:workshop]
      else
        @workshop = params[:user_session][:workshop_unique]
      end
      unless cookies[:username].nil?
        @username = cookies[:username]
      else
        @username = params[:user_session][:username]
      end
      respond_to do |format|
        format.html { render :action => 'new'}
        format.js {  
        render :update do |page| 
          page.replace_html :login, :partial => 'login_form'
          page.visual_effect(:shake,:login,:duration => 1)
        end
        }
      end
    end
  end
 
  def destroy
    @user_session = UserSession.find
    @user_session.destroy
    flash[:notice] = "Log off succsesfull."
    current_user = nil
    redirect_to :controller => 'szws', :action => 'goodbye'
  end
 
end

Tworzenie kontrolera sesji użytkownika jest typowym podejściem przy wykorzystywaniu API authlogic. Ten kontroler zadba o logowanie i wylogowanie naszego użytkownika. Na samej górze kodu źródłowego znajdziesz mały kawałek kodu, który nie należy do zakresu naszego zainteresowania, ta część jest typowa dla rozwiązania autoryzacyjnego acl9 jakie wykorzystuje w mojej aplikacji. To co jest tutaj ważne to nasze metody. New, która jest odpowiedzialna za wyświetlenia nowego formularza logowania użytkownikowi, create, która zajmuje się logowaniem i odmową logowania jeśli użytkownik przekazał złe parametry uwierzytelnienia. Trzeci metoda destroy jest wykorzystana do wylogowania użytkownika. Jeśli spojrzysz na metody new i destroy nie znajdziesz w nich niczego niezwykłego. W metodzie destroy znajdujemy obiekt @user_session aktualnie zalogowanego użytkownika i niszczymy go, jest to w prostej linii wykorzystanie API authlogica.

To co jest najważniejsze tutaj to nasza metoda create. Pierwsza część tej metody to obsługa ciasteczek, pominiemy ją i przejdziemy poniżej. Tutaj znajdziesz część tworzącą obiekt @user_session. W normalny warunkach stworzylibyśmy ten obiekt, przekazując do niego dwa parametry pobrane z naszego żądania. Tak postąpilibyśmy w 90% wypadków ale tutaj możesz zauważyć drobny trik jaki zastosowałem aby sprawić, że trzy parametry logowania zaczną działać. Jako że konstruktor obiektu sesji przyjmuje tylko dwa parametry username i password. Authlogic przekazuje tylko te dwa parametry do modelu, który obsługuje proces autoryzacji. To co tutaj zrobimy to najpierw stworzymy tablicę asocjacyjną, która przechowa zarówno parametr workshop_unique jak i username następnie przypiszemy tę tablicę do obiektu login. Aby na końcu przekazać ten obiekt jako username, w konstruktorze UserSession.new.

To wszystko co zrobiłem aby sprawić, że 3 parametry logowania zadziałają w kontrolerze. Oczywiście to nie wszystko, co trzeba zrobić aby authlogic poprawnie zweryfikował 3 parometrowy login użytkownika. Ostatnia część to model. Będziemy musieli się przyjrzeć dwóm modelom, pierwszy to model user_session drugi to model user. Zacznijmy do modelu user_session.

class UserSession < Authlogic::Session::Base
  find_by_login_method :find_user_in_workshop
  #Make sure the right messege is being displayed to user if he provides incorrect login information
  generalize_credentials_error_messages "You provided wrong login information, please try again"
 
  @workshop_unique
 
  def workshop_unique
    @workshop_unique
  end
 
  def worksop_unique=(value)
    @workshop_unique=value
  end
 
end

Jak widzisz klasa UserSession dziedziczy z Authlogic::Session::Base, jest to kolejne typowe rozwiązanie dla API authlogic. W górnej częsći tego pliku źródłowego znajdzejsz najpobieżniejszą rzecz. Definiując find_by_login_method, możesz zastąpić standardową metodę znajdująca użytkownika w systemie. Jak napisał autor w dokumentacji API: "tylko niebo cię ogranicza", i ma tu pełną rację. Zajrzymy do naszej metody find_user_in_workshop analizując kod źródłowy modelu user. Poniżej możesz znaleźć definicję komunikatu błędu jaki wyświetlimy użytkownikowi jeśli wprowadzi błędne informacje logowania. Ostania rzecz w modelu user_session to definicja zmiennej instancji @workshop_unique. Dodałem ją aby móc użyć jej w metodzie pomocniczej widoku form_remote_for. Spójrz do kodu widoku. Teraz spójrzmy na model user.

class User < ActiveRecord::Base
  #This is authentication subject
  acts_as_authentic do |c|
     c.validate_email_field = false
     c.validate_login_field = true
     #make sure that one workshop wont be able to have two users of the same name
     c.validations_scope = :workshop_id
     c.logged_in_timeout=30.minutes;
     c.maintain_sessions=false
     c.ignore_blank_passwords=false
  end
 
  belongs_to :workshop
 
  def self.find_user_in_workshop(login)
    workshop_unique=login[:workshop_unique]
    username = login[:username]
    workshop = Workshop.find_by_workshop_unique(workshop_unique)
    unless workshop.nil?
      find_by_username_and_workshop_id(username,workshop.id)
    else
      return nil
    end
  end
 
end

To co widzisz w górnej części kodu źródłowego, to konfiguracja podmiotu uwierzytelnienia. Ustawiamy tu weryfikację naszego pola loginu i ignorowanie walidacji pola email. Następnie upewniamy się, że nasza nazwa użytkownika będzie unikalna w ramach jednego warsztatu. Ustawiamy czas wygasania sesji logowania użytkownika. Jak widzisz także uniemożliwiam automatyczne zarządzanie sesją dlatego, że w moim systemie jedni użytkownicy mogą tworzyć konta innych. Nie chciałbym aby następowało automatyczne zalogowanie użytkownika na konto, które właśnie założył dla kogoś innego. Ostatnią rzeczą jest wyłączenie ignorowania pustych haseł.

Drugą rzeczą jest typowa konfiguracja relacji jak wiemy każdy użytkownik może należeć do jednego warsztatu.

Ostatnią ale bynajmniej nie najmniej ważną rzeczą jest definicja metody: find_user_in_workshop. Ta metoda przyjmuje nasz parametr login, który jest tablicą asocjacyjną zawierającą w sobie: workshop_unique i username, pobrane z formularza logowania użytkownika. To co tutaj robimy to najpierw staramy się znaleźć warsztat używając jego unikalnego identyfikatora. Jeśli to się udaje, znajdujemy użytkownika używając zarówno username jak i workshop.id. I to jest wszystko, to rozwiązanie działa całkiem nieźle w systemie, który buduję.

Sources:

• Strona GitHub kodu Authlogic
• Czyste dokumentacja API Authlogic
• Screencast Ryan Bates'a o Authlogic