Struttura dei dati del modello corretta? (La mia app 1st Rails)

Question

Sto per creare la mia prima applicazione Ruby on Rails (e prima di tutto oltre xhtml e css), e sto cercando un feedback utile sulla mia struttura del modello.

Ho incluso un modello per aiutare a visualizzare l'applicazione.

Gli unici modelli di cui sono sicuro di aver bisogno finora sono:
1. un film modello (per fungere da modello principale, chiamato film così gli URL appariranno, & Quot; sitename.com/movies/1-Willy-Wonka ") e
2. un utente modello

Oltre a quelli, non so cosa fare gli altri; come "location delle riprese", "attori" e, soprattutto, attributi come "willy wonka" e "johnny depp".

Devo creare tutti quei modelli, anche gli attributi? In tal caso, è possibile e consigliato consentire alle persone di creare modelli come attributi?

Provo a vedere l'app come dati creati dai moduli e memorizzati nei database, e con quel pov non riesco a decidere come collegare gli attributi (carattere < = > attore) alle sezioni ( attori, luoghi delle riprese, opere d'arte, ecc.) all'interno di un elenco di film; pur consentendo agli attributi stessi di essere collegamenti ipertestuali ad attributi / film / persino sezioni correlate: facendo clic su "Steven Speilberg" si accederà a una pagina con i film in cui ha recitato, i film che ha diretto, prodotto, scritto, ecc.

Pensieri?

Answer 1

Ti consiglio di chiarire prima il tuo modello di dati. È quindi possibile iniziare con un modello di binari per tabella del database. Questo non è sempre il caso, ma è un punto di partenza ragionevole.

Concentriamoci sui film e sugli attori:

Alcuni presupposti:

• i film possono avere una relazione molti-a-molti con le altre entità
• vuoi memorizzare le informazioni sul personaggio come parte della relazione tra un attore e un film

Potresti quindi modellare le tue relazioni in questo modo:

# movies.rb
class Movie < ActiveRecord::Base
  has_many :roles
  has_many :actors, :through => :roles
end

# actor.rb
class Actor < ActiveRecord::Base
  has_many :roles
  has_many :movies, :through => :roles
end

Normalmente, puoi fare affidamento sulla magia di Rails per gestire il modello di join senza crearne uno tu stesso. In questo caso vogliamo archiviare le informazioni sul personaggio come attributi del modello di join, quindi le creiamo esplicitamente.

# role.rb
class Role < ActiveRecord::Base
  belongs_to :movie
  belongs_to :actor
end

Answer 2

Inizia con i modelli Movie, Actor, FilmLocation e Character. Film e attore hanno una relazione molti-a-molti (A Movie ha molti attori, un attore ha lavorato a molti film). Anche FileLocation e Movie sono molti a molti. Anche il personaggio (Willy Wonka) e l'attore sono molti-a-molti.

Answer 3

Se questo è il tuo primo passo per quanto riguarda lo sviluppo web, ti suggerisco di iniziare con la scrittura di una semplice app Web che elenca solo i filmati e ti consente di aggiungerli, modificarli ed eliminarli. Basta memorizzare il titolo, una sinossi e forse l'URL della copertina del poster / dvd del film. Quindi lavora per aggiungere attori e associarli al film.

Creazione di un " IMDB-like " sito non è un progetto banale. Avrai relazioni molto complesse oltre ad associare un attore a un film. Gli attori hanno ruoli nei film. E potresti voler diventare ancora più astratto di così e dire che una persona ha un lavoro in un film che ti permetterebbe di tracciare anche cose come i registi, i produttori, i key grip, i casting director.

Non solo dovresti lavorare sul tuo modello di dati, ma lavorare su un piano su ciò in cui vuoi che il sito sia composto e in quale ordine dovresti creare quelle funzionalità (in base alle necessità) e prendere piccoli passi per arrivare a quel finale obiettivo.

Answer 4

Ulteriore elaborazione. Le migrazioni per i modelli sopra elencati potrebbero apparire così:

class CreateMovies < ActiveRecord::Migration
  def self.up
    create_table 'movies' do |t|
      t.string  'title', :null => false
      t.timestamps
    end
  end

  def self.down
    drop_table 'movies' 
  end
end

class CreateActors < ActiveRecord::Migration
  def self.up
    create_table 'actors' do |t|
      t.string  'first_name', 'last_name', :null => false
      t.timestamps
    end
  end

  def self.down
    drop_table 'actors' 
  end
end

I campi movie_id e actor_id sottostanti corrispondono alle belongs_to associazioni nel modello di ruolo sopra e sono le chiavi esterne che consentono alla tabella dei ruoli di unire attori e film. Come ho proposto di modellarlo, character_name è una proprietà di questa relazione ed è quindi un attributo del ruolo. È la tua chiamata se permetti NULL in character_name. Sono sospettoso di NULL, ma in questo caso l'ho permesso in quanto si potrebbe argomentare che in pratica si desidera spesso memorizzare il fatto che un attore è in un determinato film ma non si conosce o si preoccupa del personaggio nome.

class CreateRoles < ActiveRecord::Migration
  def self.up
    create_table 'roles' do |t|
      t.integer 'movie_id', 'actor_id', :null => false
      t.string 'character_name'
      t.timestamps
    end
  end

  def self.down
    drop_table 'roles' 
  end
end

Answer 5

Potrebbe essere utile leggere la normalizzazione del database: http://en.wikipedia.org/ wiki / Database_normalization

Answer 6

In generale, sì. Mi piace che i miei modelli siano il più granulari possibile. Questo rende le cose molto più chiare per qualcuno che non ha familiarità con l'applicazione e facilita il riutilizzo del codice.

È utile avere una solida conoscenza di Associazioni ActiveRecord prima di scrivere un'applicazione complessa. Assicurati di conoscere tutte le associazioni a memoria e ciò che effettivamente generano in termini di tabelle SQL. A volte può sembrare magia e la magia non è necessariamente una buona cosa. Se sai cosa c'è dietro le cose vanno a posto.

Inoltre, non aver paura di scartare tutto e ricominciare da capo mentre sperimenta. È Ruby, quindi non ci vorrà molto per tornare dove eri.