DEV Community: marelons1337

Specifying a polymorphic has_many through: association in Rails

marelons1337 — Wed, 14 Dec 2022 23:10:36 +0000

In my recent project that I'm working on I faced this problem where I have a Client model and two different models for properties, Sale and Rental. To avoid having multiple tables for ClientSales and ClientRentals I wanted to just have ClientProperties, and for that I need a polymorphic has_many through:

In Ruby on Rails, the has_many :through association is a way of creating a many-to-many connection with an extra model. This association is often used to create a join table that connects two other tables.

In my example I have three models a Property::Rental, Property::Sale model and a Customer::Client model. A rental can have multiple clients(tenants), and a client can buy multiple properties. To create this association, we need to create a join table called client_properties that has foreign keys for the client, and property. Since we want to only use one model called Property::ClientProperty for both of these, we need a polymorphic association.

First, we our table for property_client_properties.

class CreatePropertyClientProperties < ActiveRecord::Migration[7.0]
  def change
    create_table :property_client_properties do |t|
      t.references :client
      t.integer :property_id
      t.string :property_type

      t.timestamps
    end
  end
end

:property_type column will be used to store which model we are actually referring to when passing an id. Let's run rails db:migrate.

Now in our Property::ClientProperty we only need a few adjustments.

# app/models/property/client_property.rb

belongs_to :client, class_name: 'Customer::Client'
belongs_to :property, polymorphic: true

Now that we have a polymorphic :property association, we can refer to this model outside of it as :property. Here's how we can use this association with one of our models, for example Property::Sale.

# app/models/property/sale.rb

has_many :client_properties, as: :property
has_many :clients, through: :client_properties

With this setup we can now add a client to sale.

irb(main):004:0> sale = Property::Sale.last  
=>                                               
#<Property::Sale:0x0000000109bdd738>

irb(main):005:0> client = Customer::Client.last
=>                                
#<Customer::Client:0x0000000118086308>

