# Has\_and\_belongs\_to\_many come riempire la join table?

**URL:** <https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778>\
**Category:** IT\
**Created:** [January 27, 2009, 9:36pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778 "2009-01-27T21:36:20Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 9:36pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/1 "2009-01-27T21:36:20Z")

</div>

Siccome nella join table non ho bisogno di gestire nessuna informazione  
aggiuntiva alle due foreign keys che mettono in relazione molti a molti  
due  
tabelle ho preferito usare has\_and\_belongs\_to\_many piuttosto che  
has\_many  
:through.  
La domanda e’: la tabella di join va popolata manualmente oppure esiste  
un  
meccanismo automatico che si occupa di popolarla quando vengono inseriti  
dati nelle due tabelle in relazione?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 9:52pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/2 "2009-01-27T21:52:15Z")

</div>

Se crei correttamente i due has\_and\_belongs\_to\_many la tabella di join  
si  
autopopola 😃

2009/1/27 Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 9:57pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/3 "2009-01-27T21:57:35Z")

</div>

Il 27 gennaio 2009 21.35, Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) ha scritto:

> Siccome nella join table non ho bisogno di gestire nessuna informazione  
> aggiuntiva alle due foreign keys che mettono in relazione molti a molti due  
> tabelle ho preferito usare has\_and\_belongs\_to\_many piuttosto che has\_many  
> :through.  
> La domanda e’: la tabella di join va popolata manualmente oppure esiste un  
> meccanismo automatico che si occupa di popolarla quando vengono inseriti  
> dati nelle due tabelle in relazione?

dai un’occhiata a:

> **[\#17 HABTM Checkboxes - RailsCasts](http://railscasts.com/episodes/17-habtm-checkboxes)**
>
> Short Ruby on Rails screencasts containing tips, tricks and tutorials. Great for both novice and experienced web developers.

> **[\#47 Two Many-to-Many - RailsCasts](http://railscasts.com/episodes/47-two-many-to-many)**
>
> Short Ruby on Rails screencasts containing tips, tricks and tutorials. Great for both novice and experienced web developers.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 10:47pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/4 "2009-01-27T22:47:36Z")

</div>

Il 27 gennaio 2009 22.19, Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) ha scritto:

> A questo punto ho lanciato script/console e fatto un  
> @category=Categoyt.create(…) e  
> @supplier=Supplier.create(…)  
> Le due tabelle categories e suppliers vengono popolate ma la tabella di join  
> no.

cosa c’è in quei …?  
in particolare, dov’è il dato di quali categorie appartengono a quali  
supplier?

@supplier.categories = Category.find(:all)  
@supplier.save

oppure:  
@category.suppliers = Supplier.first

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 10:19pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/5 "2009-01-27T22:19:55Z")

</div>

2009/1/27 Sandro P. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)

> Se crei correttamente i due has\_and\_belongs\_to\_many la tabella di join si  
> autopopola 😃

Allora ti spiego com’e’ la situazione perche’ la tabella di join non si  
e’  
autopopolata.  
Dunque i modelli sono  
class Category \< ActiveRecord::Base  
belongs\_to :sector  
has\_and\_belongs\_to\_many :suppliers  
end

Il belongs to sector e’ perche’ la categoria appartiene ad un settore  
specifico, ma il mio problema e’ tra Category e:

class Supplier \< ActiveRecord::Base  
has\_and\_belongs\_to\_many :categories  
end

A questo punto ho lanciato script/console e fatto un  
@category=Categoyt.create(…) e  
@supplier=Supplier.create(…)  
Le due tabelle categories e suppliers vengono popolate ma la tabella di  
join  
no.  
La migration per la tabella di join e’:

class CreateCategoriesSuppliersJoin \< ActiveRecord::Migration  
def self.up  
create\_table :categories\_suppliers, :id =\> false do |t|  
t.references :category, :null =\> false  
t.references :supplier, :null =\> false  
end

def self.down  
drop\_table :categories\_suppliers  
end  
end  
end

Dove sbaglio? A me sembra tutto giusto.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 10:48pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/6 "2009-01-27T22:48:49Z")

