diff --git a/app/controllers/clients_controller.rb b/app/controllers/clients_controller.rb
index f269754..03c33c4 100644
--- a/app/controllers/clients_controller.rb
+++ b/app/controllers/clients_controller.rb
@@ -1,79 +1,88 @@
 class ClientsController < ApplicationController
   before_action :require_logged_in
   before_action :fetch_client, only: [:show, :jobs, :logs, :stats, :users, :restore, :run_restore]
   before_action :fetch_logs, only: [:logs]
 
   # GET /clients
   # POST /clients
   def index
     @client_ids = Client.for_user(current_user.id).pluck(:ClientId)
     @clients = Client.where(ClientId: @client_ids).includes(:jobs)
     @hosts = current_user.hosts.not_baculized
     fetch_jobs_info
     get_charts
   end
 
   # GET /clients/1
   def show
     @schedules = @client.host.job_templates.map(&:schedule)
     @filesets = @client.host.job_templates.map(&:fileset)
   end
 
   # GET /clients/1/jobs
   def jobs
     @jobs = @client.recent_jobs.page(params[:page])
   end
 
   # GET /clients/1/logs
   def logs; end
 
   # GET /clients/1/stats
   # POST /clients/1/stats
   def stats
     get_charts
   end
 
   # GET /clients/1/users
   def users
     @users = @client.host.users
   end
 
   # GET /clients/1/restore
   def restore
     return if @client.is_backed_up?
 
     flash[:error] = 'Can not issue a restore for this client'
     redirect_to client_path(@client)
   end
 
   # POST /clients/1/run_restore
   def run_restore
     location = params[:restore_location].blank? ? '/tmp/bacula-restore' : params[:restore_location]
     fileset = params[:fileset]
-    if location.nil? || fileset.nil? || !@client.host.restore(fileset, location)
+    restore_point = fetch_restore_point
+    if location.nil? || fileset.nil? || !@client.host.restore(fileset, location, restore_point)
       flash[:error] = 'Something went wrong, try again later'
     else
       flash[:success] =
         "Restore job issued successfully, files will be soon available in #{location}"
     end
 
     redirect_to client_path(@client)
   end
 
   private
 
   def fetch_client
     @client = Client.for_user(current_user.id).find(params[:id])
     @client_ids = [@client.id]
   end
 
   def fetch_jobs_info
     @stats = JobStats.new(@client_ids)
   end
 
   def get_charts
     days_ago = params.fetch(:days_back, 7).to_i rescue 7
     @job_status = ChartGenerator.job_statuses(@client_ids, days_ago)
     @job_stats = ChartGenerator.job_stats(@client_ids, days_ago - 1)
   end
+
+  def fetch_restore_point
+    if params['restore_time(4i)'].blank? || params['restore_time(5i)'].blank? ||
+        params[:restore_date].blank?
+      return nil
+    end
+    "#{params[:restore_date]} #{params['restore_time(4i)']}:#{params['restore_time(5i)']}:00"
+  end
 end
diff --git a/app/models/client.rb b/app/models/client.rb
index d5ad86f..5087fa6 100644
--- a/app/models/client.rb
+++ b/app/models/client.rb
@@ -1,127 +1,139 @@
 # Bacula Client class.
 # All hosts that are getting backed up with Bacula have a Client entry, with
 # attributes concerning the Client.
 class Client < ActiveRecord::Base
   self.table_name = :Client
   self.primary_key = :ClientId
 
   alias_attribute :name, :Name
   alias_attribute :uname, :Uname
   alias_attribute :auto_prune, :AutoPrune
   alias_attribute :file_retention, :FileRetention
   alias_attribute :job_retention, :JobRetention
 
   has_many :jobs, foreign_key: :ClientId
   has_one :host, foreign_key: :name, primary_key: :Name
 
   scope :for_user, ->(user_id) { joins(host: :users).where(users: { id: user_id }) }
 
   DAY_SECS = 60 * 60 * 24
 
   # Fetches the client's job_templates that are already persisted to
   #  Bacula's configuration
   #
   # @return [ActiveRecord::Relation] of `JobTemplate`
   def persisted_jobs
     host.job_templates.where(baculized: true).includes(:fileset, :schedule)
   end
 
   # Fetches the client's performed jobs in reverse chronological order
   #
   # @return [ActiveRecord::Relation] of `Job`
   def recent_jobs
     jobs.order(EndTime: :desc).includes(:file_set)
   end
 
   # Helper method. It shows the client's  job retention,
   # (which is expressed in seconds) in days.
   #
   # @return [Integer]
   def job_retention_days
     job_retention / DAY_SECS
   end
 
   # Helper method. It shows the client's  file retention,
   # (which is expressed in seconds) in days.
   #
   # @return [Integer]
   def file_retention_days
     file_retention / DAY_SECS
   end
 
   # Helper method for auto_prune
   #
   # @return [String] 'yes' or 'no'
   def auto_prune_human
     auto_prune == 1 ? 'yes' : 'no'
   end
 
   # Helper method for displayin the last job's datetime in a nice format.
   def last_job_date_formatted
