Estoy aprendiendo RoR proveniente de muchos años de c # y MSSQL.

Elegí un proyecto para construir un sitio web para mi hermano que es administrador de propiedades de alquiler. Pensé que esto debería ser bastante fácil, ya que los modelos deberían ser sencillos, pero creo que puedo estar pensando demasiado en todo o estoy teniendo problemas para dejar el "viejo" camino. De todos modos, aquí está el problema. Estoy comenzando con solo dos modelos (Usuario y Propiedad). El modelo de propiedad es fácil, el usuario no tanto. Pensé que tenemos tres tipos de usuarios en el sistema. Inquilinos, propietarios y gerentes (mi hermano será el único gerente pero pensé que lo diseñaría para crecer) Él administra propiedades para varios propietarios, cada uno de los cuales puede tener muchas propiedades. Cada propiedad tendrá un propietario, un inquilino y un administrador.

Los inquilinos podrán iniciar sesión y solo ver la propiedad que alquilan para tal vez completar una solicitud de mantenimiento o algo así ... (no es un requisito real en este punto incluso dar al inquilino un inicio de sesión en el sistema, pero pensé que sería un buen ejercicio)

Lo mismo ocurre con los propietarios, ninguno de ellos realmente necesita acceso al sistema (contratan a mi hermano para que no tengan que involucrarse), pero pensé que podría ser agradable y nuevamente un buen ejercicio.

Utilicé el Nifty_generator para generar un usuario, que solo proporciona correo electrónico, contraseña, etc. Lo he extendido de la siguiente manera ...

class AddProfileDataToUsers < ActiveRecord::Migration
  def self.up
    add_column :users, :first_name, :string
    add_column :users, :last_name, :string
     add_column :users, :address1, :string
     add_column :users, :address2, :string
     add_column :users, :city,:string
     add_column :users, :state, :string
     add_column :users, :zip, :string
     add_column :users, :phone, :string
     add_column :users, :email, :string
     add_column :users, :user_type, integer
  end

  def self.down 
    remove_column :users, :first_name 
    remove_column :users, :last_name
   remove_column :users, :address1
   remove_column :users, :address2
   remove_column :users, :city
   remove_column :users, :state
   remove_column :users, :zip 
   remove_column :users, :phone 
   remove_column :users, :email 
   remove_column :users, :user_type
  end
end

Aquí está el código para crear la tabla de propiedades

class CreateProperties < ActiveRecord::Migration
  def self.up
    create_table :properties do |t|
      t.string :address
      t.string :city
      t.string :type
      t.integer :beds
      t.float :baths
      t.float :price
      t.float :deposit
      t.string :terms
      t.string :laundry
      t.datetime :date_available
      t.integer :sqft
      t.integer :owner_id
      t.integer :manager_id
      t.integer :tenant_id
      t.timestamps
    end
  end

  def self.down
    drop_table :properties
  end
end

Agregué lo siguiente al modelo de usuario que fue generado por el generador de autenticación nifty

class User < ActiveRecord::Base

  #other stuff in the user model up here......
  validates_length_of :password, :minimum => 4, :allow_blank => true

  #this is the stuff that I have added to the user model
  has_many :managed_properties, :class_name => "Property", :foreign_key => "manager_id"
  has_many :owned_properties, :class_name => "Property", :foreign_key => "owner_id"
  has_one :rented_property, :class_name => "Property", :foreign_key => "tenant_id"

Luego agregué esto al modelo de propiedad ...

class Property < ActiveRecord::Base
    belongs_to :manager, :class_name => "User" #picked up by the manager_id
    belongs_to :owner, :class_name => "User"  #picked up by the owner_id
    belongs_to :tenant, :class_name => "User"  #picked up by the tenant_id
end

Mi pregunta es, ¿esto parece una forma aceptable de modelar la situación que describí?

¿Debo usar la herencia de una sola tabla y crear un modelo de inquilino; un modelo de gerente; y un modelo de propietario? El problema que vi al hacer eso fue que un solo usuario podía ser tanto gerente como propietario. Esto podría resolverse teniendo tablas de roles para el usuario donde un usuario tiene muchos roles y un rol tiene muchos usuarios. También había mirado una tabla de perfil con una coincidencia individual con la tabla de usuario y haciendo esto polimórfico, pero no pensé que esta situación realmente requiriera eso y no resolvió el problema donde un usuario puede ser propietario y un gerente .....

Esto es cuando comencé a pensar que tal vez había terminado de pensar el problema y se me ocurrió lo que ves aquí.

Agradezco cualquier comentario constructivo que pueda tener. Tenga en cuenta que en realidad nunca he construido nada en Rails y todo esto es un primer intento, hace una semana ni siquiera había instalado rails en mi computadora.

No sé si esto importa, pero pensé que el administrador / gerente sería responsable de crear usuarios. Este no será un tipo de sitio de autorregistro. El gerente agregará nuevos propietarios cuando registre un nuevo propietario, y lo mismo se aplicará a los inquilinos. Esto facilitará la determinación del tipo de usuario que está creando.

Gracias por cualquier idea que pueda tener.