</div>

2009/1/27 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> @category.suppliers = Supplier.first

scusa:  
@category.suppliers = [Supplier.first]

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 10:51pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/7 "2009-01-27T22:51:46Z")

</div>

2009/1/27 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)

> 2009/1/27 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):
> 
> > @category.suppliers = Supplier.first
> 
> scusa:  
> @category.suppliers = [Supplier.first]
> 
> * * *
> 
> Ml mailing list  
> removed\_email\_address@domain.invalid  
> [http://lists.ruby-it.org/mailman/listinfo/ml](http://lists.ruby-it.org/mailman/listinfo/ml)

Quindi la tabella di join non viene popolata automaticamente come hai  
detto,  
bisogna intevenire col codice o qualcosa mi sfugge?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 10:55pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/8 "2009-01-27T22:55:17Z")

</div>

2009/1/27 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid)

> Il 27 gennaio 2009 22.19, Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) ha scritto:
> 
> > A questo punto ho lanciato script/console e fatto un  
> > @category=Categoyt.create(…) e  
> > @supplier=Supplier.create(…)  
> > Le due tabelle categories e suppliers vengono popolate ma la tabella di  
> > join  
> > no.
> 
> cosa c’è in quei …?

Ci sono i campi valorizzati @category=Categoyt.create(:id =\> 1, :codice  
=\>‘A01’, :descrizione =\> ‘prova’)  
@supplier=Supplier.create(:id =\> 1, :nome =\> ‘pingo’, :cognome =\>  
‘pongo’)

> in particolare, dov’è il dato di quali categorie appartengono a quali  
> supplier?

Dovrebbero essere le foreign keys nella tabella di join no? category\_id  
e  
supplier\_id.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [January 27, 2009, 11:26pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/9 "2009-01-27T23:26:25Z")

</div>

2009/1/27 Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Dovrebbero essere le foreign keys nella tabella di join no? category\_id e  
> supplier\_id.

andiamo con ordine.  
tu hai Supplier e Category, e ogni supplier può appartenere a più  
categorie e ogni categoria può appartenere a ogni supplier.

una volta che hai creato una categoria e un supplier, c’è ancora un  
dato che manca: questa categoria si applica a questo supplier?

se hai tre categorie e tre suppier, il software non può indovinare  
come sono associate.

ci sono diversi modi di procedere, in base a come vuoi che sia  
l’interfaccia:

a) puoi inserire prima tutte le categorie, poi tutti i clienti e  
infine fare un rettangolo di checkbox in cui spuntare quelle giuste;

(crei gli oggetti così come hai fatto finora, poi fai il form  
(eventualmente parliamo di come si può fare) e fai le varie  
associazioni;

b) puoi inserire prima le categorie; quando poi inserisci ogni  
supplier, scegli con checkbox o una select multipla le categorie per  
questo supplier;

c) puoi fare una cosa mista, più complessa ma forse più comoda per  
l’utente: quando inserisci una categoria, fai scegliere tra i supplier  
già presenti ed eventualmente dei nuovi, e viceversa, quando inserisci  
un supplier, fai scegliere tra le categorie.

quasi tutto il lavoro lo fa activerecords da solo: come ti ho scritto,  
puoi aggiungere o togliere oggetti direttamente agendo su  
@supplier.categories, o @category.suppliers come se fossero array  
(anche se un occhio a quello che poi succede in termini di interazione  
col database non guasta).

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 4, 2009, 11:31pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/10 "2009-02-04T23:31:30Z")

</div>

2009/1/27 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> se hai tre categorie e tre suppier, il software non può indovinare
> 
> b) puoi inserire prima le categorie; quando poi inserisci ogni  
> supplier, scegli con checkbox o una select multipla le categorie per  
> questo supplier;

Piano piano comincio a capire grazie anche agli episodi su railscast,  
veramente utili 🙂  
Ho scelto la soluzione b.  
Una parte del codice della view per i suppliers e’:

\<%= f.label :aggiudicazioniGare %\>  
 \<%= f.text\_field :aggiudicazioniGare %\>