irb(main):006:0> sale.clients << client
=>                                
[#<Customer::Client:0x0000000118086308, <Customer::Client:0x0000000107454018]

Now, two things are happening when we append another client to this association. One is creating our Property::ClientProperty record by running INSERT and two, returning a relation with this new record already in it. We can access clients for this sale using normal association methods like sale.clients.

To finish this up, we want it to be bidirectional, so let's add the rest of the logic on the client side.

# app/models/customer/client.rb

has_many :client_properties, class_name: 'Property::ClientProperty',
dependent: :destroy

has_many :sales, through: :client_properties, source: :property,
source_type: 'Property::Sale', class_name: 'Property::Sale'

has_many :rentals, through: :client_properties, source: :property,
source_type: 'Property::Rental', class_name: 'Property::Rental'

Here, we specify the source_type which is exactly what is going to be inserted into our property_type column.
And that's it!

Rails + Stimulus.js sorting filter on select

marelons1337 — Tue, 29 Nov 2022 22:32:45 +0000

In my new project I wanted to introduce sorting on the index page for my records and I came up with this simple Stimulus.js solution.

First, I created the select

<select aria-label="select">
  <option value="id desc">Latest</option>
  <option value="id asc">Oldest</option>
  <option value="name asc">A-Z</option>
  <option value="name desc">Z-A</option>
</select>

Then once i have my element in place I can create a Stimulus controller

rails g stimulus select

And also attach it to my select

<select data-controller="select" aria-label="select">
  <!-- content -->
</select>

Now, let's attach the action to our element that is responsible for selecting.

export default class extends Controller {
  params = new URLSearchParams(window.location.search)
  connect() {
    // attach action to the element
    this.element.dataset.action = "change->select#filter"
    // set initial params after page load
    this.element.value = this.params.get('sort')
  }
  filter() {
    const query = this.element.value
    this.params.set('sort', query)
    window.location.search = this.params.toString()
  }
}

The reason I'm setting this.element.value in my connect() method is because of the next method introduced, filter(). Here I will set the search location of the window object to the params we got from our select. However this will refresh the page and cause the select to reset.

Last step is adding the actual filtering to the controller, but to make sure that it's safe and user cannot send their own values I also introduce an array of values available in this filter.

class Property::SalesController < ApplicationController
  before_action :set_property_sale, only: %i[ show edit update destroy ]
  SORT_METHODS = ['id asc', 'id desc', 'name asc', 'name desc']

  # GET /property/sales or /property/sales.json
  def index
    @property_sales = Property::Sale.all
    @property_sales = @property_sales.order(params[:sort]) if params[:sort].presence.in? SORT_METHODS
  end
end

Now our input is safe because only these 4 strings can trigger a database call.

Creating model for "related" posts in Rails

marelons1337 — Sat, 23 Apr 2022 21:03:11 +0000

I wanted to create a section on my page that leads to related posts. One proposition was to create additional table and store from and to ID's of related posts.

rails g model post title content

First we want to have our model, nothing special about it, just an example Post class.

Next, we need a class that will connect our related posts.

rails g model post_connection from_post:references to_post:references

Here's my migration file, I'm also adding index on both ids to make sure that there can only be one PostConnection per each combination of Post -> Post to avoid duplicate records.

class CreatePostConnections < ActiveRecord::Migration[7.0]
  def change
    create_table :post_connections do |t|
      t.references :from_post
      t.references :to_post

      t.index [:from_post_id, :to_post_id], unique: true

      t.timestamps
    end
  end
end

Now, I also want to make sure that users will not be able to relate the post to itself. So the only connections available will be p1 -> p2 and p2 -> p1. This p1 -> p1 connection is redundant.

class PostConnection < ApplicationRecord
  belongs_to :from_post, class_name: 'Post'
  belongs_to :to_post, class_name: 'Post'

  validate :connection_uniqueness
  validates :from_post_id, uniqueness: { scope: [:to_post_id, :from_post_id], message: 'this connection already exists' }

  def connection_uniqueness
    if self.from_post_id == self.to_post_id
      errors.add(:post_connection, 'must be between two different posts')
    end
  end
end

On the Post side, we need to make sure that we can access specific connections. Using dependent: :destroy will make sure that whenever a Post is destroyed, so does connection.

class Post < ApplicationRecord
  has_many :from_posts, foreign_key: :from_post_id, class_name: 'PostConnection', dependent: :destroy
  has_many :to_posts, foreign_key: :to_post_id, class_name: 'PostConnection', dependent: :destroy

  def post_connections
    from_posts.or(to_posts)
  end
end

Now let's see this in action.

p1 = Post.create(title: "First Post")
=>
#<Post:0x00000001105b6d08                                                                    
 id: 1,                                                                                      
 title: "First Post",                                                                        
 ... >   
p2 = Post.create(title: "Second Post")
=>
#<Post:0x0000000110245d18                        
 id: 2,                                          
 title: "Second Post",                                                            
 ... >

Adding our Posts we can now create a connection between them.

pc1 = PostConnection.create!(from_post: p1, to_post: p2)
pc1
=> 
#<PostConnection:0x00000001377a7988              
 id: 1,                                          
 from_post_id: 1,                                
 to_post_id: 2,                                  
 ... >

Great, we have our connection! Now let's see what happens if we try to add the exact same connection again.

pc1 = PostConnection.create!(from_post: p1, to_post: p2)

Validation failed: From post this connection already exists (ActiveRecord::RecordInvalid)

Awesome, our validation works, and just to double check custom validation that was added to PostConnection we can try assigning a connection from and to the same Post.

pc1 = PostConnection.create!(from_post: p1, to_post: p1)

Validation failed: Post connection must be between two different posts (ActiveRecord::RecordInvalid)

Nice, custom validation works as expected!

Let's create a connection in other direction and find all connections for a Post.

pc2 = PostConnection.create!(from_post: p2, to_post: p1)
pc2
=> 
#<PostConnection:0x0000000116fc2800                                                      
 id: 2,                                                                                  
 from_post_id: 2,                                                                        
 to_post_id: 1,                                                                          
 ... >

p1.post_connections
=>                                                             
[#<PostConnection:0x00000001132d4790                           
  id: 1,                                                       
  from_post_id: 1,                                             
  to_post_id: 2,                                               
  ... >, 
 #<PostConnection:0x00000001132d4650                           
  id: 2,                                                       
  from_post_id: 2,                                             
  to_post_id: 1,                                               
  ... >]

Yes, we can access all our connections now! I can also use a specific association to access only one part of PostConnections for specific Post. For example I can select only from_posts to see which connections were created directly from this post.

p1.from_posts
=>
[#<PostConnection:0x0000000113064e38                           
  id: 1,                                                       
  from_post_id: 1,                                             
  to_post_id: 2,                                               
  ... >]

Got it! One thing that could probably be done is query optimization when calling post_connections as it uses OR statement which is not very efficient for filtering. Let me know if you have any suggestions to improve this, I hope that it helps you!

Create honeypot against spam bots in Rails

marelons1337 — Wed, 16 Mar 2022 11:15:20 +0000

I was trying to implement something that is less annoying than google recaptcha. Everyone knows that it's quite exhausting for some users. Also I would like to reduce the amount of requests made to google with all gtags, analytics, ads etc. are already slowing the whole internet down.

I found this very old article on how to stop those simpliest bots(in the app I am working on most of the spam came from these basic crawler/spammer types) using a honeypot technique.

Basically whole idea behind honeypot is that you can add some fields to the form that are not visible to the user, but if those simple bots scraping your website will see them, they would probably fill them out.

This article inspired me to try it with a little twist, and here's how it went.

Of course this will be of no use against real human spammers. So you should probably also invest in Akismet.

Let's add some of these strategies mentioned in the article into the controller that is responsible for creating Posts.

# clarify time will make more sense later on. I am using regular names like status and street_name for my trap fields, they will be invisible to the user anyway, but bots might have a list of fields to fill out.

Notice how I send status: :ok when the alert is shown(means it got caught either by timer or by filling the field that should be empty). So for normal human being nothing will really change, but bot will see response 200 OK meaning that he was successful in his posting and will move on.

You should also consider adding blocking IP's after certain amount of tries within short period of time. I have noticed that these bots usually send hundreds of requests/sec, so these should be relatively easy to catch.

You can easily test it as well.

Now, let's create a partial that will be used in our views for rendering this honeypot using <%= render 'posts/honeypot' %> later on.

#general-ackbar { display: none;} will hide out our div, but I am still using css_strategy to change it as I assume some bots might read css and just ignore some of the fields if they're for example hidden. These are just some ways to obfuscate your fields.

Now, I also obfuscate the time so I can check it once it gets back to the server. In the previous gist you saw that timer is set to 5 seconds.

This can be just changed to any number, just try to fill out your form as fast as you can and then add this time as a value under which you will display the alert.

To summarize, this method will not protect against any advanced bots and human spammers, but it might help you fight those basic robots.

You might also want to add blocking IP's that are sending too many requests and other anti-spam tools.

Using attr_accessor to clean up your calls between models

marelons1337 — Tue, 22 Feb 2022 22:53:14 +0000

In my glorious real estate management app I thought that it'd be cool to know how much rent a tenant has to pay without typing tenant.flat.rent every single time (tenant belongs_to :flat)
So instead, we can just use attr_accessor :rent as below.

Now I can always access tenant's rent by simply going for tenant.rent

Ensure only one record has specific value for another associated record | Rails 6.1.4

marelons1337 — Sun, 06 Feb 2022 19:51:43 +0000

I couldn't come up with a better title, but for my app for landlords I faced a problem where I don't want to remove old tenants. I want to store them in a database for future reference. So that leaves me with problem of making sure that only one tenant can have "active" status at any given time.

Now, I tried to find a way of forcing that on a database level, but then I thought about rails validations. I can check that on adding or modifying my tenants. And since my app will never be big enough for multiple users to update the same record in DB concurrently, I decided to implement that directly in the app.

Let's assume our Flat has_many :tenants and Tenant belongs_to :flat

I will take advantage of rails model callback order. And first four go as below:

So now I can use this order to force validation of my record to see if any other tenants are active. If there is another tenant that is active, I won't allow the record to save. Sounds simple to me.

Few things happened above. I use my method determine_active in my validation. I do that because in my force_one_active function, it first checks if the tenant should be active at all, then performs a search to check if there are any additional tenants with the same status, if it happens to find that the flat is occupied, it stops the record from saving on a validation level, thus leaving active = false.

I've also added another function to set flat's taken value if our current tenant happened to be active.

Now, because this method is in before_save callback it will never run unless validation has passed successfully, as per order shown previously.

It's not perfect, but it works for a smaller scale app like mine.

Create dynamic dependant dropdowns with Javascript in Rails 6.1.4

marelons1337 — Thu, 03 Feb 2022 09:08:34 +0000

What we want to do here

I managed to pull this stunt off in an app I'm working on. Let's say we want to have a payment module. On top of the form we have three dropdowns. To make things easier for the user, I want these dropdowns to be dependant, so first I choose the building, then another dropdown only server me flats that actually belong to the building and finally after choosing a flat, I will only be able to choose tenant that is living there.

Key points:

Flat and Tenant dropdowns are empty until previous dropdown has changed.
After Building and Flat dropdown change, I want to fetch the data for next dropdown.
I want to use the data from fetch to fill out dropdowns.

I'm setting up my arrays in the controller so I can access all the data in my view.

Now, if I want to fetch any data from the server I will need an endpoint that will allow me to access the data in JSON format so I can easily parse it and fill my dropdowns with it.
First, I create entries in my config/routes.rb file.

That will reflect my actions in controllers:

Now that I have my backend setup, I can proceed with the front.

Here I have my dropdowns that I need to fill out dynamically.

At the time of writing this post, Rails 7 has already been released, but I already started my app in 6.1.4 and managed to understand a fraction of webpacker so I decided to stick with it. My JS code is inside javascript folder.
app/javascript/forms/fetch_building_data.js

Also, I added the require statement in application.js
require('forms/fetch_building_data')

Here, I load my variables as soon as turbolinks:load is finished. That's the correct way of adding this handler, because if you try to add DOMContentLoaded or load it won't work. Rails way🛤.

Because I'm also using this script on Tenants view used to create them to have only two dropdowns (for Building and Flat) I have bundled this code into one file.
Now, first of all I set up length of dependant select tags to 1, that way only my placeholder will be available until you actually choose something. The rest of the function takes care of collecting the input from the dropdown
buildingSelect.addEventListener('input', function (event)
and storing it let buildingId = event.target.value
Functions at the bottom create options for my select and append them.

That's it.