Forem: Mary Webby

Photogram Authorization

Mary Webby — Mon, 11 Mar 2024 20:11:05 +0000

➔ Notes

first begin with checking for traceable and editable routes that our users could use to change info that isn't theirs. if found, we will then need to go into our routes.rb and add in except and only parameters to our resources :follow_requests controller to not let other users be able to change who gets to follow and unfollow who. so after for photogram it would look something like this

resources :comments
resources :follow_requests, except: [:index, :show, :new, :edit]
resources :likes, only: [:create, :destroy]
resources :photos, except: [:index]

next we can move onto the controller with before_action in private, this action will allow us to add some blockers to specific routes so users can't just add and delete whichever photo they want to.

class PhotosController < ApplicationController
  before_action :set_photo, only: %i[ show edit update destroy ]
  before_action :ensure_current_user_is_owner, only: [:destroy, :update, :edit]
  # ...
end

def ensure_current_user_is_owner
  if current_user != @photo.owner
   redirect_back fallback_location: root_url, alert: "You're not authorized for that."
end

To reiterate:

First we ask what routes we actually want and filter them from the routes.rb with except or only. For the remaining routes, we ask who is allowed to do what on each route.

we use conditionals for keeping edit and delete buttons cause users shouldn’t see the edit or delete links. For instance, we would put a conditional within the photo.html.erb in the app/views/photos/_photo.html.erb.

      <% if current_user == photo.owner %>
        <%= link_to edit_photo_path(photo), class: "btn btn-link btn-sm text-muted" do %>
          <i class="fas fa-edit fa-fw"></i>
        <% end %>

        <%= link_to photo, method: :delete, class: "btn btn-link btn-sm text-muted" do %>
          <i class="fas fa-trash fa-fw"></i>
        <% end %>
      <% end %>

We are checking that the current_user is the photo.owner in the view template, and only rendering the Font Awesome links if they are.

hiding if users are private would require another conditional in the app/views/users/show.html.erb file, this fix to the code would allow us to not see users if they are private, but to see them if we follow them

<% if current_user == @user || !@user.private? || current_user.leaders.include?(@user) %>
  <div class="row mb-2">
    <div class="col-md-6 offset-md-3">
      <%= render "users/profile_nav", user: @user %>
    </div>
  </div>

  <% @user.own_photos.each do |photo| %>
    <div class="row mb-4">
      <div class="col-md-6 offset-md-3">
        <%= render "photos/photo", photo: photo %>
      </div>
    </div>
  <% end %>
<% end %>

@user.private? is going to be true or false. The preceding ! asks “if not”, flipping the true or false. In other words saying, “if the user is not private then render the page”.

now we have to make it so users are only able to comment on photos in our app if they are following the user or the user is public, so in the actions of the app/controllers/comments_controller.rb. we may have hid the route and/or content, but we also want to bounce them from actions they aren't allowed in.

class CommentsController < ApplicationController
  before_action :set_comment, only: %i[ show edit update destroy ]
  before_action :is_an_authorized_user, only: [:destroy, :create]
  # ...
    def is_an_authorized_user
      if current_user == @comment.owner || !@comment.owner.private? || current_user.leaders.include?(@comment.owner)
        redirect_back fallback_location: root_url, alert: "Not authorized"
      end
    end
  # ...
end

That copy-paste of the conditional won’t work, because we don’t have @user here, we have @comment. We need to get from @comment to the owner of it, turns out we’ll need to add another association accessor first. so, we need to go into the comment model, and make sure we are getting the user of the photo through owner.

class Comment < ApplicationRecord
  belongs_to :author, class_name: "User", counter_cache: true
  belongs_to :photo, counter_cache: true
  has_one :owner, through: :photo

  validates :body, presence: true
end

We could test that, but we would unfortunately end up getting a nil returned for @comment when we try to create or destroy. Why? Because the before_action :set_comment is not being run before our new is_authorized_user method (the new method is not in the only list for :set_comment). Actually if we tried debugging this, we would realize a flaw in our logib up until this point, we dont want to be looking at the owner of the comment, we want to be looking at the owner of the photo of which we are commenting on, so we instead would be changing our code from before, to this

