devise_token_auth 0.1.1 → 1.3.0

data/app/models/devise_token_auth/concerns/user.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module DeviseTokenAuth::Concerns::User
+  extend ActiveSupport::Concern
+
+  def self.tokens_match?(token_hash, token)
+    @token_equality_cache ||= {}
+
+    key = "#{token_hash}/#{token}"
+    result = @token_equality_cache[key] ||= DeviseTokenAuth::TokenFactory.token_hash_is_token?(token_hash, token)
+    @token_equality_cache = {} if @token_equality_cache.size > 10000
+    result
+  end
+
+  included do
+    # Hack to check if devise is already enabled
+    if method_defined?(:devise_modules)
+      devise_modules.delete(:omniauthable)
+    else
+      devise :database_authenticatable, :registerable,
+             :recoverable, :validatable, :confirmable
+    end
+
+    if const_defined?('ActiveRecord') && ancestors.include?(ActiveRecord::Base)
+      include DeviseTokenAuth::Concerns::ActiveRecordSupport
+    end
+
+    if const_defined?('Mongoid') && ancestors.include?(Mongoid::Document)
+      include DeviseTokenAuth::Concerns::MongoidSupport
+    end
+
+    if DeviseTokenAuth.default_callbacks
+      include DeviseTokenAuth::Concerns::UserOmniauthCallbacks
+    end
+
+    # get rid of dead tokens
+    before_save :destroy_expired_tokens
+
+    # remove old tokens if password has changed
+    before_save :remove_tokens_after_password_reset
+
+    # don't use default devise email validation
+    def email_required?; false; end
+    def devise_will_save_change_to_email?; false; end
+
+    if DeviseTokenAuth.send_confirmation_email && devise_modules.include?(:confirmable)
+      include DeviseTokenAuth::Concerns::ConfirmableSupport
+    end
+
+    def password_required?
+      return false unless provider == 'email'
+      super
+    end
+
+    # override devise method to include additional info as opts hash
+    def send_confirmation_instructions(opts = {})
+      generate_confirmation_token! unless @raw_confirmation_token
+
+      # fall back to "default" config name
+      opts[:client_config] ||= 'default'
+      opts[:to] = unconfirmed_email if pending_reconfirmation?
+      opts[:redirect_url] ||= DeviseTokenAuth.default_confirm_success_url
+
+      send_devise_notification(:confirmation_instructions, @raw_confirmation_token, opts)
+    end
+
+    # override devise method to include additional info as opts hash
+    def send_reset_password_instructions(opts = {})
+      token = set_reset_password_token
+
+      # fall back to "default" config name
+      opts[:client_config] ||= 'default'
+
+      send_devise_notification(:reset_password_instructions, token, opts)
+      token
+    end
+
+    # override devise method to include additional info as opts hash
+    def send_unlock_instructions(opts = {})
+      raw, enc = Devise.token_generator.generate(self.class, :unlock_token)
+      self.unlock_token = enc
+      save(validate: false)
+
+      # fall back to "default" config name
+      opts[:client_config] ||= 'default'
+
+      send_devise_notification(:unlock_instructions, raw, opts)
+      raw
+    end
+
+    def create_token(client: nil, lifespan: nil, cost: nil, **token_extras)
+      token = DeviseTokenAuth::TokenFactory.create(client: client, lifespan: lifespan, cost: cost)
+
+      tokens[token.client] = {
+        token:  token.token_hash,
+        expiry: token.expiry
+      }.merge!(token_extras)
+
+      clean_old_tokens
+
+      token
+    end
+  end
+
+  def valid_token?(token, client = 'default')
+    return false unless tokens[client]
+    return true if token_is_current?(token, client)
+    return true if token_can_be_reused?(token, client)
+
+    # return false if none of the above conditions are met
+    false
+  end
+
+  # this must be done from the controller so that additional params
+  # can be passed on from the client
+  def send_confirmation_notification?; false; end
+
+  def token_is_current?(token, client)
+    # ghetto HashWithIndifferentAccess
+    expiry     = tokens[client]['expiry'] || tokens[client][:expiry]
+    token_hash = tokens[client]['token'] || tokens[client][:token]
+    previous_token_hash = tokens[client]['previous_token'] || tokens[client][:previous_token]
+
+    return true if (
+      # ensure that expiry and token are set
+      expiry && token &&
+
+      # ensure that the token has not yet expired
+      DateTime.strptime(expiry.to_s, '%s') > Time.zone.now &&
+
+      # ensure that the token is valid
+      (
+        # check if the latest token matches
+        does_token_match?(token_hash, token) ||
+
+        # check if the previous token matches
+        does_token_match?(previous_token_hash, token)
+      )
+    )
+  end
+
+  # check if the hash of received token matches the stored token
+  def does_token_match?(token_hash, token)
+    return false if token_hash.nil?
+
+    DeviseTokenAuth::Concerns::User.tokens_match?(token_hash, token)
+  end
+
+  # allow batch requests to use the last token
+  def token_can_be_reused?(token, client)
+    # ghetto HashWithIndifferentAccess
+    updated_at = tokens[client]['updated_at'] || tokens[client][:updated_at]
+    last_token_hash = tokens[client]['last_token'] || tokens[client][:last_token]
+
+    return true if (
+      # ensure that the last token and its creation time exist
+      updated_at && last_token_hash &&
+
+      # ensure that last token falls within the batch buffer throttle time of the last request
+      updated_at.to_time > Time.zone.now - DeviseTokenAuth.batch_request_buffer_throttle &&
+
+      # ensure that the token is valid
+      DeviseTokenAuth::TokenFactory.token_hash_is_token?(last_token_hash, token)
+    )
+  end
+
+  # update user's auth token (should happen on each request)
+  def create_new_auth_token(client = nil)
+    now = Time.zone.now
+
+    token = create_token(
+      client: client,
+      previous_token: tokens.fetch(client, {})['token'],
+      last_token: tokens.fetch(client, {})['previous_token'],
+      updated_at: now
+    )
+
+    update_auth_headers(token.token, token.client)
+  end
+
+  def build_auth_headers(token, client = 'default')
+    # client may use expiry to prevent validation request if expired
+    # must be cast as string or headers will break
+    expiry = tokens[client]['expiry'] || tokens[client][:expiry]
+    headers = {
+      DeviseTokenAuth.headers_names[:"access-token"] => token,
+      DeviseTokenAuth.headers_names[:"token-type"]   => 'Bearer',
+      DeviseTokenAuth.headers_names[:"client"]       => client,
+      DeviseTokenAuth.headers_names[:"expiry"]       => expiry.to_s,
+      DeviseTokenAuth.headers_names[:"uid"]          => uid
+    }
+    headers.merge(build_bearer_token(headers))
+  end
+
+  def build_bearer_token(auth)
+    return {} if DeviseTokenAuth.cookie_enabled # There is no need for the bearer token if it is using cookies
+
+    encoded_token = Base64.strict_encode64(auth.to_json)
+    bearer_token = "Bearer #{encoded_token}"
+    { DeviseTokenAuth.headers_names[:"authorization"] => bearer_token }
+  end
+
+  def update_auth_headers(token, client = 'default')
+    headers = build_auth_headers(token, client)
+    clean_old_tokens
+    save!
+
+    headers
+  end
+
+  def build_auth_url(base_url, args)
+    args[:uid]    = uid
+    args[:expiry] = tokens[args[:client_id]]['expiry']
+
+    DeviseTokenAuth::Url.generate(base_url, args)
+  end
+
+  def extend_batch_buffer(token, client)
+    tokens[client]['updated_at'] = Time.zone.now
+    update_auth_headers(token, client)
+  end
+
+  def confirmed?
+    devise_modules.exclude?(:confirmable) || super
+  end
+
+  def token_validation_response
+    as_json(except: %i[tokens created_at updated_at])
+  end
+
+  protected
+
+  def destroy_expired_tokens
+    if tokens
+      tokens.delete_if do |cid, v|
+        expiry = v[:expiry] || v['expiry']
+        DateTime.strptime(expiry.to_s, '%s') < Time.zone.now
+      end
+    end
+  end
+
+  def should_remove_tokens_after_password_reset?
+    DeviseTokenAuth.remove_tokens_after_password_reset &&
+      (respond_to?(:encrypted_password_changed?) && encrypted_password_changed?)
+  end
+
+  def remove_tokens_after_password_reset
+    return unless should_remove_tokens_after_password_reset?
+
+    if tokens.present? && tokens.many?
+      client, token_data = tokens.max_by { |cid, v| v[:expiry] || v['expiry'] }
+      self.tokens = { client => token_data }
+    end
+  end
+
+  def max_client_tokens_exceeded?
+    tokens.length > DeviseTokenAuth.max_number_of_devices
+  end
+
+  def clean_old_tokens
+    return if tokens.blank? || !max_client_tokens_exceeded?
+
+    # First, remove any tokens with expiry greater than current max allowed lifespan
+    #   this handles the case where token lifespan was reduced and old tokens exist.
+    #   The threshold MUST be computed the same way TokenFactory.expiry writes
+    #   expiries — calendar advance (Time.zone.now + lifespan) — otherwise a
+    #   calendar Duration (e.g. 2.months) and its average-seconds form
+    #   (token_lifespan.to_i) disagree by hours, and the freshly minted token
+    #   gets purged out from under the response.
+    max_lifespan_expiry = (Time.zone.now + DeviseTokenAuth.token_lifespan).to_i
+    tokens_to_keep = tokens.select do |_cid, v|
+      expiry = (v[:expiry] || v['expiry']).to_i
+      expiry <= max_lifespan_expiry
+    end
+
+    # Using Enumerable#sort_by on a Hash will typecast it into an associative
+    #   Array (i.e. an Array of key-value Array pairs). However, since Hashes
+    #   have an internal order in Ruby 1.9+, the resulting sorted associative
+    #   Array can be converted back into a Hash, while maintaining the sorted
+    #   order.
+    self.tokens = tokens_to_keep.sort_by { |_cid, v| v[:expiry] || v['expiry'] }.to_h
+
+    # Since the tokens are sorted by expiry, shift the oldest client token
+    #   off the Hash until it no longer exceeds the maximum number of clients
+    tokens.shift while max_client_tokens_exceeded?
+  end
+end

