रेल - डेविस - हैंडलिंग - devise_error_messages

Question

मेरे उपयोगकर्ता संपादन पृष्ठ में, निम्नानुसार एक पंक्ति है:

<%= devise_error_messages! %>

समस्या यह है कि यह आउटपुट तरीका उस मानक तरीके से त्रुटि नहीं करता है जो बाकी ऐप करता है:

<% flash.each do |key, value| %>
    <div class="flash <%= key %>"><%= value %></div>
<% end %>

मेरा सवाल यह है कि मुझे दूसरों की तरह काम करने के लिए डेविस एरर मैसेज कैसे मिलता है जो फ्लैश का उपयोग करते हैं।

धन्यवाद।

Comments

कृपया ध्यान दें कि डेविस पहले से ही फ्लैश का उपयोग कर रहा है जैसा कि बाकी ऐप कर रहे हैं। devise_error_messages फ़्लैश संदेशों (अंतिम पृष्ठ से जानकारी) के बारे में नहीं है, बल्कि ActiveRecord सत्यापन मार्गदर्शिकाओं

— क्रिस्टोफर ओजेट

Answer 1

मैं यह जानने की कोशिश कर रहा हूं। मुझे सिर्फ Github https://github.com/plataformatec/devise/issues/issue/504/#comment_574788 पर लॉग इन किया गया यह मुद्दा मिला

जोस कह रहा है कि devise_error_messsages!विधि सिर्फ एक ठूंठ है (हालांकि इसमें कार्यान्वयन भी शामिल है) और हम इसे ओवरराइड / रिप्लेस करने वाले हैं। यह अच्छा होता अगर यह विकी में कहीं बाहर इंगित किया गया होता, यही कारण है कि मुझे लगता है कि हमारे जैसे कुछ लोग हैं जो अनुमान लगा रहे हैं।

इसलिए मैं मॉड्यूल को फिर से खोलने और विधि को फिर से परिभाषित करने की कोशिश कर रहा हूं, प्रभावी रूप से डिफ़ॉल्ट कार्यान्वयन को ओवरराइड कर रहा है। मैं आपको बताता हूँ कि यह कैसे जाता है।

अपडेट करें

हां, यह काम करता है। मैंने app/helpers/devise_helper.rbइसे बनाया और इस तरह से ओवररोड किया:

module DeviseHelper
  def devise_error_messages!
    'KABOOM!'
  end
end

तो यह जानते हुए, मैं त्रुटि संदेशों को प्रदर्शित करने के लिए विधि को संशोधित कर सकता हूं जिस तरह से मैं चाहता हूं।

अपनी मूल समस्या को हल करने में आपकी मदद करने के लिए: यहाँ मूल devise_helper.rbगितुब पर है । एक नज़र डालें कि त्रुटि संदेशों को कैसे ट्रैक किया जा रहा है:

messages = resource.errors.full_messages.map { |msg| content_tag(:li, msg) }.join

आपको शुरू करने में मदद करनी चाहिए। :)

एक और अपडेट

resourceवस्तु वास्तव में मॉडल है कि वसीयत (जाने आंकड़ा) द्वारा किया जा रहा है।

resource.class         #=> User
resource.errors.class  #=> ActiveModel::Error

यह एक उच्च दायरे (संभवतः नियंत्रक से आने वाले) में परिभाषित किया गया प्रतीत होता है, इसलिए इसे विभिन्न स्थानों पर पहुँचा जा सकता है।

अपने हेल्पर में कहीं भी

module DeviseHelper
  def devise_error_messages1!
    resource.errors.full_messages.map { |msg| content_tag(:li, msg) }.join
  end

  def devise_error_messages2!
    resource.errors.full_messages.map { |msg| content_tag(:p, msg) }.join
  end
end

आपकै विचार

<div><%= resource.errors.inspect %></div>

Comments