class CommentsController < ApplicationController
  before_action :set_comment, only: %i[ show edit update destroy ]
  before_action :is_an_authorized_user, only: [:destroy, :create]
  # ...
    def is_an_authorized_user
      @photo = Photo.find(params.fetch(:comment).fetch(:photo_id))
      if current_user != @photo.owner && @photo.owner.private? && !current_user.leaders.include?(@photo.owner)
        redirect_back fallback_location: root_url, alert: "Not authorized"
      end
    end
  # ...
end

first, we will be needing to get the current photo from the params hash (from comment[photo_id]), then we need to change the logic in our conditional (switching the location of the ! “if not” modifiers, and changing || to &&) to get what we want: Users can only comment of public photos, or photos of their leaders.

Photogram Industrial Notes

Mary Webby — Fri, 08 Mar 2024 21:21:34 +0000

notes about scaffolds for CRUD & generating a model

The question you have to answer now is: for each of these tables, do you want to generate a scaffold or do you just want to generate a model? How do we figure that out?

If I will need routes and controller/actions for users to be able to CRUD records in the table, then I probably want to generate scaffold. (At least some of the generated routes/actions/views will go unused. I need to remember to go back and at least disable the routes, and eventually delete the entire RCAVs, at some point; or I risk introducing security holes.)

If the model will only be used on the backend, e.g. by other models, then I probably want to generate model. For example, a Month model where I will create all twelve records once in db/seeds.rb does not require routes, MonthsController, app/views/months/, etc.

foreign keys in migrates & models

any times you are specifying the forgein_key within a migrate file, you need to also make sure to go and change it in the model as well. so here is our migrate file

class CreateComments < ActiveRecord::Migration[7.0]
  def change
    create_table :comments do |t|
      t.references :author, null: false, foreign_key: { to_table: :users }
      t.references :photo, null: false, foreign_key: true
      t.text :body

      t.timestamps
    end
  end
end

and we are specifically looking at the foreign_key: { to_table: :users } part of this. and you can see we specified that the users table is going to be what the author is referring to.
so now in our models, we can go into comment.rb, and in here we can add in the specific classname for the author

class Comment < ApplicationRecord
  belongs_to :author, class_name: "User"
  belongs_to :photo
end

Raghu: "So basically for every foreign_key, there should be a belongs_to. For every belongs_to, there should be a has_many."<

rails db:drop will delete your entire database, rails db:rollback will undo your last migration<

will need to keep all the migration files to see all the history of changes and

Helper Methods

Mary Webby — Fri, 01 Mar 2024 16:12:35 +0000

➜ Cleaning up `config/routes.rb`

post("/movies", { :controller => "movies", :action => "create" })

anywhere you see the old Hash syntax (:symbol keys with hash rockets =>): switch to the new Hash syntax. Which would be controller: "movies", action: "create"
next, it is always good to see how many methods are happening on this line, Raghu's convention is that is there no other methods happening, you can leave out the parentheses. so our output would look something like this get "/movies", controller: "movies", action: "create".
we can even go further to just take out the controller and action since it is the only method we are placing into the route. remember, the # symbol is used to indicate an Object#method, which, in this example, is MoviesController#create. which would finally leave us with something like this

get "/movies" => "movies#create"

for special circumstances like when you are wanting to display the root page of the website, rails has special syntax that allows you to omit the route being displayed, so instead of # get("/", { :controller => "movies", :action => "index" }), you would write it as this root "movies#index".

➜ Route helper methods

at the bash prompt, run rails routes. the display should look like something similar to this

Prefix Verb   URI Pattern                                Controller#Action
            GET    /                                         movies#index
    movies POST   /movies(.:format)                          movies#create
movies_new GET    /movies/new(.:format)                      movies#new
            GET    /movies(.:format)                         movies#index
            GET    /movies/:id(.:format)                     movies#show
            PATCH  /movies/:id(.:format)                     movies#update
            GET    /movies/:id/edit(.:format)                movies#edit
            DELETE /movies/:id(.:format)                     movies#destroy