\<%= f.label :note %\>  
 \<%= f.text\_area :note %\>

\<%= f.label :categorie %\>  
 \<%= f.collection\_select :category\_ids, @categories, :id, :descrizione %\>

Dove quindi ho una select attraverso la quale indicare la categoria  
associata al fornitore.  
Ovviamente nel controller fornitore ho: @categories=Category.find(:all).  
Funziona 🙂  
Pero’ mi serve qualcosa di piu’:  
Le categorie fanno parte di diversi settori, cioe’ ho un’associazione  
uno a molti tra settori e categorie.  
Quando inserisco un nuovo fornitore percio’, non voglio assegnarli la  
categoria di appartenenza scegliendo tra tutte le categorie  
disponibili, bensi’ vorrei prima indicare il settore per poi scegliere  
tra le categorie appartenenti al settore selezionato.  
Non so se sono riuscito a spiegarmi.  
Dovrei capire a fondo i meccanismi che collegano i modelli con i  
controllers con le views, e infatti li sto capendo piano piano  
lavorando sul campo, solo che non riesco a trovare la soluzione a  
questo banale problemino.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 5, 2009, 1:12pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/11 "2009-02-05T13:12:26Z")

</div>

2009/2/4 Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Pero’ mi serve qualcosa di piu’:  
> Le categorie fanno parte di diversi settori, cioe’ ho un’associazione  
> uno a molti tra settori e categorie.  
> Quando inserisco un nuovo fornitore percio’, non voglio assegnarli la  
> categoria di appartenenza scegliendo tra tutte le categorie  
> disponibili, bensi’ vorrei prima indicare il settore per poi scegliere  
> tra le categorie appartenenti al settore selezionato.

chiarissimo.

nella mia applicazione ho incontrato questo problema più volte.

in un caso, poiché le opzioni possibili erano veramente tante, ho fatto  
così:  
una normale select “settore”, poi un observe\_field che, quando scatta,  
fa una richiesta ajax a un apposito metodo di un controller, che  
restituisce la select con le sole categorie per quel settore.

relativamente veloce da scrivere, però, ripeto, consigliabile solo se  
il numero di settori e/o categorie è molto molto alto, perché la  
richiesta ajax ci impiega un po’.

in un altro caso, le opzioni possibili erano pochi, ho usato  
javascript (in una view: era un file .js.erb):

var sections = new Array();  
\<%- for section in @sections -%\>  
elem = document.createElement(‘optgroup’);  
elem.setAttribute(‘id’, ‘\<%= “group#{section.id}” -%\>’);  
elem.appendChild(create\_option(‘’, ‘\<%= t(:option\_pick\_a\_user) -%\>’));  
\<% for user in section.users -%\>  
elem.appendChild(create\_option(‘\<%= user.id -%\>’, ‘\<%= user.nick  
-%\>’));  
\<% end -%\>  
sections[‘\<%= section.id -%\>’] = elem;  
\<% end -%\>

function create\_option(value, text) {  
o = document.createElement(‘option’);  
o.setAttribute(‘value’, value);  
o.appendChild(document.createTextNode(text));  
return o;  
}

function set\_users() {  
section = $(‘assignment\_section\_id’).value;  
if (section == “”) {  
$(‘users’).hide();  
$(‘buttons’).hide();  
}  
else {  
sel = $(‘assignment\_user\_id’);  
children = sel.childNodes;  
for(i = 0; i \< children.length; i++)  
sel.removeChild(children[i]);  
sel.appendChild(sections[section]);  
$(‘users’).show();  
$(‘buttons’).show();  
}  
}

come vedi, ho popolato un array javascript, e poi nella view uso:

\<%= observe\_field “id\_della\_select”, :function =\> “set\_users()” %\>

forse è possibile creare gli optgroup direttamente da codice erb,  
senza usare javascript, crearli tutti invisibili e poi mostrare quello  
giusto, ma non ne sono sicuro.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 11, 2009, 5:42pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/12 "2009-02-11T17:42:16Z")

</div>

