REST API with Ruby on Rails: The Complete Guide

Get familiar with the concept of postman application and why it's so useful for API developers.

In this video we'll go through the main interface and will create a first request to get a data of article's collection. It's a first real communication with the application serwer we'll write later in the course.

In this video we'll learn how to create resources using Postman requests and we'll do it by creating the most important one: a user's registration!

Learn one of the most useful tricks for API developers that can give you a huge productivity boost in all of your projects - an automatic documentation from Postman.

In this lesson we're going into more advanced stuff possible with Postman application. In the video I present how to use the access token to authorize requests against our API so it's possible to create and update articles or add article's comments.

Postman allows your productivity to be boosted like crazy and in this lesson we'll cover a first tip how to achieve that. I'll show you how to use environment variables and dynamic content in your requests definition. After that You'll be able to switch between production and development environments with no time!

Summary of what we learned and a presentation of the complete course endpoints collection and API documentation for application we'll build.

In this document you'll find all information you need make most of the Postman Application, together with the whole documentation for this course's API.

This lesson is a short introduction for API in general and what is our goal in the next few lessons. After you go through it You'll be more familiar with the API concept and possible types of communication between client and server. You also will understand better all future coding lessons, so I strongly encourage you to check it out.

In this lesson you'll learn how to implement rounting to your list of articles by adding routes, creating controllers and using CRUD actions to pass the routing test (which you are also going to learn how to make during this lecture).

Here is the explanation for an error from the previous lesson. When you finish this part you'll understand the routing much better. Also you'll acquire knowledge how to render json responses in the browser.

In this lesson you'll learn how to receive an empty array using TDD. You'll also see here practical examples of the server requests.

API already returns expected data, but there are returned in the wrong format. Here we'll cover how to make the controller listing articles in a an expected format and which gems could help us with that.

Technology sometimes change faster than it's possible to record videos! In this article I share a reference to a tutorial how to switch from ActiveModelSerializers gem into the newer and faster one!

In this lesson you are going to learn how to make the code much shorter, cleaner and overall nicer. We refactor the code to save a lot of time later.

In this episode you'll learn how to make articles being listed in a correct order automatically (from newest to oldest) to simulate the news feed.

After completing this lecture you’ll know how to implement an important performance feature for our API - pagination.

Here you’ll learn the basics of Oauth flow concept. It’s going to allow you to make a viable authorization method for your application’s users.

This short lesson is a quick guide about creating the Github Oauth application which'll be necessary for our authorization system.

Here you’ll learn how to integrate the authorization engine with your application using a gem “Octokit”  created by the community. Also there’s a lot of useful information about it, so keep an open mind!

In this episode we'll create a fully functional user object that'll be used in our authentication system, articles and comments later on. 

Here you’ll learn about basics of the final authentication service. We handled here the case when user is not authorized. Here also you'll going to improve your TDD skills a lot.

In this lesson we continue with authorization service by covering successed case. To do it we'll “mock” the gem's methods to behave the way we expected. It's a pretty important, so stay tuned!

Here you’ll learn how to implement a feature responsible for completing user’s logging in and registration by reusing the existing users. The lesson’s title kind of speaks for itself.

In this lesson we prepare the token to finish our authentication system using TDD and allowing frontend to send the authorized requests.

Now it's time to add endpoints for the purpose of managing sessions to finally authenticate our users and implement routing. Note: Routing won't be fully operational yet, so it’s going to need some improvements, which will be covered in the next lesson.

In this lesson we add controller tests for unauthorized requests. Before we handle the success request, it's essentional to take care of all inappropriate requests user can sent to us.

Refactoring time! To keep our management and productivity being the best as possible, we'll take care of moving some of the duplicated code into more manageable snippets, that we can reuse in the future. This lesson'll save a lot of time for us in the future.

After completing this lesson you’ll be able to correctly finish the registration and logging in processes by using TDD and fix some glitches that come with it. Also there’s a handy example of “mocking” the gem included that will help you fully understand it.

In this lesson we'll start implementing a very important feature - logging out. This time, again we start from unauthorized requests, and from this we'll cover the success ones next.

As we introduced the authorization, some of our already written tests started to fail. Here are solutions to errors from the previous lesson that make the code a lot more viable.

This is the last lesson about authorization and authentication. We’ll do the rest of the major work with logging out feature and add finishing touches to our code now. All of that in Test Driven Development of course!

The first part of implementing the endpoint to create new articles. We'll cover here unauthorized requests together with testing them here.

In this lesson you’ll mainly learn how to handle validation errors from your API endpoints. So there won't be any invalid articles saved in our database.

Here we’ll cover the final parts of article creation when everything is authorized and valid. Also, you're going to improve your skills in TDD with other examples.

Name speaks for itself. In this short lesson you're going to see my approach for the exercise I gave you before. I cover here the complete functionality for updating articles in our database. There are some improvements yet to be done which are covered in the next episode.

In this lecture you’ll learn how to prevent users from changing or even deleting other users’ articles to prevent griefing and make our application private.

In this lecture I show you how to make a possibility of destroying (deleting) articles by your users. Of course - users'll be able to delete only their articles and that's because of what we’ve done in our previous lesson.

I strongly suggest you to see this episode AFTER you try to implement this feature on your own.

In this lesson we starts comments system for our application. We choose different approach this time, using rails' built in "scaffold" generators.

In this first part we need to do some cleanup and refactoring to make all automatically generated tests related to listing articles being nice and green. It's quite a lot of work to do, but I'm sure you’ll succeed! 

Here improve the code related to the comment's creation to make all test passing. We clean up a lot, but there're still a lot of things to improve in the next lessons.

In this lesson you are going to learn how to finish implementing comment listing, fix some errors that come with automatic scaffold generators and make it overall nice and clean.

Here are final improvements and fixes for problems in comment creating feature. After finishing this lecture you’ll complete the first version of your application, ready for release, so congratulations for doing so well!