Prefix means that Rails has defined a method that we can call anywhere in our view templates, controller actions, etc., that will return the path as a string.
to test out what exactly this code is doing, move over to the index.html.erb page, type in <%= movies_path %>, and see what the page renders. you can see that it is displaying the string "/movies". if we were to try others, we can see that <%= movies_new_path %> refresh the change, and /movies renders "/movies/new". Following this pattern, <%= root_path %> just renders "/".
movies and movies_new are static routes, without dynamic ID numbers in the path, so Rails just puts the segments together and gives you the method. But, for all the rest of the routes that do contain :id, there are no methods defined yet. We get to define those methods ourselves!

➜ Creating our own route helper methods

get "/movies/:id" => "movies#show", get "/movies/:id" => "movies#show", as: :details

say for the one above, "/movies/:id" has :id within the route, so we have to properly define it after the route, just like we are doing above, the as: :details part of the route is us defining a specific method, we can then transition back into the index.html.erb file and define our route like so <%= details_path %>.
if we see what this provides us with it will be an error No route matches {:action=>"show", :controller=>"movies"}, missing required keys: {:id}. this is because it is a dynamic route, so rails cant produce a route unless you tell it what to put in the path!
say if we were to put (42) within this ruby syntax helper method, it would be able to display the route with the :id being (42).
you can also change the embedded ruby method to details_url(42), then you will be able to see the full url of the app, including the path, this allows you to see fully qualified url's. this means you dont need to hardcode anything because it will be able to full run on any persons own personal web browser.
now we are going to be placing them into the normal conventions that every ruby developers use. such as

get "/movies/new" => "movies#new", as: :new_movie
get "/movies/:id/edit" => "movies#edit", as: :edit_movie

we however dont need to define the helper methods for delete or patch

patch "/movies/:id" => "movies#update"
delete "/movies/:id" => "movies#destroy"

➜ implementing helper methods

Now we are going to be taking those helper methods and placing them into the rest of our code, so these are going to work the same way as routes, where instead of having the routes path and then placing the variable into it with ruby <%= a_movie.id %> like this, we will change it to something like below...

<form action="<%= movie_path(@the_movie.id) %>" method="post" data-turbo="false">
  <input name="authenticity_token" value="<%= form_authenticity_token %>" type="hidden">

another point, since we are taking the specific movie id for the route, we can use ruby convention and just always assume that that is what it will naturally grab specifically unless we say otherwise action="<%= movie_path(@the_movie) %>"
say we are implementing them into our controllers for redirection, for this piece of code for example...

if @the_movie.valid?
      @the_movie.save
      redirect_to("/movies", { :notice => "Movie created successfully." })
    else
      render template: "movies/new"
    end

we can instead change "/movies" to movies_url, since we want to specifically route them to a url and not use the path name /movies

➜ Creating forms with helper methods

<%= form_with(url: movies_path) do %>
  <div>
    <!--    <label for="title_box">
      Title
    </label>-->
    <%= label_tag :title_box, "Title" %>
    <!--<input type="text" id="title_box" name="query_title" value="<%#= @the_movie.title %>">-->
    <%= text_field_tag :query_title, @the_movie.title, { id: "title_box" } %>
  </div>

  <div>
    <!--<label for="description_box">
      Description
    </label>-->
    <%= label_tag :description_box, "Description" %>
<!--    <textarea id="description_box" name="query_description" rows="3"><%#= @the_movie.description %></textarea>\ -->
    <%= text_area_tag :query_description, @the_movie.description, id: "description_box", rows: 3 %>
  </div>    

 <!-- <button>
    Create Movie
  </button>-->
    <%= button_tag "Button"%>
<% end %>

here you can see the before and after of placing in tags to our forms, and below is a much more organized way to look at it

<%= form_with(url: movies_path) do %>
  <div>
    <%= label_tag :title_box, "Title" %>
    <%= text_field_tag :query_title, @the_movie.title, { id: "title_box" } %>
  </div>

  <div>
    <%= label_tag :description_box, "Description" %>
    <%= text_area_tag :query_description, @the_movie.description, id: "description_box", rows: 3 %>
  </div>    

    <%= button_tag "Button"%>
<% end %>

➜ `find_by` method

