**Course Title:** Mastering Ruby on Rails: Building Scalable Web Applications **Section Title:** Final Project and Advanced Topics **Topic:** Begin working on the final project that integrates learned concepts into a full-stack Ruby on Rails web application.(Lab topic) **Objective:** By the end of this topic, students will have a fully functional, scalable, and maintainable Ruby on Rails web application that integrates all the concepts learned throughout the course. Students will apply their knowledge of Ruby, Rails, and advanced topics to build a real-world application. **Prerequisites:** - Completion of all previous topics - Familiarity with Ruby and Rails basics - A local development environment set up with Ruby, Rails, and a code editor **Step 1: Project Planning and Requirements Gathering** Before starting the project, take some time to plan and gather requirements. This will help you stay focused and ensure that your application meets the needs of your users. * Identify the problem or opportunity that your application will address * Conduct user research to understand their needs and pain points * Create a list of features and requirements for your application * Prioritize features based on importance and complexity **Example:** Let's say you're building an e-commerce application. Your requirements might include: * User authentication and authorization * Product management (create, read, update, delete) * Order management (create, read, update, delete) * Payment processing * Shipping integration **Step 2: Setting up the Project Structure** Create a new Rails project using the command `rails new my_app --api`. This will set up a basic project structure for you. * Create a new directory for your project and navigate to it in your terminal * Run `rails new my_app --api` to create a new Rails project * Create a new directory for your project's assets (images, stylesheets, etc.) and a new directory for your project's models, views, and controllers **Example:** ```bash mkdir my_app cd my_app rails new my_app --api ``` **Step 3: Defining the Database Schema** Create a new migration to define the database schema for your application. This will include the tables and columns for your models. * Run `rails generate migration CreateUsers table` to create a new migration * Edit the migration file to define the columns for your users table * Run `rails db:migrate` to apply the migration to your database **Example:** ```ruby class CreateUsers < ActiveRecord::Migration[6.1] def change create_table :users do |t| t.string :name t.string :email t.string :password t.timestamps end end end ``` **Step 4: Building the Models** Create new models for each of the entities in your application. This will include the User model, Product model, and Order model. * Run `rails generate model User name:string email:string password:string` to create a new User model * Run `rails generate model Product name:string description:string price:decimal` to create a new Product model * Run `rails generate model Order user:references products:many-to-many` to create a new Order model **Example:** ```ruby class User < ApplicationRecord validates :name, :email, :password, presence: true end class Product < ApplicationRecord validates :name, :description, :price, presence: true end class Order < ApplicationRecord belongs_to :user has_many :products end ``` **Step 5: Building the Controllers** Create new controllers for each of the actions in your application. This will include the UsersController, ProductsController, and OrdersController. * Run `rails generate controller Users` to create a new UsersController * Run `rails generate controller Products` to create a new ProductsController * Run `rails generate controller Orders` to create a new OrdersController **Example:** ```ruby class UsersController < ApplicationController def index @users = User.all end def show @user = User.find(params[:id]) end def new @user = User.new end def create @user = User.new(user_params) if @user.save redirect_to users_path, notice: 'User created successfully' else render :new end end private def user_params params.require(:user).permit(:name, :email, :password) end end ``` **Step 6: Building the Views** Create new views for each of the templates in your application. This will include the index.html.erb, show.html.erb, new.html.erb, and create.html.erb templates. * Run `rails generate view Users index` to create a new index.html.erb template * Run `rails generate view Users show` to create a new show.html.erb template * Run `rails generate view Users new` to create a new new.html.erb template * Run `rails generate view Users create` to create a new create.html.erb template **Example:** ```erb <!-- users/index.html.erb --> <h1>Users</h1> <ul> <% @users.each do |user| %> <li><%= user.name %></li> <% end %> </ul> ``` **Step 7: Routing** Define routes for each of the actions in your application. This will include the root route, users route, products route, and orders route. * Run `rails generate route users` to create a new users route * Run `rails generate route products` to create a new products route * Run `rails generate route orders` to create a new orders route **Example:** ```ruby # config/routes.rb Rails.application.routes.draw do root 'users#index' resources :users do member do get :show get :new post :create end end resources :products do member do get :show get :new post :create end end resources :orders do member do get :show get :new post :create end end end ``` **Step 8: Testing** Write tests for each of the models, controllers, and views in your application. This will ensure that your application is working as expected. * Run `rails generate test_user` to create a new test_user model * Run `rails generate test_product` to create a new test_product model * Run `rails generate test_order` to create a new test_order model **Example:** ```ruby # spec/models/user_spec.rb require 'rails_helper' RSpec.describe User, type: :model do it { is_expected.to have_attribute(:name) } it { is_expected.to have_attribute(:email) } it { is_expected.to have_attribute(:password) } end ``` **Step 9: Deployment** Deploy your application to a production environment. This will include setting up a new Heroku app or AWS instance. * Run `heroku create` to create a new Heroku app * Run `aws cloudformation create-stack --stack-name my_app --template-body file://template.yaml` to create a new AWS instance **Example:** ```bash heroku create aws cloudformation create-stack --stack-name my_app --template-body file://template.yaml ``` **Step 10: Monitoring and Maintenance** Monitor your application for performance issues and maintenance tasks. This will include setting up new logs and monitoring tools. * Run `rails generate logger` to create a new logger * Run `aws cloudwatch create-logs-group --log-group-name my_app` to create a new AWS logs group **Example:** ```bash rails generate logger aws cloudwatch create-logs-group --log-group-name my_app ``` **Conclusion:** By following these steps, you have successfully integrated all the concepts learned throughout the course into a fully functional, scalable, and maintainable Ruby on Rails web application. You have applied your knowledge of Ruby, Rails, and advanced topics to build a real-world application. **Next Steps:** * Continue to monitor and maintain your application * Add new features and functionality to your application * Explore new technologies and tools to improve your application **Leave a comment or ask for help:**