data/app/models/devise_token_auth/concerns/user_omniauth_callbacks.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DeviseTokenAuth::Concerns::UserOmniauthCallbacks
+  extend ActiveSupport::Concern
+
+  included do
+    validates :email, presence: true, if: lambda { uid_and_provider_defined? && email_provider? }
+    validates :email, :devise_token_auth_email => true, allow_nil: true, allow_blank: true, if: lambda { uid_and_provider_defined? && email_provider? }
+    validates_presence_of :uid, if: lambda { uid_and_provider_defined? && !email_provider? }
+
+    # only validate unique emails among email registration users
+    validates :email, uniqueness: { case_sensitive: false, scope: :provider }, on: :create, if: lambda { uid_and_provider_defined? && email_provider? }
+
+    # keep uid in sync with email
+    before_save :sync_uid
+    before_create :sync_uid
+  end
+
+  protected
+
+  def uid_and_provider_defined?
+    defined?(provider) && defined?(uid)
+  end
+
+  def email_provider?
+    provider == 'email'
+  end
+
+  def sync_uid
+    unless self.new_record?
+      return if devise_modules.include?(:confirmable) && !@bypass_confirmation_postpone && postpone_email_change?
+    end
+    self.uid = email if uid_and_provider_defined? && email_provider?
+  end
+end