what we have been practicing before has led us to this moment where we will be totally deducing our 3 steps to get an ActiveRecord instance (a single row of a table, compared to an ActiveRecord:Relation (which is many rows of a table.
in the beginning of learning ruby, we had something very similar to this setup in our code...

def show
    the_id = params.fetch(:id) # FIRST we get the ID

    matching_movies = Movie.where(id: the_id) # THEN we get the set of matching rows (ActiveRecord:Relation)

    @the_movie = matching_movies.first # FINALLY we get one instance of ActiveRecord, or one row
  end

now we are presented with something very similar to this, essentially reducing whatever we started with to a more simplified version, such as this...

def show
    @the_movie = Movie.where(id: params.fetch(:id)).first
  end

now, finally we are going to be stripping that even more to a better more conventional version of this piece of code, something using the .find_by method. it is essentially the same thing as where, except that is automatically returns the .first record given in a collection without having to explicitly say that.

  def show
    @the_movie = Movie.find_by(id: params.fetch(:id)) 
  end

or shorter

def show
    @the_movie = Movie.find(params.fetch(:id))
  end

important to note here that the .find() method only takes an integer argument and is specifically for finding ID's in the ID column table

now we can accurately and effectively search for what we need without using lines and lines of code as we were doing before.

➜ Creating a checkbox form

getting an array with checkbox

<form>
  <label>Red</label>
   <input type="checkbox" name="zebra[]" value="red"> 

  <label>Blue</label>
  <input type="checkbox" name="zebra[]" value="blue"> 
</form>

output looks something like this

zebra["red", "blue"]

getting an array with hashes with checkbox

<form>
  <label>Red</label>
   <input type="checkbox" name="zebra[giraffe]" value="red"> 

  <label>Blue</label>
  <input type="checkbox" name="zebra[elephant]" value="blue"> 
</form>

output looks something like this

zebra["giraffe" => "red", "elephant" => "blue"]

➜ Mass assignment with forms

<%= form_with(model: @movie, data: { turbo: false }) do |form| %>
  <div>
    <%= form.label :title %>

    <%= form.text_field :title %>
  </div>

  <div>
    <%= form.label :description %>

    <%= form.text_area :description, { rows: 3 } %>
  </div>

  <%= form.button %>
<% end %>

➜ Adding method

This movie_params is a good tool to understand and takes away the need to write in a new table over and over again when making it cause you would just add it in one place and then it could be added everywhere.

def movie_params
    params.require(:movie).permit(:title, :description, :image_url, :director_id)
  end

➜ partial view templates

You can only add a partial to a big, not a big to a big or a big to a partial. this helps up organize our code into more folders and shorter lines so we are not overwhelmed by how many lines could be for each page.

<%= render "shared/flash_messages", locals: { person: "Alice" }%>

could be good for explaining name for each user in the top corner
in the file youre displaying

<%= render partial: "movies/form", locals: { foo: @the_movie} %>

in the partial

<% foo.errors.full_messages.each do |message| %>
  <p style="color: red;"><%= message %></p>
<% end %>

Bulletin Board User Auth

Mary Webby — Wed, 21 Feb 2024 15:44:17 +0000

setting up the rails generate devise:install

rails generate devise:install

paste into terminal after running rake sample_data, and bin/dev. this will generate the following

Depending on your application's configuration some manual setup may be required:

  1. Ensure you have defined default url options in your environments files. Here
     is an example of default_url_options appropriate for a development environment
     in config/environments/development.rb:

       config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

     In production, :host should be set to the actual host of your application.

     * Required for all applications. *

  2. Ensure you have defined root_url to *something* in your config/routes.rb.
     For example:

       root to: "home#index"

     * Not required for API-only Applications *

  3. Ensure you have flash messages in app/views/layouts/application.html.erb.
     For example:

       <p class="notice"><%= notice %></p>
       <p class="alert"><%= alert %></p>

     * Not required for API-only Applications *

  4. You can copy Devise views (for customization) to your app by running:

       rails g devise:views

     * Not required *

We complete sets 1 through 3 for this project, but you are also allowed to complete step 4, we did not go into that.

why are we doing this

Before, we were creating our databases with our models and columns in psql, which is good for initially setting up our db, but say we want to add things further down the line with other columns we need to add. Here, we are using db migrate and creating migration files to be able to add more to our db.
So initially, we need to create the migration file, which we can do by running rails generate migration AddUserIdToBoards user_id:integer for example. This will create the migration file for us to use, which we can then run rake db:migrate to then allow our database to officially implement those changes.
if we were to accidentally run rake db:migrate, we would run into the issue of having the database already initialized, and would have to start over again, which is what i was stating previously in the section above.

Bulletin Board 1

Mary Webby — Tue, 20 Feb 2024 17:12:36 +0000

setting up db with rails console

rails generate draft:resource <MODEL_NAME_SINGULAR> <COLUMN_1_NAME>:<COLUMN_1_DATATYPE> <COLUMN_2_NAME>:<COLUMN_2_DATATYPE> # etc

to generate a complete, database-backed web resource, use the code snippet above. It is actually exactly the same as creating and generating a model and a table, but instead model is replaced with draft:resource. below is an example of using this.

rails generate draft:resource post title:string body:text expires_on:date board_id:integer

or...in our assignment here...

rails generate draft:resource board name:string

this action that we just did has essentially installed all of our standard CRUD action boilerplate for us (navigate to /posts. if you would like to delete the action you just made, you can also rails destroy draft:resource, rake db:rollback, rails destroy draft:resource post or go back to the last git commit. you can then correct your error and then regenerate.

adding and removing columns

To modify existing tables, the most common tools we use are add_column and remove_column.
generate a new migration (not a whole model like above) at a bash prompt with, for example, use rails g migration AddImageToPosts, or rails g migration RemoveExpiresOnFromPosts
then, go into the new migration file and add instructions to make the change you want within the change method (or the up method, if that’s what you find inside instead of change)

def change
  add_column :posts, :image, :string
end

with ultimate last resort, use rake db:drop

other notes

rspec rails framework

bundle exec rspecor rspec to run rails debugging with ruby gem inside the GemFile

Refactoring MSM GUI 2

Mary Webby — Mon, 19 Feb 2024 19:35:41 +0000

Creating a standard instance method

Standard practice for getting a specific piece of information from each database

class Character < ApplicationRecord

  def movie
    key = self.movie_id

    matching_set = Movie.where({ :id => key })

    the_one = matching_set.at(0)

    return the_one
  end

end

meta methods

`belongs_to`

belongs_to( :name_that_we_want, :class_name => "", :foreign_key => "" )

so for example, if you wanted to change the code above, you would turn the prompt given above into this

belongs_to( :movie, :class_name => "Movie", :foreign_key => "movie_id"  )

since you are typically name all of these the same convention, you can even go further and take out the classname.

belongs_to(:movie, :foreign_key => "movie_id" )

they decided to write this method if you omit the class name, they're going to guess that the class name matches the method name that you select, which is the case 99% of the time.

belongs_to(:movie)

`has_many`

has_many( :name_that_we_want, :class_name => "", :foreign_key => "" )

producing a lot from this specific method so we want to use it for when we would we would be getting information back that comes in many, say characters, or comments, or movies. stuff like that.

belongs_to( :name_that_we_want )

can also deduce it the same way like before if the class name matches the method name, then rails will assume that that is the name that you are going to use unless stated otherwise.

example on how to use in rails console

type these into rials console to understand where we can add on methods to meta methods.

Character.joins(:movie).where("movies.year > 1994")

Photogram GUI (graphical user interface)

Mary Webby — Mon, 19 Feb 2024 16:34:47 +0000

Difference in `redirect_to` in contrast to `render`

render() is only very beneficial in terms of when you are using it to display one piece of information per page. this means that everything in your action of your controller is really all the information that you need for the page.
in contrast to redirect_to(), this specific type of page rendering allows you to sort of push all the information you acquired in within your action and allow it to be placed into another page, with other info from other actions. This helps in very dynamic and info packed pages where you want multiple different sections doing different things but don't want it to all be in one controller. for example, when you are editing and adding new photos to a users page, but also want to display and post comments on the photos. You would have those 3 different actions, all redirecting to the same page.

Understanding what `.where` returns

when searching for a specific user within an action, you need to search within all the Users model, and then pick that id.

def show
    username = params.fetch("username")
    matching_users = User.where({ :username => username })
    @user = matching_users.at(0)

    render({ :template => "user_templates/user_details"})
  end

the specific line to note here is @user = matching_users.at(0)this is because we are returned a hash, and need to select the first position of for the specific user we want.

Data Integrity w/ Validations

Mary Webby — Wed, 14 Feb 2024 17:25:13 +0000

Invalid Records History

Reminder: to run the rails console, you need to run either rails c or rails console in the terminal to prompt, even though it is pry you cannot just run pry in the terminal to get it started, you will need to run the other one to make sure that all you models and tables are being queried correctly.

As soon as you start serving data from external sources (ex. users, CSVs, or APIs) you have to start worrying about whether that data is valid
If you do encounter invalid records and they become apart of your database, you will have to begin writing your code defensively, utilizing if/elsif/else/end, just to guard against the invalid data.
It’s best not to allow invalid data that doesn’t meet our criteria to enter our database in the first place; then, we don’t need to worry about writing lots of defensive conditionals downstream in our code
ActiveRecord provides the feature: validations
Validations are a way that we can specify constraints on what we allow in each column in a model. It is crucial that we have the .save method, this will allow us not to place records into the database we don't want to. Thus, returning to us false
Validations are a super-useful tool that ActiveRecord provides for maintaining the integrity of our data.

How to Insert Validations in Models

question to address
let’s say we don’t want to allow any rows to enter our movies table with a blank director_id attribute.

how to fix & add validations
to address this problem we want to move into the Movie model insert a Validation inside of it.

class Movie < ApplicationRecord
  validates(:director_id, presence: true)

  def director
  # ...
end

The first argument to validates is a Symbol; the name of the column we are declaring constraints for.
The second argument to validates is a Hash.
The keys in the Hash are the constraints we are applying. There is a fixed list of constraints built-in to ActiveRecord that we can choose from. By far, the three most common are :presence, :uniqueness, and :numericality.
the value that we are adding to either true, which would allow you wanting the simplest use of validation. On the other hand, you can also have a hash in there clarifying the configuration options, like whether you want want the :numerically validation to have maximum or minimum

Testing our New Validations with Tests

type these commands inot the rails console termnial
m = Movie.new creating a new instance of a movie
the return value should look something like this

[1] pry(main)> m = Movie.new
   (0.4ms)  SELECT sqlite_version(*)
=> #<Movie:0x00007f93ab387430
 id: nil,
 title: nil,
 year: nil,
 duration: nil,
 description: nil,
 image: nil,
 director_id: nil,
 created_at: nil,
 updated_at: nil>

next, we will type m.save, which if done correctly should return a false
we can double check that its not in there by typing m into the console again to see that there was no created_at: or updated_at: values inserted so we know that it was never created.

The Errors Collection
we can even find out why the object didn’t save. each ActiveRecord object has an attribute called errors, which contains an instance of ActiveModel::Errors — a collection of validation failures
we can then type m.errors into our terminal and ActiveModel::Errors will prompt an output like this

[4] pry(main)> m.errors
=> #<ActiveModel::Errors [#<ActiveModel::Error attribute=director_id, type=blank, options={}>]>

next we can try to get the message

[5] pry(main)> m.errors.messages
=> {:director_id=>["can't be blank"]}

there is also a very helpful method we can place onto the error which will return a list of arrays of detailed messages on how to fix our issue on why it is not saving.

[6] pry(main)> m.errors.full_messages
=> ["Director can't be blank"]

later on down the road we can actually take those error messages, say in like logging in to an account or making a password and actually provide the user the string from the error to realize their mistakes and fix the issue. this is a good alternative than creating a for loop and making it so you have a ton of code. you can really be utilizing the ActiveRecord::Errors to make it so you are personally doing less code and using more resources.

Helpful Methods for Validations

validates(:something_id, presence: true) checks to see if a a specific "something" in a table has the presents of the thing it needs before saving to the table
validates(:something, uniqueness: true) checks to see if no other rows have the same value in that column, very helpful for usernames and stuff where each value has to be unique to the specific id so there is no confusion.

Instance Method Review

Mary Webby — Tue, 13 Feb 2024 21:58:42 +0000

Composing methods to build more powerful methods

In ruby, we use the def keyword within the class definition to add new methods to a class

class Person
  def say_hi
    return "Hello!"
  end
end

the say_hi comes immediately after the def keyword, Ruby knows we are defining an instance-level method.
Every method’s main job is returning a value
Our programs are essentially just a long sequence of methods being called on the return values of previous methods, until we arrive at our desired output.

The self keyword

class Person
  attr_accessor(:first_name)
  attr_accessor(:last_name)

  def full_name
    assembled_name = self.first_name + " " + self.last_name

    return assembled_name
  end

  def full_name_caps
    return self.full_name.upcase
  end
end

rb = Person.new
rb.first_name = "Raghu"
rb.last_name = "Betina"

pp rb.full_name_caps

self as a special variable that holds whatever object is at the forefront of Ruby’s mind when it is evaluating a program. Whatever line of code it is reading, whatever object is it working on at the moment, that is what self contains.
self represents the instance of the class that the method will be called upon in the future, formally, this object is known as the receiver of the message that is the method invocation.

Defining "association accessors"

Whenever you see Director#filmography, that is the Director class, and there is a filmography instance method within it.

Social Media Set up Tables

Mary Webby — Tue, 13 Feb 2024 16:51:34 +0000

1.users
-id
-email
-password
-username
-name
-website_url
-avatar_image_url
-bio
-private
-liked_count

2.follow_requests
-id
-created_at
-updated_at
-sender_id (users)
-recipient_id (users)
-status (accepted, rejected, pending)

3.posts/photo
-id
-created_at
-updated_at
-user_id
-image_url
-caption
-like_count(automatically incs or decs with CRUD)

4.likes-join table (the like to the user)

-id
-post_id
-user_id

5.comments - join table (the comment to the user)
-id
-created_at
-updated_at
-description
-post_id
-user_id

Ruby Database Setup & Common Commands & CRUD

Mary Webby — Thu, 08 Feb 2024 18:12:17 +0000

Using PSQL in the rails database. Explaining set up and then going into common methods for accessing data within the database.

Note ➔ When editing and creating files within your app and outside of your terminal sql editor, you will need to start and restart the rails console to make sure the changes are incorporated.

➔ Commands to start your db for rails

First, check out my other article on using SQL to create a table and the first object inside.

Notes on Databases and SQL Commands for Reference

Mary Webby ・ Feb 7
Next, you will need to change your config/database.yml file to add your database you created. For example, database: my_contact_book.
Next you will be adding your class file to the models folder, so for example, app/models/class.rb. In this folder will be, the base set up whats below. < ActiveRecord::Base allows Class to inherit all properties and methods in ActiveRecord. class Class < ActiveRecord::Base\nextLineend
You are also able to self.table_name = "contacts" and more properties to your class to manually enter here, instead of the command line.
You will now need to open the terminal and type in irb, which will prompt the "interactive ruby", which is a tool to interactively execute Ruby expressions read from the standard input.
Then you will require "./app/models/class" to ensure you have the file you need.
Exit irb by executing exit, and type rails c or rails console, which will open the respective ruby PSQL.

➔ Methods to act on your class within the `rails console`.

ActiveRecord Relations are very similar to Arrays. Any method that you can call on an Array, you can also call on a Relation; .at, .each, .sample, etc.

Class.count returns an integer
Contact.all returns all the records in a table
x.at(0) x being and example for what to replace, and at(0) being where you are looking in the indexes.
c = Contact.all.sample taking out a random contact and storing it in the variable c.
c.id, c.created_at, c.first_name, c.phone, now we can call on that specific variable we created and access its contents.
Contact.all.order({ :last_name => :asc, :first_name => :asc, :date_of_birth => :desc }) retrieve info and sorting it in a specific way.
Contact.order(:first_name).reverse_order same thing with this one.
Contact.where({ :last_name => ["Betina", "Woods"] }) giving specific to try and find a name.
Contact.where({ :first_name => "Mickey" }).or(Contact.where({ :last_name => "Betina" })) Similar ask to before but instead you are broadening the search.

➔ CREATE READ UPDATE & DELETE

UPDATE

To update a row, first you need to locate it:

c = Contact.where({ :id => 2 }).first

And then assign whatever new values you want to:

c.first_name = "Minerva"

And then don’t forget to save the changes:

c.save

DELETE

To delete a row, first find it:

c = Contact.where({ :id => 2 }).first

And then,

c.destroy

Intense.

➔ Creating tasks to populate helpful sample data

Navigate to lib/tasks, and create file to create your task, such as lib/tasks/i_am_lazy.rake
Place your task into the file,
or any task you want to create. This one is creating a new contact for a contact book.
In our terminal we will call rake sample_contacts and if you look at your database it should be populated!

Notes on Databases and SQL Commands for Reference

Mary Webby — Wed, 07 Feb 2024 22:08:40 +0000

Databases are a great tool to outsource the work of making a ruby file, CSV, or PStore
Databases are seperate from apps themselves, so any language apps can use any databases (MySQL, PostgreSQL, SQLite, etc.)
The interface to databases is text
- Dont usually come with a GUI (graphical user interface) Regional databses (which powers most apps) use a special language called SQL (stuctural query language)

Working directly with Postgres

Great one to use cause it is already installed on codespaces in github.
Commands to set up a table
- psql
  - If this command went well, we should see postgres=#
- \list
  - displays all current databases on this computer
- CREATE DATABASE my-db
  - the name of the database should be snake_case
- \connet my-db
  - to enter databases
- \dt
  - lists all the tables in the db, this means “describe tables”. the realtion comes from the term “relational databases” a ‘relation’ is a set of multiple records. not related to “relationships”, in the context of one to many, or many to many, or one to one
- CREATE TABLE contacts (
  - id SERIAL PRIMARY KEY,
  - first_name TEXT,
  - last_name TEXT,
  - date_of_birth DATE )
  - standard creation of a contact for use
SELECT first_name, last_name FROM contacts
- use * instead to see all
INSERT INTO contacts(all the values above)VALUES ('mary', 'webby', '1999, 29, 12')
- place single quotes around each intserted value.

Forem: Mary Webby

Photogram Authorization

Photogram Industrial Notes

notes about scaffolds for CRUD & generating a model

foreign keys in migrates & models

Helper Methods

➜ Cleaning up config/routes.rb

➜ Route helper methods

➜ Creating our own route helper methods

➜ implementing helper methods

➜ Creating forms with helper methods

➜ find_by method

➜ Creating a checkbox form

getting an array with checkbox

getting an array with hashes with checkbox

➜ Mass assignment with forms

➜ Adding method

➜ partial view templates

Bulletin Board User Auth

setting up the rails generate devise:install

why are we doing this

Bulletin Board 1

setting up db with rails console

adding and removing columns

other notes

Refactoring MSM GUI 2

Creating a standard instance method

meta methods

belongs_to

has_many

example on how to use in rails console

Photogram GUI (graphical user interface)

Difference in redirect_to in contrast to render

Understanding what .where returns

Data Integrity w/ Validations

Invalid Records History

How to Insert Validations in Models

Testing our New Validations with Tests

The Errors Collection

Helpful Methods for Validations

Instance Method Review

Composing methods to build more powerful methods

The self keyword

Defining "association accessors"

Social Media Set up Tables

Ruby Database Setup & Common Commands & CRUD

➔ Commands to start your db for rails

Notes on Databases and SQL Commands for Reference

Mary Webby ・ Feb 7

➔ Methods to act on your class within the rails console.

➔ CREATE READ UPDATE & DELETE

UPDATE

DELETE

➔ Creating tasks to populate helpful sample data

Notes on Databases and SQL Commands for Reference

➜ Cleaning up `config/routes.rb`

➜ `find_by` method

`belongs_to`

`has_many`

Difference in `redirect_to` in contrast to `render`

Understanding what `.where` returns

➔ Methods to act on your class within the `rails console`.