Rails RESTful controller action to create User - ruby-on-rails

Question

I am re-reading railstutorial the second time for clarity. I was trying to understand RESTful resources provided by rails where it listed various HTTP request with corresponding controller actions: index, show, new, create, edit, update, destroy.
I never really fully understood how rails controller works and I wanted to clarify it. If I make a users_controller.rb and want to create new user, and that's it. I don't care about redirecting, flash messages, and other flairs. I just want to create new user and save it on my database.
I want to do User.create(name: "Iggy1", email: "letsmail#iggy.com"). Assume I did migration and I have name (string) and email (string) on DB schema.
What is the least code line on users_controller.rb needed to create a user?
The reason why I ask this question is up til now, I am still not 100% sure which code line actually performs the desired action. Is rails actually smart enough to recognize these specific keywords index, new, create, destroy, show, edit, and update, or are they arbitrary? If rails is smart enough to detect those seven keywords, by merely listing the method (def destroy; #<no code>; end), is DELETE user method automatically accessible, or I have to actually say def destroy; User.find(params[:id]).destroy; end to use DELETE user method? On users_controller.rb, I have, from railstutorial, in the end, this elaborate code.
...
def create
#user = User.new(user_params)
if #user.save
#user.send_activation_email
flash[:info] = "Please check your email to activate your account."
redirect_to root_url
else
render 'new'
end
end
...
Is merely having def create on Users_controller sufficient for rails to create a user?
def create
end
Or I need at least to have User.new, or more codes to create new user?

Answer 1

The first thing you'll need to create a user is a 'new' action in your UsersController, like the following:
class UsersController < ApplicationController
def new
#user = User.new
end
end
When you declare the above method definition, Rails will expect a file named 'new.html.erb', unless you tell it to render another template.
NOTE: I'll continue under the assumption that you don't want to do this, but if you did, you would add render 'other' to the end of your 'new' method (where 'other' is the file 'other.html.erb'):
Since your goal is to create a new User instance, this view template will need a form to add the name and email fields. While not required for all Rails forms, one common way of creating a User is to create a 'new' (i.e. unsaved) User instance and pass it to the form, so that the form knows which attributes a User has. Rails passes this instance variable to the view, and it also knows which view file to render (because the 'new' method you defined should be named the same thing as the 'new.html.erb' view template that contains the form). This is also how Rails knows that the 'submit' button of the form should read 'Create user'.
Assuming you have the above, the next step is adding a place for the form data to be sent once you click the form's "Submit" button. This is what the 'create' action does. In other words, the 'new' action is in charge of displaying the form in your browser, and the 'create' action is in charge of handling the data submitted by that form. The bare minimum code you'll need to add at this point is the following:
def create
#user = User.create(user_params)
end
The way Rails does this is through a special method it implements, called 'params'. Behind the scenes, Rails takes the HTTP request that occurs when you submit the form, and stores certain data in an ActionController::Parameters object. This data is then processed by the 'user_params' method (which you'll need to declare; see below), and only the paramaters which you whitelist in that method definition (i.e. 'name' and 'email') are returned.
This implies that you'll need to implement that 'user_params' method definition. This is typically done as a private method at the bottom of your UsersController, since you don't want this method available outside of the controller. So you'd add the following:
private
def user_params
params.require(:user).permit(:name, :email)
end
This is important from a security standpoint because a malicious user could potentially add new form elements in their browser (for instance, an element named 'admin') and click 'submit'. If your User model does indeed include an 'admin' attribute, that malicious user has just created an Admin user (with corresponding Admin privileges).
Finally, since the request that the form sends is a POST request (not a get request), Rails expects you to provide a view to send the user to after they submit the form. This view is typically the 'show.html.erb' template for the user you've just created, since the 'create' doesn't have a template of its own (remember, the form we've discussed is the view for the 'edit' action, not the 'create' action). The 'show' view is rendered by the following method:
def show
end
In addition, you'll need to tell Rails to redirect to the 'show' page after the 'create' action is finished. Add this to the end of your 'create' method:
redirect_to #user
Since you passed a single instance of the User class, Rails infers that you want to redirect to the 'show' action (as opposed to 'index' or some other action) of the User controller. Depending on what you pass to the "redirect_to" method, you can send your user to any number of destinations. See these docs for more info.
So in summary, besides the 'edit.html.erb' and 'show.html.erb' view templates and the route declaration in your 'config/routes.rb' file (which I haven't discussed in detail, since the question scope is limited to the UsersController), the bare minimum amount of code your UsersController should have is the following:
class UsersController < ApplicationController
def new
#user = User.new
end
def create
#user = User.create(user_params)
redirect_to #user
end
def show
end
private
def user_params
params.require(:user).permit(:name, :email)
end
end

Answer 2

You have to understand rails is built on MVC and REST. MVC is an architectural pattern to distribute responsibility of your project.
M - Model, which interacts with the database and the ideal place to implement business logic.
V - View, where the HTML rendering happens
C - Controller, basically bridges the communication between M and V.
So, basically when the end user accesses your domain the request comes to the webserver and then, to the rails API. The rails API would know the default controller to transfer the request and the default controller action would return the html output.
Default router in config/routes.rb
root to: 'controller#action'
Likewise rails understands the 5 HTML methods which are GET, POST, PUT, DELETE and PATCH. So, once you create a controller and set the reference in routes.rb as resources [controller_name] then, the rails routes would create 8 urls for each of the 8 default actions in your controller. For an example let's say your controller is users_controller.rb then, you set it in routes.rb as resources :users this would allow the following methods,
users GET /users(.:format) users#index
POST /users(.:format) users#create
new_user GET /users/new(.:format) users#new
edit_user GET /users/:id/edit(.:format) users#edit
user GET /users/:id(.:format) users#show
PATCH /users/:id(.:format) users#update
PUT /users/:id(.:format) users#update
DELETE /users/:id(.:format) users#destroy
So, when you build your view and set the form_for url as users_path and set the http method as POST the submission of the form would trigger the create action. So, in the create action you should write all the code that is needed to trigger the model to save your record.
Also, go through this document as well,
http://guides.rubyonrails.org/routing.html