Relevant source files

The following files were used as context for generating this wiki page: - [app/models/application_record.rb](https://github.com/basecamp/fizzy/blob/main/app/models/application_record.rb) - [app/models/board.rb](https://github.com/basecamp/fizzy/blob/main/app/models/board.rb) - [app/models/card.rb](https://github.com/basecamp/fizzy/blob/main/app/models/card.rb) - [app/models/user.rb](https://github.com/basecamp/fizzy/blob/main/app/models/user.rb) [FILE_URLS] (use these URLs when citing sources in the content): - app/models/application_record.rb: https://github.com/basecamp/fizzy/blob/main/app/models/application_record.rb - app/models/board.rb: https://github.com/basecamp/fizzy/blob/main/app/models/board.rb - app/models/card.rb: https://github.com/basecamp/fizzy/blob/main/app/models/card.rb - app/models/user.rb: https://github.com/basecamp/fizzy/blob/main/app/models/user.rb

# Models This document provides a comprehensive overview of the data models within the Fizzy project. The models form the core of the application's business logic, defining the structure of the data, the relationships between different data entities, and the rules for data manipulation and validation. They are built on top of the Ruby on Rails Active Record framework, which provides an object-relational mapping (ORM) layer to interact with the database. The primary models discussed here are `User`, `Board`, and `Card`, which represent the fundamental entities of the application. All these models inherit from a common base class, `ApplicationRecord`, which provides shared functionality and configurations. ## Core Model Architecture The application's models follow a standard Rails convention, inheriting from a central `ApplicationRecord` class. This base class extends `ActiveRecord::Base`, enabling all models to benefit from the full suite of Active Record features, including database abstraction, validations, associations, and callbacks. The following diagram illustrates the inheritance hierarchy of the core models. ```mermaid classDiagram direction TB class ActiveRecord__Base { <> } class ApplicationRecord { <> } class User { +string: name +string: email +has_many: boards +has_many: cards } class Board { +string: title +belongs_to: user +has_many: cards } class Card { +string: title +text: description +belongs_to: user +belongs_to: board } ActiveRecord__Base <|-- ApplicationRecord ApplicationRecord <|-- User ApplicationRecord <|-- Board ApplicationRecord <|-- Card ``` ### ApplicationRecord The `ApplicationRecord` class serves as the parent for all models in the application. By centralizing common configurations and methods here, developers can ensure consistency and reduce code duplication across the entire model layer. For example, global scopes or default behaviors can be defined in this file. Sources: [app/models/application_record.rb](https://github.com/basecamp/fizzy/blob/main/app/models/application_record.rb) ## Model Relationships and Data Flow The models are interconnected through a series of associations that define how they relate to one another. The primary relationship is between `User`, `Board`, and `Card`, forming a hierarchical structure where users own boards, and boards contain cards. ### Entity-Relationship Diagram The following ER diagram visualizes the database schema and the relationships between the `users`, `boards`, and `cards` tables. ```mermaid erDiagram users { int id PK string name string email datetime created_at datetime updated_at } boards { int id PK string title int user_id FK datetime created_at datetime updated_at } cards { int id PK string title text description int user_id FK int board_id FK datetime created_at datetime updated_at } users ||--o{ boards : "owns" users ||--o{ cards : "creates" boards ||--o{ cards : "contains" ``` ### User Model The `User` model represents an individual user of the application. It is the top-level entity in the data hierarchy. - **Attributes**: A user has a `name` and an `email`. - **Associations**: - A `User` `has_many` `boards`, representing the boards they have created. - A `User` `has_many` `cards`, representing all cards they have created across all boards. Sources: [app/models/user.rb](https://github.com/basecamp/fizzy/blob/main/app/models/user.rb) ### Board Model The `Board` model acts as a container for cards, similar to a project or a to-do list. - **Attributes**: A board has a `title`. - **Associations**: - A `Board` `belongs_to` a `User`, establishing the owner of the board. - A `Board` `has_many` `cards`, which are the individual items within that board. Sources: [app/models/board.rb](https://github.com/basecamp/fizzy/blob/main/app/models/board.rb) ### Card Model The `Card` model represents an individual task, note, or item within a board. - **Attributes**: A card has a `title` and a `description`. - **Associations**: - A `Card` `belongs_to` a `User`, identifying its creator. - A `Card` `belongs_to` a `Board`, specifying which board it belongs to. Sources: [app/models/card.rb](https://github.com/basecamp/fizzy/blob/main/app/models/card.rb) ## Summary The models in the Fizzy project provide a robust and scalable foundation for the application's data layer. By leveraging Ruby on Rails' Active Record and adhering to clear architectural patterns, the models define a simple yet powerful relationship between `Users`, `Boards`, and `Cards`. This structure supports the core functionality of the application, enabling users to create and manage boards and their associated cards efficiently.