data/app/validators/devise_token_auth_email_validator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class DeviseTokenAuthEmailValidator < ActiveModel::EachValidator
+  EMAIL_REGEXP = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+
+  class << self
+    def validate?(email)
+      email =~ EMAIL_REGEXP
+    end
+  end
+
+  def validate_each(record, attribute, value)
+    unless DeviseTokenAuthEmailValidator.validate?(value)
+      record.errors.add(attribute, email_invalid_message)
+    end
+  end
+
+  private
+
+  def email_invalid_message
+    # Try strictly set message:
+    message = options[:message]
+
+    if message.nil?
+      # Try DeviceTokenAuth translations or fallback to ActiveModel translations
+      message = I18n.t(:'errors.messages.not_email', default: :'errors.messages.invalid')
+    end
+
+    message
+  end
+end

data/app/views/devise/mailer/confirmation_instructions.html.erb

@@ -0,0 +1,5 @@
+<p><%= t(:welcome).capitalize + ' ' + @email %>!</p>
+
+<p><%= t '.confirm_link_msg' %> </p>
+
+<p><%= link_to t('.confirm_account_link'), confirmation_url(@resource, {confirmation_token: @token, config: message['client-config'].to_s, redirect_url: message['redirect-url']}).html_safe %></p>

data/app/views/devise/mailer/reset_password_instructions.html.erb