2009/2/5 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> nella mia applicazione ho incontrato questo problema più volte.
> 
> in un caso, poiché le opzioni possibili erano veramente tante, ho fatto così:
> 
> una normale select “settore”, poi un observe\_field che, quando scatta,  
> fa una richiesta ajax a un apposito metodo di un controller, che  
> restituisce la select con le sole categorie per quel settore.

Tanto per cominciare mi trovo nella banale situazione di inserire  
nella view dei fornitori la lista dei settori.  
Ancora prima di poter selezionare la categoria di appartenenza del  
fornitore devo scegliere il settore, il problema su come poi  
visualizzare le categorie relative a quel settore lo risolvo dopo.  
Nella view del fornitore, new.html.erb, ho inserito \<%=  
f.collection\_select :sector\_id, @sectors, :id, :descr %\> ma ovviamente  
mi da errore perche’ il metodo sector\_id non esiste nella classe  
fornitore.  
Mi trovo in stand\_by per questo banale problema.

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 5, 2009, 1:24pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/13 "2009-02-05T13:24:46Z")

</div>

2009/2/5 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> \<% end -%\>  
> function set\_users() {  
> sel.appendChild(sections[section]);  
> forse è possibile creare gli optgroup direttamente da codice erb,  
> senza usare javascript, crearli tutti invisibili e poi mostrare quello  
> giusto, ma non ne sono sicuro.

Ah ecco, piu’ complicato del previsto, agli observe non ci sono ancora  
arrivato 🙂

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 12:57am UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/14 "2009-02-15T00:57:32Z")

</div>

Pietro G. wrote:

> \<%= observe\_field “id\_della\_select”, :function =\> “set\_users()” %\>

Come mai richiami una funzione javascript e non un’azione del  
controller?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 12:23pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/15 "2009-02-15T12:23:55Z")

</div>

2009/2/15 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> caricarli tutti (in questo caso creando un array javascript) per poi  
> mostrare quelli giusti. in questo caso, non si chiama nessun’azione  
> del server.
> 
> quando invece i dati sono tanti, allora si preferisce fare una richiesta ajax.
> 
> tra parentesi: su quale sia il modo migliore di gestire le richieste  
> dinamiche ci sono varie scuole. io finora ho usato prototype, ma vedo  
> che sempre più gente utilizza jquery, che sembra carino, anche se non  
> l’ho ancora provato.

Ho proprio ieri potuto apprezzare l’utilita’ dell’observ\_field.  
Per poter utlizzare ajax ho utilizzato, come indicato nel manuale  
agile web development with rails, \<% javascript\_include\_tag :defauts  
%\>.  
Non quindi se viene utilizzato jquery o prototype, c’e’ un modo per  
capirlo?  
Un’altra domanda.  
Bene o male nel form di “nuovo fornitore”, in cui va riempito il form  
per la creazione di un nuovo fornitore, sono riuscito ad inserire  
l’elenco dei settori e, alla scelta di un settore, tramite  
l’observ\_field, vengono presentate le categorie relative.  
Tutto nella stessa pagina.  
Se non sbaglio pero’ e’ impossibile fare tutto con un’unica  
operazione, nel senso: creare un nuovo fornitore e contemporaneamente  
assegnargli le categorie di appartenenza.  
Devo prima avere gia’ in tabella l’id del fornitore e solo cosi’ posso  
successivamente assegnare tale fornitore a diverse categorie.  
Sbaglio?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 9:29am UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/16 "2009-02-15T09:29:17Z")

</div>

2009/2/15 Msan M. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Pietro G. wrote:
> 
> > \<%= observe\_field “id\_della\_select”, :function =\> “set\_users()” %\>
> 
> Come mai richiami una funzione javascript e non un’azione del  
> controller?

come ti dicevo, non sempre è necessario usare ajax: se i dati tra cui  
scegliere sono pochi\*, si può prendere in considerazione l’idea di  
caricarli tutti (in questo caso creando un array javascript) per poi  
mostrare quelli giusti. in questo caso, non si chiama nessun’azione  
del server.

