DevInterface Blog

Information Technology: è tempo di freelance e agenzie specializzate

Twago Magazine — Thu, 16 Feb 2012 13:44:24 +0000

Quello che segue è un guest post di Lorenzo Monfregola, content manager di Twago Italia.

Secondo gli ultimi dati presentati da twago, azienda leader nel settore del lavoro online, i professionisti dell’IT sono sempre più ricercati. Secondo il trend individuato i servizi basati su progetti online nel 2011 sono aumentati del 430%. Si tratta di cifre che forse possono essere colte solo da chi conosce il veloce evolversi del web e dell’economia digitale. La domanda di professionisti nel mondo dell’IT si è moltiplicata di cinque volte nello scorso anno. In particolare ci riferiamo a progetti online portati avanti con collaborazioni in oustourcing presso freelance o agenzie specializzate. Se si vuole, infatti, individuare il passaggio centrale dell’evoluzione digitale dell’outsourcing bisogna considerare come, in pochi anni, l’esternalizzazione che un tempo potevano permettersi solo le Big Company, oggi è a portata di qualsiasi azienda. Se un tempo erano necessari investimenti anche solo per cercare un collaboratore esterno, oggi il web e le piattaforme di intermediazione online aprono ad ogni tipo di azienda l’esternalizzazione verso esperti specializzati. Questa è una svolta in particolare per l’Italia, in cui il ruolo delle piccole medie imprese resta centrale, soprattutto nel momento in cui evolvere il proprio profilo digitale (o crearlo da zero) significa un passo verso le nuove prospettive della web economy.

Dall’altro lato è la stessa economia del web a richiedere freelance o agenzie specializzate. Gli skills necessari per ciascuno dei settori dell’IT richiedono una tale formazione ed un costante aggiornamento che solo un freelance o un agenzia professionale possono offrire. Un’agenzia che si muove globalmente offrendo di volta in volta le proprie competenze ad aziende diverse è una realtà molto più produttiva della vecchia creazione ad hoc di dipartimenti IT interni all’azienda. E, come già scritto, questo è ancora più vero per quelle piccole realtà economiche che mai si sognerebbero di creare un proprio ufficio IT. Ecco che quindi il ruolo di un freelance con un proprio bagaglio di esperienze, o di un’agenzia che integra diverse competenze correlate tra loro, diventa fondamentale.

Di quali competenze freelance stiamo parlando?

Le differenti opzioni della programmazione (linguaggio Html, Java, Php) e del Web design continuano ad essere le specificità più richieste dai servizi in outsourcing a livello globale. Altro campo in continua espansione è quello dei Content Management Systems, Wordpress e Joomla su tutti, a conferma della crescente importanza dell’offerta di contenuti di qualità online, anche a livello aziendale. Un discorso particoalre va poi fatto per il Mobile, la crescita di richiesta e progetti di Applicazioni, tanto iPhone e iPad quanto Android, è in crescita vertiginosa e va a segnare il veloce consolidamento di un’ennesima evoluzione dell’economia e della creatività digitale.

Share on:

Inserire box di commento Disqus più volte nella stessa pagina

Claudio — Thu, 26 Jan 2012 19:52:17 +0000

(Powered by LaunchBit)

Ciao a tutti!

Per chi non lo conoscesse Disqus è una piattaforma che permette di inserire facilmente un box per i commenti su qualsiasi sito web, e consente agli utenti di utilizzare il loro account facebook o twitter (ma non solo) per autenticarsi.

Il limite di Disqus è che associa ogni thread di commenti ad un unica url.
Di conseguenza, si aspetta che in ogni pagina ci sia solamente un box di commenti.

Nella stragrande maggioranza dei casi questo limite è accettabile, tuttavia, per alcune applicazioni è utile poter inserire più box di commento in un unica pagina. Si pensi ad esempio ad un blog dove si vuol dare la possibilità di commentare ogni singolo post direttamente dalla pagina principale dove sono elencati tutti i post uno sotto l’altro.

Quello che voglio mostrarvi oggi è un metodo per superare il limite di Disqus ed implementare in modo semplice una pagina con più box di commento, come nell’esempio del blog appena fatto.
Sfruttando un iframe e jQuery renderemo inoltre i box dinamici.