@@ -0,0 +1,8 @@
+<p><%= t(:hello).capitalize %> <%= @resource.email %>!</p>
+
+<p><%= t '.request_reset_link_msg' %></p>
+
+<p><%= link_to t('.password_change_link'), edit_password_url(@resource, reset_password_token: @token, config: message['client-config'].to_s, redirect_url: message['redirect-url'].to_s).html_safe %></p>
+
+<p><%= t '.ignore_mail_msg' %></p>
+<p><%= t '.no_changes_msg' %></p>

data/app/views/devise/mailer/unlock_instructions.html.erb

@@ -0,0 +1,7 @@
+<p><%= t :hello %> <%= @resource.email %>!</p>
+
+<p><%= t '.account_lock_msg' %></p>
+
+<p><%= t '.unlock_link_msg' %></p>
+
+<p><%= link_to t('.unlock_link'), unlock_url(@resource, unlock_token: @token, config: message['client-config'].to_s) %></p>

data/app/views/devise_token_auth/omniauth_external_window.html.erb

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+      /*
+        The data is accessible in two ways:
+
+        1. Using the postMessage api, this window will respond to a
+            'message' event with a post of all the data. (This can
+            be used by browsers other than IE if this window was
+            opened with window.open())
+        2. This window has a function called requestCredentials which,
+            when called, will return the data. (This can be
+            used if this window was opened in an inAppBrowser using
+            Cordova / PhoneGap)
+      */
+
+      var data = JSON.parse(decodeURIComponent('<%= ERB::Util.url_encode( @data.to_json ) %>'));
+
+      window.addEventListener("message", function(ev) {
+        if (ev.data === "requestCredentials") {
+          ev.source.postMessage(data, '*');
+          window.close();
+        }
+      });
+      function requestCredentials() {
+        return data;
+      }
+      setTimeout(function() {
+        document.getElementById('text').innerHTML = (data && data.error) || 'Redirecting...';
+      }, 1000);
+    </script>
+  </head>
+  <body>
+    <pre id="text">
+    </pre>
+  </body>
+</html>

data/config/locales/da-DK.yml