-    if job_time = jobs.backup_type.last.try(:end_time)
+    if job_time = last_job_datetime
       I18n.l(job_time, format: :long)
     end
   end
 
+  # Helper method for fetching the last job's datetime
+  def last_job_datetime
+    jobs.backup_type.last.try(:end_time)
+  end
+
+  # Fetches the first and last job's end times.
+  #
+  # @returns [Array] of datetimes in proper format
+  def backup_enabled_datetime_range
+    jobs.backup_type.pluck(:end_time).minmax.map { |x| x.strftime('%Y-%m-%d') }
+  end
+
   # Shows if a client has any backup jobs to Bacule config
   #
   # @return [Boolean]
   def is_backed_up?
     jobs.backup_type.any?
   end
 
   # Shows the total file size of the jobs that run for a specific client
   #
   # @return [Integer] Size in Bytes
   def backup_jobs_size
     jobs.backup_type.map(&:job_bytes).sum
   end
 
   # Shows the total files' count for the jobs that run for a specific client
   #
   # @return [Integer] File count
   def files_count
     jobs.map(&:job_files).sum
   end
 
   # Fetches the client's jobs that are running at the moment
   #
   # @return [Integer]
   def running_jobs
     jobs.running.count
   end
 
   # Displays the bacula config that is generated from the client's
   # host
   #
   # @return [String]
   def bacula_config
     return unless host
     host.baculize_config.join("\n")
   end
 
   # Fetches the job ids that will construct the desired restore
   #
   # @param fileset_id[Integer] the fileset
   # @param restore_point[Datetime] the restore point
   #
   # @return [Array] of ids
   def get_job_ids(file_set_id, restore_point)
     job_ids = {}
     backup_jobs = jobs.backup_type.terminated.where(file_set_id: file_set_id)
     backup_jobs = backup_jobs.where('EndTime < ?', restore_point) if restore_point
 
     job_ids['F'] = backup_jobs.where(level: 'F').pluck(:JobId).last
     return [] if job_ids['F'].nil?
     job_ids['D'] = backup_jobs.where(level: 'D').where("JobId > ?", job_ids['F']).pluck(:JobId).last
     job_ids['I'] = backup_jobs.where(level: 'I').
       where("JobId > ?", job_ids['D'] || job_ids['F'] ).pluck(:JobId)
 
     job_ids.values.flatten.compact
   end
 
   # Fetches the bacula filesets that are associated with the client
   def file_sets
     FileSet.joins(:jobs).where(Job: { JobId: job_ids }).uniq
   end
 end