मैं सिर्फ यह कोशिश की, लेकिन यह काम नहीं करता है। लक्ष्य को आउटपुट के लिए त्रुटि प्राप्त करना है: <% flash.each do | key, value %>

— AnApprentice

@ColdTree नहीं, लक्ष्य यह है कि यह फ्लैश संदेशों की तरह काम करे । मार्कअप को नियंत्रित करने में सक्षम होना एक अच्छा उपाय है।

— बेंजामिन एटकिन

... मुझे नहीं लगता कि यह सवाल का जवाब देता है, हालांकि यह एक अच्छा शोध कार्य है।

— १

Answer 2

नीचे समाधान अब (4.1.1) और रेल्स 4.2.6 के नवीनतम विकास के साथ काम करता है। लेकिन इतना आसान है कि मैं कारण नहीं देखता कि यह अब से 10 साल काम क्यों नहीं करेगा;)

यदि आप अपने त्रुटि संदेशों को रीसायकल करना चाहते हैं और उन्हें अपने ऐप पर समान दिखना चाहते हैं तो मैं कुछ इस तरह की सलाह दूंगा (जिस तरह से मैंने माइकल हार्टल ट्यूटर के साथ सीखा है):

त्रुटि संदेशों के लिए आंशिक बनाएं: layouts/_error_messages.html.erb निम्नलिखित कोड के अंदर रखें (यहां मैं कुछ बूटस्ट्रैप 3 वर्गों का उपयोग करता हूं):

<% if object.errors.any? %>
  <div id="error_explanation">
    <div class="alert alert-danger alert-dismissable">
      <button type="button" class="close" data-dismiss="alert" aria-hidden="true">&times;</button>
      <p><strong>This form contains <%= pluralize(object.errors.count, 'error') %>.</strong></p>
      <ul>
        <% object.errors.full_messages.each do |msg| %>
          <li><%= msg %></li>
        <% end %>
      </ul>
    </div>
  </div>
<% end %>

अब आपके पास कुछ रिसाइकिल होने योग्य है और आप इसे बोर्ड भर में उपयोग कर सकते हैं। मानक वसीयत के बजाय:

<%= devise_error_messages! %>

इसे अपने फॉर्म में इस तरह से कॉल करें:

<%= render 'layouts/error_messages', object: resource %>

आप इसे किसी भी रूप में रख सकते हैं। डेविस संसाधन पास करने के बजाय आप अपने फॉर्म से चर को इस तरह से पास कर सकते हैं:

<%= form_for @post do |f| %>
  <%= render 'layouts/error_messages', object: f.object %>  
  <%= f.text_field :content %>
  <%= f.submit %>
<% end %>

Comments

शायद सबसे अच्छा और सबसे सहज जवाब।

— विक्टर

