Model użytkownika Ruby On Rails dla wielu typów

FWIW, jak dla mnie wygląda dobrze. Mogę spojrzeć na declarative_autoryzation , Aby zarządzać swoimi rolami, które mogą być nieco zaangażowane, szczególnie z punktu widzenia interfejsu użytkownika. Zarządzanie użytkownikami z wieloma rolami wydaje się bardziej odpowiednie niż STI w tej sytuacji, ponieważ, jak mówisz, użytkownik może być zarówno menedżerem, jak i dzierżawcą itp.

Jednym z rozwiązań pozwalających na oddzielenie kodu dla menedżera, dzierżawcy i właściciela, przy jednoczesnym umożliwieniu użycia wszystkich trzech ról w jednej instancji, może być dynamiczne dołączanie modułów reprezentujących te role w zależności od ról danego użytkownika. Nadal masz podstawową klasę użytkownika, ale zamiast używać STI, które ograniczałoby Cię do pojedynczej struktury dziedziczenia, możesz mieszać Moduły w oparciu o role, które ma każdy użytkownik, co może po prostu obracać się na jakie właściwości belong_to danego użytkownika podczas inicjalizacji.

W tym celu mogę utworzyć fabrykę użytkowników, która może sprawdzić użytkownika pod kątem różnych ról, które odgrywa i rozszerzyć Klasa singleton tego użytkownika z odpowiednim modułem: extend z modułem dzierżawca dla użytkowników posiadających właściwości dzierżawne, extend z modułem Manager dla użytkowników posiadających właściwości zarządzane, itd.

Z punktu widzenia declarative_autoryzation, Można zadeklarować role_symbols podobnie na podstawie tego, czy Asocjacje takie jak managed_properties zostały wypełnione, na przykład:

def role_symbols  
  @roles ||= {:manager => :managed_properties, 
    :tenant => :rented_property, 
    :owner => :owned_properties}.map do |k,v|
      k if !send(v).blank?
    end.compact
end

Ogólnie wydaje mi się, że twój model danych jest dobry, a twój instynkt, aby nie używać STI do zarządzania wieloma rolami, jest prawidłowy. Nie ma myślę, że jesteś na dobrej drodze. Całkiem nieźle jak na pierwsze podanie.

EDIT: wiesz, im więcej o tym myślę, nie jestem pewien, jakie korzyści daje utrzymanie funkcjonalności menedżera/najemcy/właściciela w oddzielnych modułach. W moim poprzednim wcieleniu jako Java / C# guy byłbym za SRP/MKOl i całkowite rozdzielenie obaw. Ale w Ruby i Rails nie jest to aż tak wielka sprawa, ponieważ jest typowanie dynamiczne i sprzężenie nie jest tak duże, a przynajmniej takie samo, co w środowiskach typowanych statycznie. Możesz być całkowicie w porządku, po prostu umieszczając wszystkie funkcje poszczególnych ról w modelu pojedynczego użytkownika i nie martw się modułami, przynajmniej jeszcze nie teraz.

Jestem na ogrodzeniu tutaj, i mile widziane wejście od innych. Dla mnie jedną z zalet klas Ruby, w przeciwieństwie do klas/pakietów Javy lub klas/zestawów. NET, jest to, że zawsze możesz refactor w razie potrzeby i nie być prawie tak zaniepokojony, która klasa, pakiet, przestrzeń nazw, dll lub jar jest powiązana z inną, itd. Nie mówię, że SRP nie jest ważne w Ruby, wcale. Ale nie jestem pod tym względem aż tak paranoiczna jak kiedyś.

EDIT: Paul Russell ma rację. Myślę, że powinieneś poważnie rozważyć dopuszczenie wielu najemców / zarządców / właścicieli na nieruchomość. W Rails można to wyrazić poprzez relacyjną tabelę i has_many: poprzez asocjację, plus STI, aby opisać różne rodzaje relacji. Myślę też, że konieczne będzie odwrócenie relacji między Użytkownikiem (jako najemcą) a nieruchomością. Nieruchomość może mieć więcej niż jednego Najemcę, ale Najemca nie może mieszkać w więcej niż jednej nieruchomości. (a może mogą? To nie w porządku, ale...)

Może coś w stylu (to jest bardzo szybkie i brudne, więc wybacz wszystkie pominięte szczegóły proszę):

class PropertyRole < ActiveRecord::Base
  belongs_to :user
  belongs_to :property
end

class Managership < PropertyRole
  # Manager functionality here
end

class Ownership < PropertyRole
  # Owner functionality here
end

class User < ActiveRecord::Base
  belongs_to :residence, :class_name => 'Property', :foreign_key => 'residence_id'
  has_many :managerships
  has_many :ownerships

  has_many :owned_properties, :through => :ownerships, :classname => 'Property'
  has_many :managed_properties, :through => :managerships, :classname => 'Property'
end

class Property < ActiveRecord::Base
  has_many :tenants, :class_name => 'User', :foreign_key => 'residence_id'
  has_many :managerships
  has_many :ownerships
  has_many :owners, :class_name => 'User', :through => :ownerships
  has_many :managers, :class_name => 'User', :through => :managerships
end

Jak mówiłem, to jest szybkie i brudne, pierwsze podanie na wysokim poziomie. Zauważ, że mamy teraz stworzono role zarządzania i własności, które mogą zawierać funkcje Menedżera i właściciela, eliminując poprzedni dylemat, czy usunąć tę funkcjonalność w oddzielnych modułach.

** zauważ również, że odwróciłem rolę najemcy / nieruchomości-myślę, że była to konieczna zmiana w Twojej domenie. Oczywiście rezydencja może mieć więcej niż jednego najemcę. Wydaje mi się (w tej chwili), że można zachować funkcjonalność specyficzną dla Najemcy w modelu użytkownika.