diff --git a/app/models/host.rb b/app/models/host.rb
index d6f1ca7..dee59f9 100644
--- a/app/models/host.rb
+++ b/app/models/host.rb
@@ -1,258 +1,258 @@
 # The bacula database must be independent from all of our application logic.
 # For this reason we have Host which is the application equivalent of a Bacula Client.
 #
 # A host is being created from our application. When it receives all the configuration
 # which is required it gets dispatched to bacula through some configuration files. After
 # that, a client with the exact same config is generated by bacula.
 class Host < ActiveRecord::Base
   include Configuration::Host
 
   STATUSES = {
     pending: 0,
     configured: 1,
     dispatched: 2,
     deployed: 3,
     updated: 4,
     redispatched: 5,
     for_removal: 6,
     inactive: 7
   }
 
   has_many :ownerships
   has_many :users, through: :ownerships, inverse_of: :hosts
 
   belongs_to :client, class_name: :Client, foreign_key: :name, primary_key: :name
   belongs_to :verifier, class_name: :User, foreign_key: :verifier_id, primary_key: :id
 
   has_many :filesets, dependent: :destroy
   has_many :job_templates, dependent: :destroy
   has_many :schedules, dependent: :destroy
 
   validates :file_retention, :job_retention,
     :port, :password, presence: true
   validates :port, numericality: true
 
   validates :fqdn, presence: true, uniqueness: true
 
   validate :fqdn_format
 
   scope :not_baculized, -> {
     joins("left join Client on Client.Name = hosts.name").where(Client: { Name: nil })
   }
 
   scope :in_bacula, -> {
     where(
       status: STATUSES.select { |k,_|
         [:deployed, :updated, :redispatched, :for_removal].include? k
       }.values
     )
   }
 
   scope :unverified, -> { where(verified: false) }
 
   before_validation :set_retention, :unset_baculized, :sanitize_name
 
   state_machine :status, initial: :pending do
     STATUSES.each do |status_name, value|
       state status_name, value: value
     end
 
     after_transition [:dispatched, :redispatched, :configured, :updated] => :deployed do |host|
       host.job_templates.enabled.
         update_all(baculized: true, baculized_at: Time.now, updated_at: Time.now)
     end
 
     event :add_configuration do
       transition [:pending, :dispatched, :inactive] => :configured
     end
 
     event :dispatch do
       transition :configured => :dispatched
     end
 
     event :redispatch do
       transition :updated => :redispatched
     end
 
     event :set_deployed do
       transition [:dispatched, :redispatched, :configured, :updated] => :deployed
     end
 
     event :change_deployed_config do
       transition [:deployed, :redispatched, :for_removal] => :updated
     end
 
     event :mark_for_removal do
       transition [:dispatched, :deployed, :updated, :redispatched] => :for_removal
     end
 
     event :set_inactive do
       transition [:deployed, :dispatched, :updated, :redispatched] => :inactive
     end
 
     event :disable do
       transition all => :pending
     end
   end
 
 
   # Shows the host's auto_prune setting
   def auto_prune_human
     client_settings[:autoprune]
   end
 
   # Uploads the host's config to bacula
   # Reloads bacula server
   #
   # It updates the host's status accordingly
   def dispatch_to_bacula
     return false if not needs_dispatch?
     bacula_handler.deploy_config
   end
 
   # Removes a Host from bacula configuration.
   # Reloads bacula server
   #
   # If all go well it changes the host's status and returns true
   #
   # @param force[Boolean] forces removal
   def remove_from_bacula(force=false)
     return false if not (force || needs_revoke?)
     bacula_handler.undeploy_config
   end
 
   # Restores a host's backup to a preselected location
   #
   # @param fileset_id[Integer] the desired fileset
   # @param location[String] the desired restore location
   # @param restore_point[Datetime] the desired restore_point datetime
   def restore(file_set_id, location, restore_point=nil)
     return false if not restorable?
     job_ids = client.get_job_ids(file_set_id, restore_point)
     file_set_name = FileSet.find(file_set_id).file_set
