How to Build a Content Monitoring App with Ruby • Daily CyberSecurity

What exciting tools have you built in Ruby? A command-line tool or media player? A web scraper or extraction tool? Maybe something for parsing, data cleaning, and filtering? Well, bring along that same raw curiosity and sandbox excitement, because today we are building a content monitoring app in Ruby. Before we start, if this seems to be a little too intense – why not use pre-built code capsules designed and tested by big-time players in the web development industry? It is quick, easy, and convenient! However, if you feel confident and want to learn the nitty, gritty – this tutorial is for you.

What You Need

Before you can build a Ruby content monitoring app, you will need to have a few tools. First, you need a computer that can run Ubuntu 18.04. The machine should also have a non-root user that can access administrative privileges, and it should have a firewall. You’ll also need:

js
Npm
Ruby
Rbenv
Rails

You should install each of the previous programs on your Ubuntu machine. Use the following code to update the package index:

sudo apt update

You can install SQLite with the code:

sudo apt install sqlite3 libsqlite3-dev

You can then use the following to make sure everything is running correctly.

sqlite3 –version

Now, you can start building Ruby applications for content monitoring.

Start a Rails Project

After you install your database, you can create a Rails app. You can use the rails new command to create an app, and you can name it whatever you like:

rails new example

Swap out “example” with your project name. Then, you can see the output as Rails creates your project, including the following:

Gemfile
App directory
Config file
Database configuration

After that, the program will run a bundle install to create your app. Then, you can go to the app directory with the following code:

cd example

Now, use the rails server command to make sure the application works. You can use the following code when working on a local machine:

rails server

Next, you can see the Rails welcome message. You can then start building a unique app for content monitoring.

Make the Scaffolding

To start creating your app, you need to make a model that can manage your data. You can use the following command to build the scaffolding for your app:

rails generate scaffold

You can also use the generate scaffold command to set up a database table with the model name and other fields. Use the following code to generate a controller, model, and views:

rails generate scaffold Example name:string facts:text

The name:string gives the app permission to include and accept your app name. Meanwhile, the facts:text will allow other fields to appear in the database table.

After you use the command, you can watch the app generate different elements, such as the app/models/example.rb.

This generation will also show a new controller with the file name app/controllers/example_controller.rb, and it will also create a file for views with the folder name:

app/views/example.

You will also find that config/routes.rb has a new resource route with the name resources :example.

You can use this command to view the controller file:

cat app/controllers/example_controller.rb

The output may look like this:

class ExampleController < ApplicationController

before_action :set_example, only: [:show, :edit, :update, :destroy]

# GET /example

# GET /example.json

def index

    @example = example.all

end

# GET /example/1

# GET /example/1.json

def show

end

# GET /example/new

def new

    @example = example.new

end

# GET /example/1/edit

def edit

end

# POST /example

# POST /example.json

def create

    @example = example.new(example_params)

    respond_to do |format|

      if @example.save

        format.html { redirect_to @example, notice: ‘example was successfully created.’ }

        format.json { render :show, status: :created, location: @example }

      else

        format.html { render :new }

        format.json { render json: @example.errors, status: :unprocessable_entity }

      end

    end

end

# PATCH/PUT /example/1

# PATCH/PUT /example/1.json

def update

    respond_to do |format|

    if @example.update(example_params)

        format.html { redirect_to @example, notice: ‘example was successfully updated.’ }

        format.json { render :show, status: :ok, location: @example }

      else

        format.html { render :edit }

        format.json { render json: @example.errors, status: :unprocessable_entity }

      end

    end

end

# DELETE /example/1

# DELETE /example/1.json

def destroy

    @example.destroy

    respond_to do |format|

      format.html { redirect_to example_url, notice: ‘example was successfully destroyed.’ }

      format.json { head :no_content }

    end

end

private

    # Use callbacks to share common setup or constraints between actions.

    def set_example

      @example = example.find(params[:id])

    end

    # Never trust parameters from the scary internet, only allow the white list through.

    def example_params

      params.require(:example).permit(:name, :facts)

    end

end

You can review the output to make sure everything looks good. Then, you can move to the next step in creating Ruby applications.

Create the Root View

When you release the app, you want users to go straight to the root, so you can create a root view. You can do this in a few ways, such as creating an index page or developing a home view.

You’ll need to edit the config/routes.rb to set up the application root. You can use the following code when editing your root view:

Rails.application.routes.draw do

resources :example

root ‘example#index’

Make sure you save the file and leave the editor, and then you can use this code to run and view your application:

rails db:migrate

Then, you can restart your Rails server using the following code for a local project:

rails s

If you use a development server, you will need to use the following code:

rails s –binding=your_server_ip

Now, you can start adding features to your app with different pieces of code. The code you use can depend on the features you want to add.

Test the Functionality

After you add the features you want, you can test how everything works. You can run the application page to add or edit the features.

Your app can be as simple or complex as you like. Consider what type of content you want to monitor, then you can include that when adding functions.

Add Validation

You may not need to add validations, but you can if you want. This is good if you want to create a database as part of your app because you can control what people can and can’t add to the database.

You can go to your ApplicationRecord and add the following to your models:

validates :name, presence: true, uniqueness: true

If you want to add other validations, you can write them in the same place.

Add Authentication

Adding authentication allows you to have more control over your app. If you only want some people to control content monitoring, you can require people to sign in. You’ll need to add the following code to the Application Controller:

http_basic_authenticate_with name: user, password: password, except: [:index, :show]

After you save and close your work, you can test it. You should see a username and password requirement to add or change things.

Creating Ruby Applications

Whether you have programming experience or not to create multiple Ruby applications for content monitoring. Then, you can adjust the app to limit access and controls.

As long as you have access to Ubuntu, you can download the rest of the tools you need. Then, you can verify the code to make a basic app.