Supponiamo di avere la nostra pagina index.html.haml come segue e di aver già creato il nostro account su Disqus:

1
2
3
4

- @posts.each do |post|
= show_for post do |s|
= s.attribute :title
= s.attribute :body

L’idea è quella di creare un iframe dinamicamente sotto ogni post e farlo visualizzare/nascondere tramite jQuery quando si clicca su un link “commenta”.

Come prima cosa quindi creiamo la pagina comments.html.haml che andremo a caricare nell’iframe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#disqus_thread

%noscript
Please enable JavaScript to view the
%a{:href => "http://disqus.com/?ref_noscript"} comments powered by Disqus.

%a.dsq-brlink{:href => "http://disqus.com"}
blog comments powered by
%span.logo-disqus Disqus

:javascript
var disqus_shortname = 'devinterface-example';

(function() {
var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
dsq.src = 'http://' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();

function disqus_config() {
this.callbacks.onReady = [function() {
var frameHeight = $(document).height();
$('iframe.comment_frame', top.document).attr("height", frameHeight)
}];
this.callbacks.onNewComment = [function() {
var frameHeight = $(document).height();
$('iframe.comment_frame', top.document).attr("height", frameHeight)
}];
}

In questa pagina inseriamo l’html ed il javascript fornitoci da Disqus e settiamo la variabile disqus_shortname.
Utilizzando poi la funzione disqus_config impostiamo due callback per disqus in modo tale che dopo il completo caricamento di disqus o all’inserimento di un nuovo commento, l’iframe che contiene questa pagina venga ridimensionato opportunamente.
NOTA: il ridimensionamento dell’iframe “contenitore” è possibile solo perchè le due pagine index e comments stanno sullo stesso dominio. Se cosi non fosse infatti, l’accesso al parent di un iframe sarebbe impossibile per i criteri di sicurezza dei browser.

Ora che abbiamo creato la nostra pagina comments, non ci resta che aggiungere alla index in modo dinamico l’iframe.
Per rendere le cose più “carine” faremo in modo che il link di apertura/chiusura del box dei commenti contenga il conteggio dei commenti di quello specifico post.

Torniamo quindi alla pagina index e modifichiamola come segue:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

- @posts.each do |post|
= show_for post do |s|
= s.attribute :title
= s.attribute :body
/ disqus comments
= link_to "", "/#{post.slug}/comments#disqus_thread", :class=> "dq_comment", :id => post.id
.comment_box{:id => "comment_#{post.id}"}

:javascript
var disqus_shortname = 'devinterface-example';

(function () {
var s = document.createElement('script'); s.async = true;
s.type = 'text/javascript';
s.src = 'http://' + disqus_shortname + '.disqus.com/count.js';
(document.getElementsByTagName('HEAD')[0] || document.getElementsByTagName('BODY')[0]).appendChild(s);
}());

$(document).ready(function(){
$(".dq_comment").click(function(e){
e.preventDefault();

var id = $(this).attr("id");
var href = $(this).attr("href");
var src = href.substring(0,href.length-14); // Remove #disqus_thread

if ($("#comment_"+id).is(':visible'))
$("#comment_"+id).html('');
else
$("#comment_"+id).append('+src+'" class="comment_frame">');

$("#comment_"+id).toggle('slow');
})
});

Come vedete abbiamo aggiunto il link con una url univoca del post ed il tag #disqus_thread per attivare il counter dei commenti, come spiegato nella documentazione.
Infine tramite la funzione jQuery abbiamo intercettato il click sul link facendo in modo di creare dinamicamente sotto al post un iframe con l’url della nostra pagina comments.html.haml.
Ovviamente l’url di comments dovra essere definita opportunamente nel nostro file di routes.

Ora non vi resta che aprire il vostro browser e vedere i vostri post, ognuno con il suo box di commenti caricato dinamicamente cliccando sul counter.

NB: se provate questi script in locale, ricordatevi di aggiungere nei due javascript di Disqus:

1	var disqus_developer = 1;

subito sotto a disqus_shortname.

Share on:

Tips: Paginazione multipla con will_paginate

Claudio — Thu, 11 Aug 2011 13:07:10 +0000

(Powered by LaunchBit)

Will Paginate è la gemma più utilizzata per la paginazione in Ruby on Rails.

Succede a volte di dover paginare più liste diverse su una stessa pagina.

Questo tip mostra come è possibile visualizzare una lista paginata di prodotti ed una lista paginata di servizi su una stessa pagina utilizzando will_paginate.
Il punto chiave sta nell’utilizzare un parametro param_name personalizzato sia nella view che nel controller.

Il codice della view sarà qualcosa di simile a questo:

1
2
3
4
5
6
7

# ...
# la lista di prodotti va qui
<%= will_paginate @products, :param_name => 'products_page', :prev_label => t('helpers.labels.previous'), :next_label => t('helpers.labels.next') %>

# la lista di servizi va qui
<%= will_paginate @services, :param_name => 'services_page', :prev_label => t('helpers.labels.previous'), :next_label => t('helpers.labels.next') %>
# ...

E questo invece sarà il codice del controller:

1
2
3
4
5
6

# ...
def index
@products = current_company.products.paginate(:page => params[:products_page], :per_page => 10)
@services = current_company.products.paginate(:page => params[:services_page], :per_page => 10)
end
# ...

Share on:

Registrazione in due step con Devise

Claudio — Wed, 11 May 2011 20:28:04 +0000

(Powered by LaunchBit)

Nei miei progetti in Ruby on Rails generalemente utilizzo Devise come gem per l’autenticazione degli utenti.

Nell’ultima applicazione sviluppata avevo necessità di personalizzare Devise in modo che gli utenti potessero registrarsi fornendo solo l’indirizzo email.
La password di accesso doveva essere impostata nello step di conferma dell’account.
Dopo alcuni test, sono giunto alla seguente soluzione.

1. Per prima cosa ho dovuto sovrascrivere il ConfirmationsController. Quindi nel file routes.rb ho impostato devise perchè utilizzase il mio controller custom (il mio model degli utenti si chiamava Account).
Ho dovuto sovrascrivere anche il RegistrationsController per personalizzare la pagina di registrazione:

1
2
3

devise_for :accounts, :controllers => {:confirmations => "confirmations", :registrations => "registrations"} do
put "confirm_account", :to => "confirmations#confirm_account"
end

Come vedete ho anche aggiunto un metodo custom, confirm_account che userò nel quarto step, come vedremo tra poco.

2. A questo punto devo fare in modo di evitare la validazione della password di devise.
Per questo scopo ho scritto un initializer chiamato devise_customization.rb in /config/initalizers/ come segue:

1
2
3
4
5
6
7
8
9
10
11

module Devise
module Models
module Validatable

def password_required?
false
end

end
end
end

In questo modo ho sovrascritto il modulo validatable di devise skippando la validazione della password.

3. Il passo successivo è la personalizzazione delle view.
Poichè utilizzo i miei ConfirmationsController e RegistrationsController custom ho copiato le view standard di devise sotto /views/confirmations/ per le confirmations e sotto /views/registrations/ per le registrations.
Le ho poi modificate come segue per adattarle al mio workflow di registrazione.

La view /registrations/new è diventata cosi (utilizzo haml per i layout)

1
2
3
4
5
6
7
8
9
10

= form_for(resource, :as => resource_name, :url => account_registration_path(@account)) do |f|
= devise_error_messages!
%p
= f.label :email
= f.email_field :email
%p.clearfix
= f.submit 'Signup'
= link_to 'Home', root_url
%br/
= render :partial => 'devise/shared/links'

In questa view ho semplicemente rimosso i campi password e password_confirmation.

La view /confirmations/show è invece diventata:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

= form_for(resource, :url => confirm_account_path) do |f|
= devise_error_messages!
%p
= f.label :email
= @account.email
= f.hidden_field :confirmation_token
%p
= f.label :password
%br/
= f.password_field :password
%p
= f.label :password_confirmation
%br/
= f.password_field :password_confirmation
%p.clearfix
= f.submit 'Confirm Account'
= link_to 'Home', root_url
%br/
= render :partial => 'devise/shared/links'

4. Ok, ora che ho definito le mie view è tempo di scrivere il nuovo metodo di conferma dell’account nel ConfirmationsController. Posso invece lasciare inalterato il RegistrationsController.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class ConfirmationsController < Devise::ConfirmationsController
def show
@account = Account.find_by_confirmation_token(params[:confirmation_token])
if !@account.present?
render_with_scope :new
end
end

def confirm_account
@account = Account.find(params[:account][:confirmation_token])
if @account.update_attributes(params[:account]) and @account.password_match?
@account = Account.confirm_by_token(@account.confirmation_token)
set_flash_message :notice, :confirmed
sign_in_and_redirect("account", @account)
else
render :action => "show"
end
end

end

Il metodo show semplicemente si occupa di trovare l’account in base al token ricevuto e poi renderizzza la view show.
Il punto chiave è il metodo confirm_account dove viene trovato l’account, eseguito l’update dei suoi attributes e se il metodo password_match? ritorna true allora l’account viene confermato chiamando il metodo standard di devise confirm_by_token

5. L’ultima cosa che rimane da fare è definire il metodo password_match? all’interno del model Account.

1
2
3
4
5
6
7
8
9
10

class Account < ActiveRecord::Base
...

def password_match?
self.errors[:password] << 'password not match' if password != password_confirmation
self.errors[:password] << 'you must provide a password' if password.blank?
password == password_confirmation and !password.blank?
end

end

E questo è tutto!
Ora potete riavviare il server rails e registrarvi nella vostra applicazione scegliendo la password solo in fase di conferma dell’account.

Share on:

Lancio del portale Gruppi Emergenti

DevInterface — Fri, 15 Apr 2011 12:56:41 +0000

(Powered by LaunchBit)

Siamo prossimi alla pubblicazione online di Gruppi Emergenti, il nuovo portale della musica emergente italiana che si propone come vetrina per le band, gli artisti ed i locali di musica dal vivo.

Il sito web, completamente gratuito, permette di creare la pagina della propria band o del proprio live club e di pubblicare eventi musicali.

Tramite una ricerca localizzata su Gruppi Emergenti è possibile cercare tutti gli eventi (esibizioni, concerti e quant’altro) che si terranno in un determinato periodo ed in una determinata zona.

L’integrazione con le mappe di Google permette di localizzare anche visivamente i live club e gli eventi.

Gli utenti registrati possono ricevere ogni settimana l’elenco degli eventi in programma relativi ai loro gruppi o locali preferiti tramite una newsletter personalizzata.

Il portale è dotato anche di una bacheca per gli annunci relativi a strumenti, musicisti e corsi.

Gruppi Emergenti è integrato anche con i principali social network e consente di pubblicare gli eventi creati sul sito direttamente sui profili e sulle pagine di Facebook e Twitter.

Il lancio ufficiale è previsto per mercoledi 20 aprile.

Tutti gli utenti iscritti nella fase di presentazione del sito durata dal 1 marzo ad oggi 15 aprile riceveranno al loro indirizzo email le credenziali per accedere subito dopo la pubblicazione.

Inoltre, tra di loro abbiamo sorteggiato 4 vincitori di due mesi di pubblicità gratuita sul portale.

L’elenco dei vincitori lo potete vedere nell’immagine riportata qui sotto.

I vincitori saranno contattati via email nelle prossime ore con tutti i dettagli per la pubblicazione dei banner.

Share on:

Random Posts

Prevenire la registrazione di login riservate

Claudio — Tue, 05 Apr 2011 08:34:47 +0000

(Powered by LaunchBit)

Ogni volta che si realizza una web application dove gli utenti possono registrarsi, è buona cosa escludere alcuni username o login in modo che non possano essere utilizzati.
Un esempio classico è la login “admin”.
Credo che nessuno desideri che sulla sua applicazione ci sia un utente iscritto con lo username “admin” che possa magari contattare gli altri utenti spacciandosi per il vero amministratore del sito.
La stessa cosa può valere per lo username “root” e per molti altri.

E’ quindi necessario definire una lista di nomi riservati.
Fortunatamente sviluppando in Ruby on Rails è molto semplice implementare questa funzionalità sfruttando il validatore validates_exclusion_of se si utilizza Rails fino alla versione 2.3.8

1
2
3
4
5

class User < ActiveRecord::Base
validates_exclusion_of :login,
:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved"
end

oppure utilizzando validates con il parametro :exclusion se si utilizza Rails 3.x

1
2
3
4
5

class User < ActiveRecord::Base
validates :login,
:exclusion => {:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved" }
end

In questo modo, chiunque tenti di creare un account con login “admin” ottiene un messaggio di errore che indica che il nome è riservato.
Va però tenuto presente che validates_exclusion_of e anche validates :exclusion sono metodi case sensitive.
Ciò significa che con questa prima implementazione un utente che provi a registrarsi come “Admin” avrà successo.

Per ovviare anche a questo problema la cosa più semplice da fare è aggiungere un before_filter prima delle validazioni che converta la login inserita in lettere minuscole.
Ecco quindi la soluzione completa per Rails 2.3.x:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base

before_validation { |u| u.login.downcase! }

validates_exclusion_of :login,
:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved"

end

e l’equivalente soluzione per Rails 3:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base

before_validation { |u| u.login.downcase! }

validates :login,
:exclusion => {:in => ["admin", "root", "administrator", "superuser"],
:message => "is reserved" }

end

Questo metodo ha però lo svantaggio di convertire tutte le login in lettere minuscole non permettendo di fatto la registrazione di due login “uguali” ma con case diverso.
Soluzione che può essere accettabile in molti casi.
Tuttavia se si ha necessità di preservare la login con maiuscole e minuscole come viene inserita dagli utenti si può sempre implementare un metodo di validazione custom:

1
2
3
4
5
6
7
8
9

class User < ActiveRecord::Base
validate :excluded_login

def excluded_login
%w( admin root administrator superuser ).each do |reserved_login|
user.errors.add(:login, "is reserved") if user.login.downcase == reserved_login
end

end

Avete mai implementato una soluzione di questo genere? Conoscete un modo migliore di realizzarla?

Share on:

Un nuovo layout più semplice e spazioso

DevInterface — Tue, 22 Mar 2011 12:56:09 +0000

(Powered by LaunchBit)

Negli ultimi giorni abbiamo dedicato un po’ del nostro tempo per fare un completo redesign del nostro sito e del nostro blog.

Il risultato è quello che stai vedendo leggendo questo articolo.

In particolare le novità che abbiamo introdotto sia nel tema del blog che nel sito sono:

Layout più largo e suddiviso in 2 colonne anche per il sito web
Contenuti del blog con più spazio, molto utile dove si riportano spezzoni di codice
Un header ampio e lineare con in ogni pagina i punti chiave
Un footer più ampio con tutti i nostri riferimenti e gli ultimi messaggi provenienti da Twitter (sul sito anche gli ultimi post del blog)
Uno slider sulla homepage del sito e del blog che riassume visivamente ciò di cui ci occupiamo (almeno in parte)
Pagina “portfolio” completamente ridisegnata
Pagina “chi siamo” con un look più dinamico

Dal punto di vista tecnico il sito è stato riscritto utilizzando Ruby On Rails 3.0.5 e jQuery mentre il motore del blog rimane sempre il solito collaudato Wordpress.

Ti piace la nuova grafica? Siamo in attesa dei tuoi commenti!

Share on:

Come spedire email in modo asincrono con Devise e Rails3

Stefano — Fri, 04 Mar 2011 14:47:16 +0000

(Powered by LaunchBit)

Ciao a tutti.

Vorrei mostrare un workaround per inviare email in modo asincrono usando Devise e Rails3.

Supponiamo di avere già in piedi la nostra applicazione, con Devise e delayed_job installati correttamente.

Un primo tentativo è stato quello di aggiungere in config/initializers il seguente file devise_async.rb:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#devise_async.rb
module Devise
module Models
module Confirmable
handle_asynchronously :send_confirmation_instructions
end

module Recoverable
handle_asynchronously :send_reset_password_instructions
end

module Lockable
handle_asynchronously :send_unlock_instructions
end
end
end

Questo workaround ha funzionato parzialmente: ha messo in coda correttamente l’invio della mail di confirmation nella tabella di delayed_job ma il problema si è poi rivelato al momento dell’attivazione del job, ottenendo questo errore:

1 2	User#send_confirmation_instructions_without_delay failed with NoMethodError: undefined method 'send_confirmation_instructions_without_delay' for # - 1 failed attempts [Worker(host:stefano-desktop pid:13153)]

Come si puo’ notare, il job sta tentando di chiamare il metodo sbagliato di invio istruzioni, send_confirmation_instructions_without_delay.

A questo punto ho implementato un hack ancora più sporco, overridando i metodi in questione e seguendo la sintassi indicata da intridea per inviare le email in background:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#devise_async.rb
module Devise
module Models
module Confirmable
# Send confirmation instructions by email
def send_confirmation_instructions
generate_confirmation_token! if self.confirmation_token.nil?
::Devise.mailer.delay.confirmation_instructions(self)
end
end

module Recoverable
# Resets reset password token and send reset password instructions by email
def send_reset_password_instructions
generate_reset_password_token!
::Devise.mailer.delay.reset_password_instructions(self)
end
end

module Lockable
# Send unlock instructions by email
def send_unlock_instructions
::Devise.mailer.delay.unlock_instructions(self)
end
end
end
end

Questo metodo è troppo legato però all’implementazione di Devise e non rappresenta quindi una valida soluzione (oltre ad essere veramente di pessima fattura).

L’ultima idea, che poi rappresenta la soluzione adottata almeno fino a qualcosa di meglio, è la seguente: utilizzare alias_method in questo modo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#devise_async.rb
module Devise
module Models
module Confirmable
alias_method :send_confirmation_instructions_without_delay, :send_confirmation_instructions
handle_asynchronously :send_confirmation_instructions
end

module Recoverable
alias_method :send_reset_password_instructions_without_delay, :send_reset_password_instructions
handle_asynchronously :send_reset_password_instructions
end

module Lockable
alias_method :send_unlock_instructions_without_delay, :send_unlock_instructions
handle_asynchronously :send_unlock_instructions
end
end
end

Questo ultimo hack funziona a meraviglia, non è il massimo ma permette di inviare mail da Devise in modo asincrono.

Se avete altre soluzioni migliori, non esitate e condividerle.

Share on:

Come implementare due dropdown dipendenti l’una dall’altra in Django e jQuery

Stefano — Fri, 25 Feb 2011 15:40:46 +0000

(Powered by LaunchBit)

Ciao a tutti.

Con l’articolo di oggi vorrei mostrare come implementare due dropdown dipendenti l’una dall’altra usando Django e jQuery.

Supponiamo di avere una relazione 1-N tra marca di automobile e modello: nella prima dropdown vogliamo mostrare la lista delle marche; una volta selezionata una marca mostreremo nella seconda dropdown la lista dei modelli filtrati per quella marca.

Ipotizziamo di avere i modelli definiti così:

1
2
3
4
5
6
7
8
9

#models.py
class VehicleBrand(models.Model):
description = models.CharField(max_length=100)
code = models.SlugField(primary_key=True)

class VehicleModel(models.Model):
description = models.CharField(max_length=100)
code = models.SlugField(primary_key=True)
brand = models.ForeignKey(VehicleBrand)

Iniziamo a definire il templatetag da includere nei nostri template:

1
2
3
4
5
6
7
8
9
10
11

#templatetags.py
from models import VehicleBrand

from django import template

register = template.Library()

@register.inclusion_tag("brand_model_select.html")
def brand_model_select():
brand_list = VehicleBrand.objects.all()
return {'brand_list' : brand_list}

Come possiamo vedere, il tag richiede un template html di supporto. Vediamo come è definito:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

<form action="" method="get" accept-charset="utf-8">
<select name="brand" id="brand">
<option value="Z">Select a brand</option>
{% for brand in brand_list %}
<option value="{{ brand.code}}">{{ brand.description }}</option>
{% endfor %}
</select>
<select name="model" id="model" disabled="true">
<option>Select a model</option>
</select>
</form>
<script>
$(document).ready(
function() {
$("select#brand").change(function() {
if ($(this).val() == 'Z') {
$("select#model").html("<option>Select a model</option>");
$("select#model").attr('disabled', true);
}
else {
var url = "/brand/" + $(this).val() + "/all_json_models";
var brand = $(this).val();
$.getJSON(url, function(models) {
var options = '<option value="Z">Select a model</option>';
for (var i = 0; i < models.length; i++) {
options += 'i].pk + '">' + models[i].fields['description'] + '</option>';
}
$("select#model").html(options);
$("select#model option:first").attr('selected', 'selected');
$("select#model").attr('disabled', false);
});
}
});

$("select#model").change(function(vent) {
if ($(this).val() == -1) {
return;
}
myAwesomeFunctionToCallWhenAModelIsSelected();
});
});
}

</script>

Possiamo notare che non appena viene selezionato una marca, viene invocata una chiamata Ajax a questa url:
/brand/”selected_brand_code”/all_json_models

Dobbiamo definire dunque un’apposita view per poter intercettare questa url:

1
2
3
4
5
6

#views.py
def all_json_models(request, brand):
current_brand = VehicleBrand.objects.get(code=brand)
models = VehicleModel.objects.all().filter(brand=current_brand)
json_models = serializers.serialize("json", models)
return HttpResponse(json_models, mimetype="application/javascript")

e in urls.py:

1
2
3

#urls.py
...
(r'^brand/(?P[-\w]+)/all_json_models/$', 'all_json_models'),

Infine, il metodo javascript myAwesomeFunctionToCallWhenAModelIsSelected(); verrà scatenato una volta selezionato il nostro modello.

Share on:

Ruby Enumerables: Operazioni con le hash

Claudio — Tue, 15 Feb 2011 10:42:48 +0000

(Powered by LaunchBit)

Nel mio ultimo post ho parlato delle hash di Ruby.
Oggi riprendo e completo l’argomento descrivendo alcune delle operazioni che si possono eseguire sulle hash per manipolarne i valori.
1. Accedere ai valori iterativamente
La classe Hash di ruby mette a disposizione tre diversi iteratori: each, each_key, each_value.
Esiste in realtà un quarto iteratore, each_pair che però è solo un alias di each.
Come ci si può aspettare l’iteratore each funziona come segue:

1
2
3
4
5
6

{"company" => "DevInterface", "activity" => "Web Agency"}.each do |key, val|
p key, ": ", val
end
# Will print
"company: DevInterface"
"activity: Web Agency"

Gli altri due operatori permettono rispettivamente di iterare solo sulle chiavi o solo sui valori della hash.

1
2
3
4
5
6
7
8
9
10
11
12

{"name" => "Claudio", "role" => "Web Developer"}.each_key do |key|
p key
end
# Will print
"name"
"role"
{"name" => "Claudio", "role" => "Web Developer"}.each_value do |val|
p val
end
# Will print
"Claudio"
"Web Developer"

2. Invertire i valori con le chiavi
Un’operazione che può essere molto utile in certi casi è l’inversione dei valori con le chiavi.
L’esempio classico è la rubrica telefonica.
Supponiamo di avere una hash che contiene la rubrica telefonica come segue

1	phone_numbers = {"DevInterface" => "339-045-2223836", "John" => "555-6677", "Stefano" => "335-12345678"}

e di voler sapere a chi appartiene il numero “555-6677″.
Potremmo iterare su tutta la hash fino a trovare il valore cercato e poi ritornare la chiave. Ma se la hash invece di 3 elementi ne contenesse 1000 questa operazione diventerebbe molto lenta.
L’alternativa è invertire la nostra hash in modo che i numeri diventino le chiavi ed i nomi i valori.
La class Hash mette a disposizione per questo scopo il metodo invert:

1 2	inverted_phone_numbers = phone_numbers.invert inverted_phone_numbers["555-6677"] # Will return "John"

Prima di utilizzare il metodo invert tuttavia, è necessario tenere presente che le hash hanno chiavi uniche, ma i valori possono essere duplicati.
Di conseguenza, quando si inverte una hash eventuali valori duplicati saranno convertiti in un unica chiave, con conseguente perdita di informazioni.
Di fatto, non è predicibile quale dei valori verrà tenuto e quali verranno invece scartati.
Riprendendo l’esempio della rubrica se avessimo:

1	phone_numbers = {"DevInterface" => "339-045-2223836", "John" => "555-6677", "Mary" => "555-6677", "Stefano" => "335-12345678"}

ed eseguissimo la stessa operazione di prima

1 2	inverted_phone_numbers = phone_numbers.invert inverted_phone_numbers["555-6677"] # Will return "John" or "Mary"

non potremo sapere con certezza se ci verrà restituito “John” oppure “Mary”.
3. Convertire un hash in un array
E’ possibile convertire una hash in un array utilizzando il metodo to_a.
Il risultato sarà un array in cui gli elementi pari corrispondono alle chiavi ed i dispari ai valori della hash di partenza.

1 2	my_hash = {"a" => 1, "b" => 2, "c" => 3} my_hash.to_a # ["a", 1, "b", 2, "c", 3]

A volte però è più comodo avere due array separati per chiavi e valori. E’ possibile ottenerli nel seguente modo:

1 2	my_hash.keys.to_a # ["a", "b", "c"] my_hash.values.to_a # [1, 2, 3]

Infine, utilizzando il metodo values_at della classe Hash è possibile estrarre in un array solo alcuni valori specifici, determinati dalle chiavi passate al metodo:

1	my_hash.values_at("a", "c") # [1, 3]

Ruby permette anche la conversione inversa, ovvero creare una hash a partire da un array:

1 2	my_array = [1, 2, 3, 4, 5, 6] my_hash = Hash[*my_array] # {1 => 2, 3 => 4, 5 => 6}

Questa conversione è possibile solo se l’array ha un numero pari di elementi.
4. Ordinamento
Una hash, come visto nel post precedente, è una struttura non ordinata.
Tuttavia in alcuni casi può rendersi necesario ordinarne i valori. Esiste quindi un metodo sort anche per le hash il cui risultato però è un array.
Questo perchè Ruby, per ordinare una hash la converte in un array di array e poi lo ordina.

1 2	beatles = {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison"} beatles.sort # [["George", "Harrison"], ["Jonn", "Lennon"], ["Paul", "McCartney"], ["Ringo", "Starr"]]

5. Merge di due Hash
L’ultimo argomento che voglio trattare oggi è il merge di due hash.
Supponiamo di voler fare un improbabile merge tra due storici gruppi, i Beatles ed i Rolling Stones:

1
2
3

beatles = {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison"}
rolling_stones = {"Mick" => "Jagger", "Keith" => "Richards", "Ronnie" => "Wood", "Charlie" => "Watts"}
rolling_beatles = beatles.merge(rolling_stones)

Il risultato è una terza hash composta come segue:

1
2
3

p rolling_beatles
# {"Jonn" => "Lennon", "Ringo" => "Starr", "Paul" => "McCartney", "George" => "Harrison",
"Mick" => "Jagger", "Keith" => "Richards", "Ronnie" => "Wood", "Charlie" => "Watts"}

Nel caso di chiavi duplicate però, il merge mantiene solo la chiave della seconda hash:

1
2
3

a = {"a" => 1, "b" => 2, "c" =>3}
b = {"a" => 5, "d" => 7, "e" =>9}
c = a.merge(b) # {"a" => 5, "b" => 2, "c" =>3, "d" => 7, "e" => 9}

In alternativa, è possibile passare al metodo merge un blocco di codice per gestire i conflitti sulle chiavi

1
2
3
4

a = {"a" => 1, "b" => 2, "c" =>3}
b = {"a" => 5, "d" => 7, "e" =>9}
c = a.merge(b) {|key, old_val, new_val| old_val < new_val ? old_val : new_val}
# {"a" => 1, "b" => 2, "c" =>3, "d" => 7, "e" => 9}

Come potete vedere il risultato di questo merge è differente dal precedente in base alla condizione specificata nel blocco di codice.

Share on:

DevInterface Blog

Information Technology: è tempo di freelance e agenzie specializzate

Related Post

Inserire box di commento Disqus più volte nella stessa pagina

Related Post

Tips: Paginazione multipla con will_paginate

Related Post

Registrazione in due step con Devise

Related Post

Lancio del portale Gruppi Emergenti

Random Posts

Prevenire la registrazione di login riservate

Related Post

Un nuovo layout più semplice e spazioso

Related Post

Come spedire email in modo asincrono con Devise e Rails3

Related Post

Come implementare due dropdown dipendenti l’una dall’altra in Django e jQuery

Related Post

Ruby Enumerables: Operazioni con le hash

Related Post