-    bacula_handler.restore(job_ids, file_set_name, location)
+    bacula_handler.restore(job_ids, file_set_name, restore_point, location)
   end
 
   # Runs the given backup job ASAP
   def backup_now(job_name)
     bacula_handler.backup_now(job_name)
   end
 
   # Disables all jobs and sends the configuration to Bacula
   def disable_jobs_and_update
     job_templates.update_all(enabled: false)
     bacula_handler.deploy_config
   end
 
   # Determinex weather a host:
   #
   # * has all it takes to be deployed but
   # * the config is not yet sent to bacula
   #
   # @return [Boolean]
   def needs_dispatch?
     verified? && (can_dispatch? || can_redispatch?)
   end
 
   # Determines weather a host is marked for removal
   #
   # @return [Boolean]
   def needs_revoke?
     for_removal?
   end
 
   # Handles the host's job changes by updating the host's status
   def recalculate
     add_configuration || change_deployed_config
   end
 
   # Fetches an info message concerning the host's deploy status
   def display_message
     if !verified?
       { message: 'Your host needs to be verified by an admin', severity: :alert }
     elsif pending?
       { message: 'client not configured yet', severity: :alert }
     elsif configured? || dispatched?
       { message: 'client not deployed to Bacula', severity: :alert }
     elsif updated? || redispatched?
       { message: 'client configuration changed, deploy needed', severity: :alert }
     elsif for_removal?
       { message: 'pending client configuration withdraw', severity: :error }
     elsif inactive?
       { message: 'client disabled', severity: :alert }
     end
   end
 
   # Determines if a host can issue a restore job.
   #
   # @returns [Boolean] true if the host's client can issue a restore job
   def restorable?
     client.present? && client.is_backed_up?
   end
 
   # @return [User] the first of the host's users
   def first_user
     users.order('ownerships.created_at asc').first
   end
 
   # Marks the host as verified and sets the relevant metadata
   #
   # @param admin_verifier[Integer] the verifier's id
   def verify(admin_verifier)
     self.verified = true
     self.verifier_id = admin_verifier
     self.verified_at = Time.now
     save
   end
 
   # Determines if a host can be disabled or not.
   # Equivalent to is_deployed
   #
   # @return [Boolean]
   def can_be_disabled?
     dispatched? || deployed? || updated? || redispatched?
   end
 
   private
 
   # automatic setters
 
   def sanitize_name
     self.name = fqdn
   end
 
   # Sets the file and job retention according to the global settings
   def set_retention
     self.file_retention = client_settings[:file_retention]
     self.file_retention_period_type = client_settings[:file_retention_period_type]
     self.job_retention = client_settings[:job_retention]
     self.job_retention_period_type = client_settings[:job_retention_period_type]
   end
 
   def unset_baculized
     self.baculized = false if new_record?
     true
   end
 
   # validation
 
   def fqdn_format
     regex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$)/
     unless fqdn =~ regex
       self.errors.add(:fqdn)
     end
   end
 
   # Proxy object for handling bacula directives
   def bacula_handler
     BaculaHandler.new(self)
   end
 
   # Fetches and memoizes the general configuration settings for Clients
   #
   # @see ConfigurationSetting.current_client_settings
   # @return [Hash] containing the settings
   def client_settings
     @client_settings ||= ConfigurationSetting.current_client_settings
   end
 end
diff --git a/app/views/clients/restore.html.erb b/app/views/clients/restore.html.erb
index 55f346d..1ed1569 100644
--- a/app/views/clients/restore.html.erb
+++ b/app/views/clients/restore.html.erb
@@ -1,42 +1,49 @@
 <div class="row">
   <div class="col-xs-4">
     <% if @client.is_backed_up? %>
-      <% restore_point = @client.last_job_date_formatted %>
       <div class="panel panel-default">
         <div class="panel-heading">
           <h3>Restore files for "<%= @client.name %>"</h3>
         </div>
 
         <br />
 
         <%= bootstrap_form_tag(url: run_restore_client_path(@client), layout: :horizontal,
                                label_col: 'col-xs-4', control_col: 'col-xs-7' ) do |f| %>
-          <div class="form-group">
-            <%= f.label(:restore_point, class: 'control-label col-xs-4') %>
-            <p class="form-control-static col-xs-8"><%= restore_point %></p>
-          </div>
+          <%= f.text_field :restore_date %>
+          <%= f.time_select :restore_time, ignore_date: true, minute_step: 30, prompt: true %>
 
           <%= f.select(:fileset,
                        options_from_collection_for_select(@client.file_sets, :id, :file_set)) %>
 
           <%= f.text_field :restore_location, placeholder: '/tmp' %>
 
           <div class="row">
             <div class="col-xs-3 col-xs-offset-9">
               <%= f.submit 'Restore Files', class: 'btn btn-warning text-right',
-                  data: { confirm: "This will restore all your files at the most recent backup (#{restore_point})" }
+                  data: { confirm: "This will restore all your files" }
               %>
             </div>
           </div>
         <% end %>
         </br>
       </div>
     <% else %>
       <div class="alert alert-warning">
         <p>Can not issue a restore for this host. It has no successful backups</p>
       </div>
     <% end %>
 
     <%= link_to 'Cancel', client_path(@client), class: 'btn btn-danger', role: 'button' %>
   </div>
 </div>