शांत समाधान। pluralize (object.errors.count, 'त्रुटियों' pluralize को (object.errors.count, हालांकि बदला जाना चाहिए 'त्रुटि'

— mizurnix

इस समाधान में @LukaszMuzyka .. क्या मुझे हटाने की आवश्यकता है: user.rb से मान्य .. ???

— विशाल

@ विशाल - नहीं। उपरोक्त समाधान बस संदेशों को प्रदर्शित करने के लिए अलग-अलग HTML का उपयोग करता है यह डेविस के किसी भी यांत्रिकी को नहीं बदलता है

— लुकाज़ मुज़ेका

@Vishal जब आप डैविस का उपयोग कर रहे हैं तो यह पहले से ही आपके द्वारा उल्लिखित मान्यताओं को बिना किसी अतिरिक्त कोड के कर रहा है। उपरोक्त समाधान केवल डिफ़ॉल्ट डेविस व्यवहार को ओवरराइड करने के लिए है। आपको पहले स्थान पर काम करना होगा। क्या आप सुनिश्चित हैं कि आपने अपने प्रोजेक्ट के साथ वसीयत को एकीकृत करने के निर्देशों का पालन किया है?

— लुकाज़ मुज़ेका

Answer 3

मुझे पता है कि इस प्रश्न को पोस्ट किए जाने के बाद कुछ समय हो गया है, लेकिन मैं सिर्फ उस चीज़ पर टिप्पणी करना चाहता हूं जो मैंने पाया है। जिन दो लोगों ने पहले ही जवाब दे दिया है, वे मेरे लिए बहुत मददगार हैं और मैं सिर्फ योगदान देना चाहता था।

आप पूरे डेविस में देखेंगे कि कॉल का उपयोग कर रहे हैं render_with_scope । मेरा मानना ​​है कि यह वसीयत द्वारा परिभाषित एक विधि है और मूल रूप से वर्तमान गुंजाइश को अगले दृश्य में लागू किया गया है।

यह प्रासंगिक क्यों है? डेविस में आपकी त्रुटियां हैं resource.errors( नहीं @resource.errors )। यदि आप इसे बॉक्स से बाहर का उपयोग करना चाहते हैं, तो बोलना ठीक है।

यदि आप अपना उपयोगकर्ता प्रबंधन व्यवहार बदलना शुरू करते हैं, तो इन त्रुटियों के साथ समस्याएँ उत्पन्न होती हैं। ( redirect_toया के renderबजाय render_with_scope) जोड़कर जहां डेविस पहले से एक नहीं था, आप मूल रूप से त्रुटि संदेश निकाल रहे हैं। यह मेरी राय में संशोधन करने के लिए Devise को अमित्र बनाता है।

मेरा समाधान यही है

# In application.html.erb
<% flash.each do |name, msg| %>

  # New code (allow for flash elements to be arrays)
  <% if msg.class == Array %>
    <% msg.each do |message| %>
      <%= content_tag :div, message, :id => "flash_#{name}" %>
    <% end %>
  <% else %>

    # old code
    <%= content_tag :div, msg, :id => "flash_#{name}" %>

  <% end %> #don't forget the extra end
<% end %>

तथा

# Wherever you want Devise's error messages to be handled like 
# your other error messages
# (in my case, registrations_controller.rb, a custom controller)
flash[:notice] = flash[:notice].to_a.concat resource.errors.full_messages

बाद वाला कोड ब्लॉक डेविस के त्रुटि संदेशों को एक सरणी के रूप में लेता है और इसे flash[:notice]एक सरणी के रूप में जोड़ता है । प्रत्येक संदेश को एक बार में एक लाइन प्रिंट किया जाएगा। अगर मेरे पास समय है, तो मुझे लगता है कि मैं बदलने जा रहा हूं कि कैसे डेविस अपने पूरे ऐप में ऐसा करने के लिए एरर मैसेजेस को हैंडल करता है, क्योंकि दो के बजाय एक एरर मैसेज सिस्टम का होना ज्यादा साफ-सुथरा लगता है।

Comments

इसके लिए बहुत-बहुत धन्यवाद, मैं ऐसा करने की कोशिश के लिए दीवार के खिलाफ अपना सिर पीट रहा था।

— लुकास

यह अब 5 साल बाद है और इस प्रतिक्रिया ने मेरे बेकन को बचा लिया। बहुत बहुत धन्यवाद @ एरिक-हू।

— marcamillion

Answer 4

मैंने इसे इसी तरह YoyoS में हल किया है, app/helpers/devise_helper.rbऔर इसे बनाकर :

module DeviseHelper

  # Hacky way to translate devise error messages into devise flash error messages
  def devise_error_messages!
    if resource.errors.full_messages.any?
        flash.now[:error] = resource.errors.full_messages.join(' & ')
    end
    return ''
  end
end

काम किया!

Answer 5

मैं यहाँ एक नया छोटा टुकड़ा लाना चाहता हूँ:

इसलिए मुझे परिणाम प्राप्त करने का एक आसान तरीका मिला जो "एनएपेंटिसिस" चाहता था।

सबसे पहले, यदि आप डेविस प्लग-इन के भीतर कुछ भी कस्टमाइज़ करना चाहते हैं, तो मैं आपको अत्यधिक सलाह देता हूं कि आप "\ Ruby_repertory \ lib \ ruby ​​\ जवाहरात \ 1.9.1" जवाहरात / डेवीज़-वर्ज़न \ ऐप के नियंत्रकों से कोड को कॉपी करें। | हेल्पर्स | मेलर्स ... "जिस फाइल को आप अपने प्रोजेक्ट में चाहते हैं।

[संपादित करें] या आप अपनी फ़ाइल को "सामान्य" डेविस फ़ाइलों से इनहेरिट कर सकते हैं ... जैसे ... कहते हैं ... आप डेविस / रजिस्ट्रेश_कंट्रोलर.बीआर के भीतर केवल एक फ़ंक्शन को अधिलेखित करना चाहते हैं, आपके उपयोगकर्ता कस्टम की पहली पंक्ति। पंजीकरण नियंत्रक होगा:

class Users::RegistrationsController < Devise::RegistrationsController

[Tool अगस्त २०१३ को संपादित करें] अब डेविस भी नियंत्रकों को उत्पन्न करने के लिए एक उपकरण प्रदान करता है: https://github.com/plataformatec/devise/wiki/Tool:-Generate-and-customize-controllers

तो ... वैसे भी ... मैं पाने के लिए क्या "AnApprentice" सिर्फ यह लिखना चाहता था (एक क्लीनर समाधान के लिए, निम्नलिखित बड़े संपादन देखें):

#/my_project/app/helpers/devise_helper.rb
module DeviseHelper
   def devise_error_messages!
      return "" if resource.errors.empty?

      return resource.errors
   end
end

और, मेरे विचार में, अगली पंक्तियों ने बहुत अच्छा काम किया:

<% devise_error_messages!.each do |key, value| %>
    <div class="flash <%= key %>"><%= key %> <%= value %></div>
<% end %>

खैर ... फिर आप इस तरह की एक विशिष्ट विशेषता के लिए त्रुटियों तक पहुंच सकते हैं:

    #Imagine you want only the first error to show up for the login attribute:
    <%= devise_error_messages![:login].first %> 

और ... प्रति विशेषता दिखाने के लिए केवल एक त्रुटि (पहले पकड़े जाने की) एक छोटी सी चाल:

<% if resource.errors.any? %>
  <% saved_key = "" %>
  <% devise_error_messages!.each do |key, value| %>
    <% if key != saved_key %>
        <div class="flash <%= key %>"><%= key %> <%= value %></div>
    <% end %>
    <% saved_key = key %>
  <% end %>
<% end %>

मुझे पता है कि इस प्रश्न को पोस्ट किए जाने में थोड़ी देर हो गई है, लेकिन मुझे लगता है कि यह बहुत से उपयोगकर्ताओं को वसीयत करने में मदद करेगा :)।

बड़ा संपादन:

जैसा कि मुझे अपने कोड का विस्तार करना पसंद है, इसे क्लीनर बनाना और दूसरों के साथ साझा करना, मैं हाल ही में devise_error_messages को बदलना चाहता था! विधि मेरे विचारों में इसका उपयोग करने के लिए और इसे ऊपर बताए गए ट्रिक को प्रदर्शित करने के लिए।

तो, यहाँ मेरी विधि है:

 def devise_error_messages! 
    html = ""

    return html if resource.errors.empty?

    errors_number = 0 

    html << "<ul class=\"#{resource_name}_errors_list\">"

    saved_key = ""
    resource.errors.each do |key, value|
      if key != saved_key
        html << "<li class=\"#{key} error\"> This #{key} #{value} </li>"
        errors_number += 1
      end
      saved_key = key
    end

    unsolved_errors = pluralize(errors_number, "unsolved error")
    html = "<h2 class=\"#{resource_name}_errors_title\"> You have #{unsolved_errors} </h2>" + html
    html << "</ul>"

    return html.html_safe
 end

यहां कोई बड़ी बात नहीं है, मैंने केवल एक त्रुटि pey विशेषता दिखाने के लिए अपने विचार में लिखे गए कोड का पुन: उपयोग किया है, क्योंकि अक्सर पहला ही एकमात्र प्रासंगिक होता है (जैसे जब उपयोगकर्ता एक आवश्यक फ़ील्ड भूल जाता है)।

मैं उन "अद्वितीय" त्रुटियों की गिनती कर रहा हूं और मैं बहुवचन का उपयोग करके एच 2 एचटीएमएल शीर्षक बना रहा हूं और इसे त्रुटियों की सूची से पहले रखूंगा।

तो अब, मैं "devise_error_messages!" डिफ़ॉल्ट के रूप में और यह बिल्कुल वही प्रस्तुत करता है जो मैं पहले से ही प्रस्तुत कर रहा था।

यदि आप अपने दृश्य में एक विशिष्ट त्रुटि संदेश का उपयोग करना चाहते हैं, तो मैं अब सीधे "resource.errors [: विशेषता] .first" या जो भी उपयोग करने की सलाह देता हूं।

सेया, कुलगर।

Answer 6

मैं रेल 3 में डेविस का उपयोग कर रहा हूं और आपका फ्लैश कोड मेरे द्वारा प्राप्त किए गए समान है। मेरे ऐप में, कोड अपेक्षित रूप से काम करता है; अर्थात मेरे फ़्लैश संदेशों के बाकी हिस्सों के साथ त्रुटि संदेश उत्पन्न होते हैं:

<% flash.each do |name, msg| %>
  <%= content_tag :div, msg, :id => "flash_#{name}" if msg.is_a?(String) %>
<% end %>

इस सटीक कोड को आज़माएं और देखें कि क्या इससे कोई फ़र्क पड़ता है - भिन्न आईडी विशेषता मदद कर सकती है।

Comments

धन्यवाद, लेकिन यह कुछ भी नहीं दिखा रहा है। "<% = devise_error_messages!%>" त्रुटि उत्पन्न करता है। ऊपर कुछ नहीं किया? विचार?

— 15

क्षमायाचना - मैंने केवल आपकी टिप्पणी देखी है। ईमानदार होने के कारण, मैं विचारों से भाग रहा हूं। मुझे लगता है कि आपने अपने ब्राउज़र में स्रोत देखा है और HTML की जाँच की है जो उत्पन्न होता है? बस मामले में कुछ सीएसएस द्वारा छिपाया जा रहा है। क्या आप डेविस के नवीनतम संस्करण का उपयोग कर रहे हैं 1.1.3?

— स्कॉट

Answer 7

मैं इस तक आया और यह अब तक काम कर रहा है। यह फ़्लैश में डेविस संदेश जोड़ता है, इसलिए इसे हमेशा की तरह उपयोग किया जा सकता है। कृपया विचार करें कि मैं रूबी और रेल के लिए नया हूँ ...

class ApplicationController < ActionController::Base
  after_filter :set_devise_flash_messages, :if => :devise_controller?
  ...

  private:

  def set_devise_flash_messages
    if resource.errors.any?
      flash[:error] = flash[:error].to_a.concat resource.errors.full_messages
      flash[:error].uniq!
    end
  end
end

संपादित करें:

क्षमा करें, मैं गार्ड चला रहा था और कुछ अवांछित व्यवहार मौजूद था। चूंकि after_filterइसे प्रतिपादन के बाद कहा जाता है इसलिए यह अपेक्षा के अनुरूप काम नहीं करता है। अगर किसी को पता है कि कार्रवाई के बाद एक विधि को कैसे कॉल किया जाए लेकिन रेंडरिंग से पहले ...

लेकिन आप इसके बजाय कुछ का उपयोग कर सकते हैं:

module ApplicationHelper

  # merge the devise messages with the normal flash messages
  def devise_flash
    if controller.devise_controller? && resource.errors.any?
      flash.now[:error] = flash[:error].to_a.concat resource.errors.full_messages
      flash.now[:error].uniq!
    end
  end

end

में views/shared/_messages.html.erb

<% devise_flash %>
<!-- then display your flash messages as before -->

Comments

+1 महान जवाब। मुझे लगता है कि यह निश्चित रूप से सबसे साफ समाधान है और मेरी वर्तमान वास्तुकला में अच्छी तरह से फिट बैठता है। हालांकि यह उत्तर इतना स्पष्ट नहीं है - मूल रूप से संपादन से पहले सब कुछ अनदेखा किया जाना चाहिए (और imo के माध्यम से हटा दिया गया या मारा गया)।

— zelanix

Answer 8

यदि आप किसी दिए गए प्रकार (: सतर्क, सूचना, आदि ...) के एक से अधिक फ्लैश को प्रदर्शित करने में सक्षम होना चाहते हैं और अपना समय बर्बाद नहीं कर रहे हैं तो एक रत्न व्यवहार को संशोधित करने की कोशिश कर रहे हैं, यह वह उपाय है जिसका मैंने डेविस के साथ उपयोग किया है। मुझे पूरा यकीन है कि इसका उपयोग किसी भी मणि के साथ किया जा सकता है जो फ़्लैश संदेशों का उपयोग करता है।

पहली बात, अपने application_controller.rb में, इसे जोड़ें:

  # Adds the posibility to have more than one flash of a given type
  def flash_message(type, text)
    flash[type] ||= []
    flash[type] << text
  end

दूसरी बात यह है कि, इसके साथ अपने फ़्लैश संदेशों को application.html.erb (या जहाँ भी आप चाहते हैं) में प्रदर्शित करें:

   <div class="flashes">
      <% flash.each do |key, messages| %>
        <% messages = Array(messages) unless messages.is_a?(Array) %>
        <% messages.each do |message| %>
        <div class="alert alert-<%= key %>">
          <%= message %>
        </div>
        <% end %>
      <% end %>
    </div>

तीसरी बात, जब भी आप किसी कंट्रोलर में फ्लैश मैसेज जोड़ना चाहते हैं, यह करें:

flash_message(:success, "The user XYZ has been created successfully.")

Comments

लेकिन कैसे एक त्रुटि वस्तु रखने के बजाय flash_messages को कॉल करने के लिए डेविस संदेश प्राप्त करने के लिए।

— क्रिस्टोफर Oezbek

Answer 9

DeviseHelper बनाएं:

module DeviseHelper
  def devise_error_messages!
    return "" if resource.errors.empty?

    messages = resource.errors.full_messages.map { |msg| content_tag(:li, msg)}.join
    return flash.now[:alert] = messages.html_safe
  end
end

आपके विचार में, स्थानापन्न

<%= devise_error_messages! %>

सेवा:

<% devise_error_messages! %>

Comments

असल में, आप का उपयोग करना चाहिए: flash.now [: सतर्क]

— BM

Answer 10

निश्चित रूप से, थोड़ा सा हैकी, लेकिन मैं इस हेल्पर (ऐप / हेल्पर्स / devise_helper.rb) का उपयोग फ्लैश को हड़पने के लिए कर रहा हूं और यदि सेट करता है तो डिफ़ॉल्ट रूप से उपयोग करने के लिए resource.errors। यह सिर्फ उस सहायक पर आधारित है जो कि वसीयत में है।

module DeviseHelper

  def devise_error_messages!
    flash_alerts = []
    error_key = 'errors.messages.not_saved'

    if !flash.empty?
      flash_alerts.push(flash[:error]) if flash[:error]
      flash_alerts.push(flash[:alert]) if flash[:alert]
      flash_alerts.push(flash[:notice]) if flash[:notice]
      error_key = 'devise.failure.invalid'
    end

    return "" if resource.errors.empty? && flash_alerts.empty?
    errors = resource.errors.empty? ? flash_alerts : resource.errors.full_messages

    messages = errors.map { |msg| content_tag(:li, msg) }.join
    sentence = I18n.t(error_key, :count    => errors.count,
                                 :resource => resource.class.model_name.human.downcase)

    html = <<-HTML
    <div id="error_explanation">
      <h2>#{sentence}</h2>
      <ul>#{messages}</ul>
    </div>
    HTML

    html.html_safe
  end

end

Answer 11

यदि आप devise_error_messages को बंद करने के लिए देख रहे हैं, तो आप resource.errors को जोड़कर ऐसा कर सकते हैं

यदि आप पंजीकरण नियंत्रक की सवारी करना चाहते हैं, तो ऐसा लग सकता है

def create
  if validation_or_other_check_passes
    super
  else
    build_resource
    clean_up_passwords(resource)
    resource.errors.add(:notice, "The check failed.")
    render :new 

Answer 12

प्रत्येक क्षेत्र के लिए त्रुटि संदेश प्रदर्शित करने का बहुत आसान तरीका

<%= resource.errors.messages[:email].join(" ") %>

प्रत्येक पंक्ति के नीचे वर्ग ब्रैकेट में फ़ील्ड नाम के साथ प्रत्येक फ़ील्ड के लिए रखें जहाँ आप इनलाइन त्रुटि संदेश प्रदर्शित करना चाहते हैं।

Answer 13

दिखाने के लिए केवल पहली त्रुटि के साथ अपने नियंत्रक से अपनी त्रुटि को दिखाने के लिए।

flash[:error] = @resource.errors.full_messages.first

Answer 14

बस एरिक हू के जवाब में ऊपर जोड़ने के लिए जहां सभी इफ स्टेटमेंट का उपयोग किया जाता है, बल्कि इसके बजाय ऐसा कुछ करें।

# Controller
flash.now[:error] = flash[:error].to_a.concat(resource.errors.full_messages)

# View
<% flash.each do |name, msg| %>
 <% Array(msg).uniq.each do |message| %>
  <%= message %>
 <% end %>
<% end %>

Answer 15

मैं बस यह करता हूं, मेरे लिए काम किया: ऐप / हेल्पर्स / में , मैं एक फ़ाइल devise_helper.rb बनाता हूं

  module DeviseHelper

  def devise_error_messages_for(resource)
    return "" if resource.errors.empty?

    messages = resource.errors.full_messages.map { |msg| content_tag(:li, msg) }.join
    sentence = I18n.t("errors.messages.not_saved",
                      count: resource.errors.count,
                      resource: resource.class.model_name.human.downcase)

    html = <<-HTML
    <div id="error_explanation">
      <h2>#{sentence}</h2>
      <ul>#{messages}</ul>
    </div>
    HTML

    html.html_safe
  end
end

सभी दृश्य फ़ाइलों में मैं बदल जाता हूं

<%= devise_error_messages! %>

के लिये:

<%= devise_error_messages_for(#your object in your formular)%>

मेरे लिए यह मेरे विचार संपादित करें और नए उपयोगकर्ता में करें:

  <%=form_for resource, as: @user, url: user_path(@user),...
      <%= devise_error_messages_for(@user) %>

आशा है इससे आपकी मदद होगी ;)

Comments

मैं वास्तव में यह कैसे करता है कुछ भी समझ में नहीं आता? यह मानक व्यवहार है? यह करने का सिर्फ एक और तरीका है <%= devise_error_messages! %>और इस सवाल का जवाब नहीं है। सवाल पूछता है कि प्रत्येक संदेश में फ्लैश कैसे लागू किया जाए।

— मार्क

Answer 16

1. "Devise_error_messages निकालें!" "एप्लिकेशन / विचारों / उपयोगकर्ताओं / पासवर्ड / नए" टेम्पलेट से।
2. अपने उपयोगकर्ता (ऐप / कंट्रोलर / उपयोगकर्ता / पासवर्ड_कंट्रोलर .rb) के लिए कस्टम कंट्रोलर बनाएँ और फ़िल्टर करने के बाद एरर फ्लैश करें आदि।

class Users::PasswordsController < Devise::PasswordsController
  after_filter :flash_errors

  def flash_errors
    unless resource.errors.empty?
      flash[:error] = resource.errors.full_messages.join(", ")
    end
  end
end

Answer 17

मैं इसे वैसे ही करना पसंद करता हूं जैसे कि इस धोखा के साथ अन्य डेविस कंट्रोलर में किया जाता है।

<% if flash.count > 0 %>
  <div id="error_explanation">
    <h2>Errors prevented you from logging in</h2>
      <ul>
        <% flash.each do |name, msg| %>
        <li>
          <%= content_tag :div, msg, id: "flash_#{name}" %>
        </li>
       <% end %>
     </ul>
   </div>
<% end %>

Answer 18

मटेरिसेक के लिए डेस्ट एरर मैसेज को टोस्ट के रूप में प्रदर्शित करने के लिए मैंने इस कोड को ऐप / हेल्पर्स / devise_helper.rb में जोड़ा।

module DeviseHelper
  def devise_error_messages!

    messages = resource.errors.full_messages.map { |msg|
      String.new(" M.toast({html: '" + msg + "' }); ".html_safe )
    }.join

    messages = ("<script>" + messages + "</script>").html_safe
  end 
end

मुझे यकीन है कि यह लिखने का उनका सबसे साफ तरीका होगा लेकिन यह पूरी तरह से सही है

Answer 19

DeviseHelper#devise_error_messages! हटा दिया गया है और अगले प्रमुख संस्करण में हटा दिया जाएगा।

devise/shared/error_messagesडिफ़ॉल्ट रूप से त्रुटि संदेशों को प्रदर्शित करने के लिए डेविस अब एक आंशिक का उपयोग करता है , और उन्हें अनुकूलित करना आसान बनाता है। अपने विचारों को कॉल बदलने से अपडेट करें:

      <%= devise_error_messages! %>

सेवा:

      <%= render "devise/shared/error_messages", resource: resource %>

Answer 20

मैंने सिर्फ एक app/helpers/devise_helper.rbजॉन की तरह बनाया है , लेकिन उस तरह की विधि को ओवररोड करें:

module DeviseHelper
  def devise_error_messages!
    flash[:error] = resource.errors.full_messages.join('<br />')
    return ''
  end
end

इसके साथ मुझे कुछ और संशोधित करने की आवश्यकता नहीं है। क्या यह एक बुरा विचार है? मैं रेल के लिए नया हूं, मुझे सुधारने में संकोच न करें। धन्यवाद।

Comments

यह वांछित फ़्लैश संदेश के रूप में काम नहीं करेगा जिसमें अब html टैग शामिल है। आम तौर पर आप केवल अपने फ्लैश संदेश में स्ट्रिंग डालते हैं।

— अज।

शायद, लेकिन नई लाइन अभी भी काम करती है। यदि आपको यह पसंद नहीं है तो एक और समाधान का प्रस्ताव करें।

— योयोस

Answer 21

मैंने सिर्फ devise_error_messages घोषित किया है! एक खाली सहायक के रूप में। और अपने आवेदन के लिए आंशिक रूप से एक सामान्य _errors में त्रुटियों को मैन्युअल रूप से लाया और संभाला। सबसे सरल समाधान की तरह लगता है और मुझे डैविस की सभी फाइलों से गुजरना नहीं पड़ता है और त्रुटि हैंडलर को कॉल को हटाना पड़ता है।