@@ -0,0 +1,52 @@
+da-DK:
+  devise_token_auth:
+    sessions:
+      not_confirmed: "Der er sendt en bekræftelsesemail til din konto på '%{email}'. Følg venligst instruktionerne i emailen for at aktivere din konto."
+      bad_credentials: "Ugyldig kombination af brugernavn og kodeord. Prøv venligst igen."
+      not_supported: "Brug POST /sign_in for at logge ind. GET er ikke supporteret."
+      user_not_found: "Brugeren er ikke fundet eller er ikke logget ind."
+    token_validations:
+      invalid: "Ugyldige legitimationsoplysninger."
+    registrations:
+      missing_confirm_success_url: "Der mangler et 'confirm_success_url' parameter."
+      redirect_url_not_allowed: "Omdirigering til '%{redirect_url}' er ikke tilladt."
+      email_already_exists: "Der eksisterer allerede en konto med '%{email}'"
+      account_with_uid_destroyed: "Kontoen med UID '%{uid}' er slettet."
+      account_to_destroy_not_found: "Kan ikke finde kontoen som skal slettes."
+      user_not_found: "Brugeren ikke fundet."
+    omniauth:
+      not_allowed_redirect_url: "Omdirigering til '%{redirect_url}' er ikke tilladt."
+    passwords:
+      missing_email: "Du skal udfylde email feltet."
+      missing_redirect_url: "Der er ingen omdirigeringsadresse."
+      redirect_url_not_allowed: "Omdirigering til '%{redirect_url}' er ikke tilladt."
+      sended: "En email er blevet sendt til '%{email}' med instruktioner for at nulstille dit kodeord."
+      user_not_found: "Kan ikke finde en bruger med '%{email}'."
+      password_not_required: "Denne bruger kræver ikke et kodeord. Log ind med '%{provider}' konto i stedet."
+      missing_passwords: "Du skal udfylde både kodeord og bekræftelse af kodeord."
+      successfully_updated: "Dit kodeord er opdateret."
+    unlocks:
+      missing_email: "Du skal udfylde en email."
+      sended: "En email er blevet sendt til '%{email}', som indeholder instruktioner for at låse kontoen op."
+      user_not_found: "Kan ikke finde en bruger med email '%{email}'."
+  errors:
+    messages:
+      validate_sign_up_params: "Angiv venligst passende registeringsdata i request body."
+      validate_account_update_params: "Angiv venligst en passende konto opdatering i request body."
+      not_email: "er ikke en email"
+  devise:
+    mailer:
+      confirmation_instructions:
+        confirm_link_msg: "Du kan bekræfte din kontos email gennem linket herunder:"
+        confirm_account_link: "Bekræft min konto"
+      reset_password_instructions:
+        request_reset_link_msg: "Nogen har anmodet om et link til at ændre dit kodeord. Det kan du gøre via linket nedenfor."
+        password_change_link: "Skift mit kodeord."
+        ignore_mail_msg: "Hvis du ikke anmodede om dette, ignorer venligst denne email."
+        no_changes_msg: "Dit kodeord ændres først når du følger linket ovenfor og skaber et nyt."
+      unlock_instructions:
+        account_lock_msg: "Din konto er blevet låst fordi der har været for mange ugyldige log ind-forsøg."
+        unlock_link_msg: "Klik linket nedenfor, for at låse din konto op:"
+        unlock_link: "Lås min konto op"
+  hello: "hej"
+  welcome: "velkommen"

data/config/locales/de.yml

@@ -0,0 +1,51 @@
+de:
+  devise_token_auth:
+    sessions:
+      not_confirmed: "Eine Bestätigungs-E-Mail wurde an Ihre Adresse '%{email}' gesendet. Sie müssen der Anleitung in der E-Mail folgen, um Ihren Account zu aktivieren."
+      bad_credentials: "Ungültige Anmeldeinformationen. Bitte versuchen Sie es erneut."
+      not_supported: "Verwenden Sie POST /sign_in zur Anmeldung. GET wird nicht unterstützt."
+      user_not_found: "Benutzer wurde nicht gefunden oder konnte nicht angemeldet werden."
+    token_validations:
+      invalid: "Ungültige Anmeldeinformationen"
+    registrations:
+      missing_confirm_success_url: "Fehlender Paramter 'confirm_success_url'."
+      redirect_url_not_allowed: "Weiterleitung zu '%{redirect_url}' ist nicht gestattet."
+      email_already_exists: "Es gibt bereits einen Account für '%{email}'."
+      account_with_uid_destroyed: "Account mit der uid '%{uid}' wurde gelöscht."
+      account_to_destroy_not_found: "Der zu löschende Account kann nicht gefunden werden."
+      user_not_found: "Benutzer kann nicht gefunden werden."
+    omniauth:
+      not_allowed_redirect_url: "Weiterleitung zu '%{redirect_url}' ist nicht gestattet."
+    passwords:
+      missing_email: "Sie müssen eine E-Mail-Adresse angeben."
+      missing_redirect_url: "Es fehlt die URL zu Weiterleitung."
+      not_allowed_redirect_url: "Weiterleitung zu '%{redirect_url}' ist nicht gestattet."
+      sended: "Ein E-Mail mit der Anleitung zum Zurücksetzen Ihres Passwortes wurde an '%{email}' gesendet."
+      user_not_found: "Der Benutzer mit der E-Mail-Adresse '%{email}' kann nicht gefunden werden."
+      password_not_required: "Dieser Account benötigt kein Passwort. Melden Sie sich stattdessen über Ihren Account bei '%{provider}' an."
+      missing_passwords: "Sie müssen die Felder 'Passwort' und 'Passwortbestätigung' ausfüllen."
+      successfully_updated: "Ihr Passwort wurde erfolgreich aktualisiert."
+  errors:
+    messages:
+      validate_sign_up_params: "Bitte übermitteln sie vollständige Anmeldeinformationen im Body des Requests."
+      validate_account_update_params: "Bitte übermitteln sie vollständige Informationen zur Aktualisierung im Body des Requests."
+      not_email: "ist keine E-Mail-Adresse"
+  devise:
+    mailer:
+      confirmation_instructions:
+        subject: "Bestätigung Ihres Kontos"
+        confirm_link_msg: "Sie können Ihr Konto über den untenstehenden Link bestätigen:"
+        confirm_account_link: "Konto bestätigen"
+      reset_password_instructions:
+        subject: "Passwort zurücksetzen"
+        request_reset_link_msg: "Jemand hat einen Link zur Änderungen Ihres Passwortes angefordert. Sie können dies durch den folgenden Link tun:"
+        password_change_link: "Passwort ändern"
+        ignore_mail_msg: "Wenn Sie keine Änderung Ihres Passwortes angefordert haben, ignorieren Sie bitte diese E-Mail:"
+        no_changes_msg: "Ihr Passwort wird nicht geändert, bis Sie auf den obigen Link zugreifen und eine neues Passwort erstellen."
+      unlock_instructions:
+        subject: "Anweisungen zum Entsperren Ihres Kontos"
+        account_lock_msg: "Ihr Konto wurde aufgrund einer übermäßigen Anzahl von erfolglosen Anmeldeversuchen gesperrt."
+        unlock_link_msg: "Klicken Sie auf den Link unten, um Ihr Konto zu entsperren:"
+        unlock_link: "Entsperren Sie Ihr Konto"
+  hello: "hallo"
+  welcome: "willkommen"