+<script type="text/javascript">
+  <% min_date, max_date = @client.backup_enabled_datetime_range %>
+  var minDate = '<%= min_date %>';
+  var maxDate = '<%= max_date %>';
+  $('#restore_date').datepicker({
+    dateFormat: 'yy-mm-dd',
+    minDate: minDate,
+    maxDate: maxDate
+  });
+</script>
diff --git a/lib/bacula_handler.rb b/lib/bacula_handler.rb
index cb642e6..c87ad3a 100644
--- a/lib/bacula_handler.rb
+++ b/lib/bacula_handler.rb
@@ -1,190 +1,191 @@
 class BaculaHandler
   require 'net/scp'
 
   attr_accessor :host, :templates, :client, :jobs, :schedules, :filesets
 
   # Initializes a BaculaHandler instance.
   #
   # Sets `host` and `templates` attributes.
   # Sets the temporal files that contain the client's configuration
   #
   # @param host[Host] A the host instance the the bacula handler will act upon
   def initialize(host)
     @host = host
     @templates = host.job_templates.includes(:fileset, :schedule)
 
     @client = get_client_file
     @jobs = get_jobs_file
     @schedules = get_schedules_file
     @filesets = get_filesets_file
   end
 
   # Deploys the host's config to the bacula director by
   #
   # * uploading the configuration
   # * reloadind the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def deploy_config
     return false unless send_config
     if reload_bacula
       if host.job_templates.enabled.any?
         host.set_deployed
       else
         host.set_inactive
       end
     else
       host.dispatch || host.redispatch
     end
   end
 
   # Removes the host's configuration from the bacula director by
   #
   # * removing the host's configuration files
   # * reloading the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def undeploy_config
     return false unless remove_config
     host.disable if reload_bacula
   end
 
   # Schedules an immediate backup to the bacula director for the given host and job
   #
   # @param job_name[String] the job's name
   def backup_now(job_name)
     job = host.job_templates.enabled.find_by(name: job_name)
     return false unless job
     command = "echo \"run job=\\\"#{job.name_for_config}\\\" yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   # Schedules an immediate restore to the bacula director for the given host.
   #
   # @param job_ids[Array] contains the jobs that compose the restore for this fileset
   # @param file_set_name[String] the fileset that is going to be restored
+  # @param restore_point[String] the restore datetime
   # @param location[String] the desired restore location
-  def restore(job_ids, file_set_name, location="/tmp/bacula-restore")
-    command = "echo \"restore client=\\\"#{host.name}\\\" jobid=#{job_ids.join(',')} where=\\\"#{location}\\\" fileset=\\\"#{file_set_name}\\\" select all done yes\" | #{bconsole}"
+  def restore(job_ids, file_set_name, restore_point, location="/tmp/bacula-restore")
+    command = "echo \"restore client=\\\"#{host.name}\\\" jobid=#{job_ids.join(',')} where=\\\"#{location}\\\" fileset=\\\"#{file_set_name}\\\" before=\\\"#{restore_point}\\\" select all done yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   private
 
   def get_client_file
     file = a_tmpfile
     file.write host.to_bacula_config_array.join("\n")
     file.close
     file
   end
 
   def get_jobs_file
     file = a_tmpfile
     file.write templates.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_schedules_file
     file = a_tmpfile
     file.write templates.map(&:schedule).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_filesets_file
     file = a_tmpfile
     file.write templates.map(&:fileset).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def send_config
     begin
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         client.path,
         ssh_settings[:path] + 'clients/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         jobs.path,
         ssh_settings[:path] + 'jobs/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         schedules.path,
         ssh_settings[:path] + 'schedules/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         filesets.path,
         ssh_settings[:path] + 'filesets/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
     rescue
       return false
     end
     true
   end
 
   def remove_config
     begin
       Net::SSH.start(ssh_settings[:host], ssh_settings[:username],
                      keys: ssh_settings[:key_file]) do |ssh|
         ssh.exec!("rm #{ssh_settings[:path]}*/#{host.name}.conf")
       end
     rescue
       return false
     end
     true
   end
 
   def reload_bacula
     command = "echo \"reload quit\" | #{bconsole}"
     exec_with_timeout(command, 2)
   end
 
   def exec_with_timeout(command, sec)
     begin
       Timeout::timeout(sec) do
         `#{command}`
       end
     rescue
       return false
     end
     true
   end
 
   def bconsole
     "bconsole -c #{Rails.root}/config/bconsole.conf"
   end
 
   def ssh_settings
     @ssh_settings ||= YAML::load(File.open("#{Rails.root}/config/ssh.yml"))[Rails.env].
       symbolize_keys
   end
 
   def a_tmpfile
     file = Tempfile.new(host.name)
     file.chmod(0666)
     file
   end
 
   def log(msg)
     Rails.logger.warn("[BaculaHandler]: #{msg}")
   end
 end