implement a booking lock for users in a scheduling app - sql

Question

I've built a scheduling web app where users can book a conference for a given date and time slot on that date.
Now I need to implement a booking lock, which means that the admin can apply this lock and users can no longer book from that time on.
My current design includes a model booking_lock that only has one attribute of "status" with values of "On" and "Off".
The model would have only one record in the database at any given time as its sole responsibility would be to provide the data to check if booking has been locked.
---------------------EDIT-----------------------------------
This is not meant to lock individual records (conferences). To do this I use the attribute of user_id. If that is 0, then the conference is available for booking.
What I want to do now is disable (lock) the booking entirely before the user hits the database.
For example:
When a user logs on they see a notification saying the booking is locked. Also, they wouldn't see a respective button to book a conference and if by chance they would navigate to the respective URL they would be redirected to home page with the same notice as above. I've got all this covered.
But I need a general switch to be turned on and off and be the basis for this kind of check. Hence the booking_lock model.
Note: I use hanami-model.
---------------------EDIT-----------------------------------
My question is twofold:
Is there a better way of implementing such a lock?
How to ensure there is only one record in the db for such lock?

Answer 1

1. Is there a better way of implementing such a lock?
It seems that your requirement is to have an application-wide setting, which is best done with
An environment variable
A value stored in database
Environment variables:
pros: system already in place, simple usage, can easily be configured statically and changed dynamically
cons: might be difficult to maintain with a multi-tenant architecture (multiple servers running the same app)
DB persistence
pros: scales easily with a multi-tenant architecture
cons: can seem a bit of an overkill for one setting BUT can easily be abstracted into a Key/Value store for multiple settings.
Example:
Create an AppSettings model with two columns: key & value.
Create and save an AppSetting with key "lock_booking_for_parents" and change the value through an admin interface.
Access this AppSetting throughout the app to know if you should lock booking or not.
Also, if you are worried about querying your database everytime you need to know if booking is enabled/disabled, you can easily implement caching.
2. How to ensure there is only one record in the db for such lock?
Environment variable
Not applicable
DB persistence
You can create a helper class to access your settings with default behavior, and use first_or_create method to ensure the record is unique.
class AppSettingsHelper
def self.booking_enable?
app_setting_record = AppSettings.find_by_key("lock_booking_for_parents")
if app_setting_record
return app_setting_record.value
else
## default behavior of your app when no record has been created yet
return true
end
end
def self.enable_booking
AppSettings.where(:key => "lock_booking_for_parents").first_or_create({value: false})
end
def self.disable_booking
AppSettings.where(:key => "lock_booking_for_parents").first_or_create({value: true})
end
end

Answer 2

You could try the ActiveRecord pessimistic locking method, or something like it. Set a field on your record that indicates a lock and try it:
booking_lock = UUID.new # Or any sufficiently unique string
Booking.update_all({ id: #booking.id, booking_lock: booking_lock }, { booking_lock: nil })
booked = Booking.find_by(id: #booking.id, booking_lock: booking_lock)
If you get the record back you successfully locked it. If not you need to try again with a different booking, it got nabbed before you could claim it.