Let’s Build: With Ruby on Rails – Job Board with Payments

Welcome to what I’ll be calling my tenth installment to my Let’s Build: With Ruby on Rails series. In this build, I’ll cover how to build a filterable job board with payments using Stripe as a payment gateway to post new jobs.

More about the app

The basis of the application is a job board where anyone looking to get hired can come and apply for positions. If you are a user or company looking to post a job you can sign up for an account and do so for a fee. We use a combination of the Stripe API and the Stripe Ruby Gem to initialize a charge when a job gets posted.

If there are errors along the way the form will offer error feedback for both the Rails-based form and the Stripe based form.

Download the source code

Stripe Integration

Stripe has a variety of solutions when it comes to accepting payments securely. There’s really no wrong way to do so but some applications may favor alternative approaches. In our case, I opted for Stripe Elements which is a drop in replacement that allows you to display a form for the credit card of which you can manipulate at will.

Styling it or triggering something to happen upon user input is completely up to you. If you’d rather bypass all of that customization you can always integrate the originally Stripe.js library and or use Stripe Checkout which is as simple as dropping in a form with key-value pairs inside your application.

Kicking off the build

In previous builds I started from scratch by installing and configuring gems as we needed them. In order to save some time, I decided to create a Rails application template. This approach is super useful if you find yourself reaching for the same files, gems, and other various features a Rails app has over and over. In my exact case, I tend to use gems such as Devise, Guard, Bulma, SimpleForm, and more to create the same type of app for these screencasts.

With all of this said I decided to share my template of which I called Kickoff. In the videos I discuss at greater length how everything here works but to make use of it you can download the repo and cd into it.

From that point, you can create a new Rails app by running rails new myapp -m template.rb. The template.rb file is where all the magic happens. It tells our new app how to configure itself and essentially presents a checklist of tasks to perform. This ultimately saves me a load of time!

Following along

If you used my template you should be in good shape to kick of building the job board. The main models we will utilize in this project are the User model and the Job model.

Jobs

Each Job will house quite a few fields of which are important for any type of job listing online.

Each Job will feature the following:

  • Title – title:
  • Description – description:text
  • Logo Avatar – via Carrierwaveavatar:string
  • Website URL – url:string
  • Type: Fulltime, Part-Time, Freelance, Contract job_type:string
  • Location – location:string
  • User ID – user_id:integer
  • Remote ok – remote_ok: boolean, default: false
  • apply_url – apply_url:string

Scaffolding this model is relatively trivial with rails. Fair warning that it’s a rather lengthy script to run.


$ rails g scaffold Job title:string description:text url:string job_type:string location:string remote_ok:boolean apply_url:string

Notice how I left out avatar and user_id. We add those later as separate migrations where avatar is a string based column and user_id is an integer based column.

Each User will have:

  • Name – name:string
  • Email – email:string
  • Stripe ID – stripe_id:string
  • Card Type – card_type:string
  • Card Last 4 – card_last4:string
  • Card Exp Mo – card_exp_month:string
  • Card Exp Year – card_exp_year:string
  • Expires at – expires_at:datetime
  • Admin – admin:boolean

We don’t use a scaffold for Users in this app as Devise does most of the heavy lifting for us. Rather than scaffold any model we just perform a few migrations to get our hands dirty.

The first is an admin column. This column as you can probably guess dictates whether a given user is an admin or not. At it’s most basic form all we need to do to make a user an admin is to set the admin column to true. And then in all our views, we can use a clever method to check if this is indeed the case


if current_user.try(:admin?)
 # show something only admins can see here
end

If you used my initial Kickoff template you should have Devise all ready to go out of the box. This appends a name field to our user model but we want to get a bit more information about the user when it comes time to make a purchase. Those extra bits of information include primarily credit card related information. We can add those as a simple migration all at once.


class AddCardInfoToUsers < ActiveRecord::Migration[5.1]
  def change
    add_column :users, :stripe_id, :string
    add_column :users, :card_brand, :string
    add_column :users, :card_last4, :string
    add_column :users, :card_exp_month, :string
    add_column :users, :card_exp_year, :string
    add_column :users, :expires_at, :datetime
  end
end

Now since we are using Stripe charges we don’t necessarily require this information on a given user. If you, for example, wanted to add some sort of subscription service to your app you might be better off saving this type of data. For our app, I just wanted to show by example. In future apps, we will look into the subscription model using Stripe and/or Braintree as a merchant.

Continuing on

I think from here it’s best to follow along watching the videos. The bulk of implementing a payment gateway into an app is knowing where it will live and how a user must interact with it before, during, and after purchase. With Rails and Stripe, you can hook into parameters and events to build a payment flow of your dreams. This app starts small with charges but I plan to scale more apps to have a subscription type of flow and even possibly utilize Stripe Connect where you can be a merchant who allows each of your users to both send and receive payments using Stripe as well. Until then I hope you enjoyed this build.

If you haven’t checked out the previous builds find those linked below:

  1. Let’s Build: With Ruby on Rails – Introduction
  2. Let’s Build: With Ruby on Rails – Installation
  3. Let’s Build: With Ruby on Rails – Blog with Comments
  4. Let’s Build: With Ruby on Rails – A Twitter Clone
  5. Let’s Build: With Ruby on Rails – A Dribbble Clone
  6. Let’s Build: With Ruby on Rails – Project Management App
  7. Let’s Build: With Ruby on Rails – Discussion Forum
  8. Let’s Build: With Ruby on Rails – Deploying an App to Heroku
  9. Let’s Build: With Ruby on Rails – eCommerce Music Shop

The Videos

Part 1

Part 2

Part 3

Part 4

Part 5

Part 6

Part 7

Thanks!

This series has been really fun for me. It probably goes without saying that this has also been a huge undertaking. I appreciate the attention it getting and can’t thank you enough if you’ve already subscribed to my YouTube channel or my weekly newsletter.

Finally, I hate asking for support but it really would make my efforts seem more worthy as I continue to author more content. Having support would mean higher quality videos and apps as I would be able to spend more time on them.

If you have interest in contributing I’ve recently made a Patreon page of which you can support me in a variety of ways. I’m always looking for feedback and would love to help out if you hit some roadblocks along the way as you follow along. If you can’t support me in that way I completely understand! Maybe a share/follow on Twitteror a like and subscribe on YouTube would be more for you. Either way thanks so much for following along this far. Until next time, peace!

Become a Patron!