data/config/locales/en.yml

@@ -0,0 +1,60 @@
+en:
+  devise_token_auth:
+    sessions:
+      not_confirmed: "A confirmation email was sent to your account at '%{email}'. You must follow the instructions in the email before your account can be activated"
+      bad_credentials: "Invalid login credentials. Please try again."
+      not_supported: "Use POST /sign_in to sign in. GET is not supported."
+      user_not_found: "User was not found or was not logged in."
+    token_validations:
+      invalid: "Invalid login credentials"
+    registrations:
+      missing_confirm_success_url: "Missing 'confirm_success_url' parameter."
+      redirect_url_not_allowed: "Redirect to '%{redirect_url}' not allowed."
+      email_already_exists: "An account already exists for '%{email}'"
+      account_with_uid_destroyed: "Account with UID '%{uid}' has been destroyed."
+      account_to_destroy_not_found: "Unable to locate account for destruction."
+      user_not_found: "User not found."
+    omniauth:
+      not_allowed_redirect_url: "Redirect to '%{redirect_url}' not allowed."
+    passwords:
+      missing_email: "You must provide an email address."
+      missing_redirect_url: "Missing redirect URL."
+      not_allowed_redirect_url: "Redirect to '%{redirect_url}' not allowed."
+      sended: "An email has been sent to '%{email}' containing instructions for resetting your password."
+      sended_paranoid: "If your email address exists in our database, you will receive a password recovery link at your email address in a few minutes."
+      user_not_found: "Unable to find user with email '%{email}'."
+      password_not_required: "This account does not require a password. Sign in using your '%{provider}' account instead."
+      missing_passwords: "You must fill out the fields labeled 'Password' and 'Password confirmation'."
+      successfully_updated: "Your password has been successfully updated."
+    unlocks:
+      missing_email: "You must provide an email address."
+      sended: "An email has been sent to '%{email}' containing instructions for unlocking your account."
+      sended_paranoid: "If your account exists, you will receive an email with instructions for how to unlock it in a few minutes."
+      user_not_found: "Unable to find user with email '%{email}'."
+    confirmations:
+      sended: "An email has been sent to '%{email}' containing instructions for confirming your account."
+      sended_paranoid: "If your email address exists in our database, you will receive an email with instructions for how to confirm your email address in a few minutes."
+      user_not_found: "Unable to find user with email '%{email}'."
+      missing_email: "You must provide an email address."
+
+  errors:
+    messages:
+      validate_sign_up_params: "Please submit proper sign up data in request body."
+      validate_account_update_params: "Please submit proper account update data in request body."
+      not_email: "is not an email"
+  devise:
+    mailer:
+      confirmation_instructions:
+        confirm_link_msg: "You can confirm your account email through the link below:"
+        confirm_account_link: "Confirm my account"
+      reset_password_instructions:
+        request_reset_link_msg: "Someone has requested a link to change your password. You can do this through the link below."
+        password_change_link: "Change my password"
+        ignore_mail_msg: "If you didn't request this, please ignore this email."
+        no_changes_msg: "Your password won't change until you access the link above and create a new one."
+      unlock_instructions:
+        account_lock_msg: "Your account has been locked due to an excessive number of unsuccessful sign in attempts."
+        unlock_link_msg: "Click the link below to unlock your account:"
+        unlock_link: "Unlock my account"
+  hello: "hello"
+  welcome: "welcome"