quando invece i dati sono tanti, allora si preferisce fare una richiesta  
ajax.

tra parentesi: su quale sia il modo migliore di gestire le richieste  
dinamiche ci sono varie scuole. io finora ho usato prototype, ma vedo  
che sempre più gente utilizza jquery, che sembra carino, anche se non  
l’ho ancora provato.

- cosa vuol dire pochi e molti? non saprei, è difficile stabilirlo,  
dipende da tanti fattori, come la velocità di connessione. non so se  
qualcuno, là fuori, ha proposto un limite.

pietro

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 1:19pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/17 "2009-02-15T13:19:49Z")

</div>

2009/2/15 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> - in Provider, crei un attributo virtuale, che so: categories\_wannabe;
> - nel form di creazione, passi le categorie con questo nome, ad  
> esempio con fields\_for :categories\_wannabe;
> - sempre in Provider, metti un after\_create o un after\_save (a seconda  
> se ti interessa solo il caso creazione o anche il caso modifica) in  
> cui assegni le categorie.
> 
> trovi un esempio (anche se un po’ diverso) qui:  
> [#75 Complex Forms Part 3 - RailsCasts](http://railscasts.com/episodes/75-complex-forms-part-3)

Perfetto grazie mille 🙂

p.s. che intendi per Provider?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 2:32pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/18 "2009-02-15T14:32:00Z")

</div>

Il 15 febbraio 2009 13.19, Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) ha scritto:

> 2009/2/15 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):  
> p.s. che intendi per Provider?

semplicemente il model del fornitore. supplier? provider?

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 5:31pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/19 "2009-02-15T17:31:01Z")

</div>

2009/2/15 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Il 15 febbraio 2009 13.19, Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid) ha scritto:
> 
> > 2009/2/15 Pietro G. [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):  
> > p.s. che intendi per Provider?
> 
> semplicemente il model del fornitore. supplier? provider?

ah ok supplier allora 🙂

---

<div class="post-metadata">

**Author:** ![mauro](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/m/45deac/32.png) [@mauro](https://www.ruby-forum.com/u/mauro)\
**Post date:** [February 15, 2009, 12:39pm UTC](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778/20 "2009-02-15T12:39:15Z")

</div>

2009/2/15 Mauro [removed\_email\_address@domain.invalid](mailto:removed_email_address@domain.invalid):

> Per poter utlizzare ajax ho utilizzato, come indicato nel manuale  
> agile web development with rails, \<% javascript\_include\_tag :defauts  
> %\>.  
> Non quindi se viene utilizzato jquery o prototype, c’e’ un modo per capirlo?

rails di default usa prototype.

> Se non sbaglio pero’ e’ impossibile fare tutto con un’unica  
> operazione, nel senso: creare un nuovo fornitore e contemporaneamente  
> assegnargli le categorie di appartenenza.  
> Devo prima avere gia’ in tabella l’id del fornitore e solo cosi’ posso  
> successivamente assegnare tale fornitore a diverse categorie.  
> Sbaglio?

non è ancora possibile farlo automaticamente (cioè senza sgobbare); lo  
sarà presto: nella 2.3 dovrebbe introdurre i nested form, che servono  
esattamente a questo.

tuttavia c’è un modo per ottenere il risultato che vuoi.

in breve:

- in Provider, crei un attributo virtuale, che so: categories\_wannabe;
- nel form di creazione, passi le categorie con questo nome, ad  
esempio con fields\_for :categories\_wannabe;
- sempre in Provider, metti un after\_create o un after\_save (a seconda  
se ti interessa solo il caso creazione o anche il caso modifica) in  
cui assegni le categorie.

trovi un esempio (anche se un po’ diverso) qui:

> **[\#75 Complex Forms Part 3 - RailsCasts](http://railscasts.com/episodes/75-complex-forms-part-3)**
>
> Short Ruby on Rails screencasts containing tips, tricks and tutorials. Great for both novice and experienced web developers.

pietro

[Next page](https://www.ruby-forum.com/t/has-and-belongs-to-many-come-riempire-la-join-table/158778.md?page=2)