data/config/locales/es.yml

@@ -0,0 +1,51 @@
+es:
+  devise_token_auth:
+    sessions:
+      not_confirmed: "Un correo electrónico de confirmación de su cuenta ha sido enviado a '%{email}'. Por favor, siga las instrucciones para validar su cuenta"
+      bad_credentials: "Identidad o contraseña no válida."
+      not_supported: "Use POST /sign_in para la conexión. GET no esta disponible."
+      user_not_found: "Usuario desconocido o no está conectado."
+    token_validations:
+      invalid: "Identidad o contraseña no válida."
+    registrations:
+      missing_confirm_success_url: "El parámetro 'confirm_success_url' no esta presente."
+      redirect_url_not_allowed: "Redirección hacia '%{redirect_url}' no esta permitida."
+      email_already_exists: "Una cuenta ya existe con este correo electrónico '%{email}'"
+      account_with_uid_destroyed: "La cuenta con el identificador '%{uid}' se ha eliminado."
+      account_to_destroy_not_found: "No se puede encontrar la cuenta a borrar."
+      user_not_found: "Usuario no encontrado."
+    omniauth:
+      not_allowed_redirect_url: "Redirección hacia '%{redirect_url}' no esta permitida."
+    passwords:
+      missing_email: "Debe incluir un correo electrónico."
+      missing_redirect_url: "Falta el Url de redirección."
+      not_allowed_redirect_url: "Redirección hacia '%{redirect_url}' no esta permitida."
+      sended: "Un correo electrónico ha sido enviado a '%{email}' con las instrucciones para restablecer su contraseña."
+      user_not_found: "No se pudo encontrar un usuario con este correo electrónico '%{email}'."
+      password_not_required: "Esta cuenta no requiere contraseña. Iniciar sesión utilizando '%{provider}'."
+      missing_passwords: "Debe llenar los campos 'Contraseña' y 'Confirmación de contraseña'."
+      successfully_updated: "Su contraseña ha sido actualizada con éxito."
+  errors:
+    messages:
+      validate_sign_up_params: "Los datos introducidos en la solicitud de acceso no son válidos."
+      validate_account_update_params: "Los datos introducidos en la solicitud de actualización no son válidos."
+      not_email: "no es un correo electrónico"
+  devise:
+    mailer:
+      confirmation_instructions:
+        subject: "Instrucciones de confirmación"
+        confirm_link_msg: "Para confirmar su cuenta ingrese en el siguiente link:"
+        confirm_account_link: "Confirmar cuenta"
+      reset_password_instructions:
+        subject: "Instrucciones para restablecer su contraseña"
+        request_reset_link_msg: "Ha solicitado un cambio de contraseña. Para continuar ingrese en el siguiente link:"
+        password_change_link: "Cambiar contraseña"
+        ignore_mail_msg: "Por favor ignore este mensaje si no ha solicitado esta acción."
+        no_changes_msg: "Importante: Su contraseña no será actualizada a menos que ingrese en el link."
+      unlock_instructions:
+        subject: "Instrucciones de desbloqueo"
+        account_lock_msg: "Su cuenta ha sido bloqueada debido a sucesivos intentos de ingresos fallidos"
+        unlock_link_msg: "Para desbloquear su cuenta ingrese en el siguiente link:"
+        unlock_link: "Desbloquear cuenta"
+  hello: "hola"
+  welcome: "bienvenido"