क्या मैं Django में टेम्प्लेट से सेटिंग्स में एक्सेस कर सकता हूं?

Question

मेरे पास सेटिंग्स में कुछ सामान है जो मैं एक टेम्पलेट से एक्सेस करने में सक्षम होना चाहता हूं, लेकिन मुझे यह पता नहीं है कि यह कैसे करना है। मैंने पहले ही कोशिश की

{{CONSTANT_NAME}}

लेकिन वह काम नहीं करता है। क्या यह संभव है?

Comments

आप कैसे संदर्भ प्रोसेसर के बारे में bchunn के जवाब में हर जवाब है, देखो के लिए एक सेटिंग पारित करने के लिए के लिए देख रहे हैं

— zags

@Jkbrzt का उत्तर एक पूर्व-पैक समाधान है जो इस समस्या को जल्दी और आसानी से हल करता है। भविष्य पाठकों को इस पर एक नज़र रखना चाहिए stackoverflow.com/a/25841039/396005 स्वीकार किए जाते हैं जवाब से अधिक

— Bron डेविस

Answer 1

Django टेम्पलेट के लिए कुछ, अक्सर उपयोग की जाने वाली सेटिंग कॉन्स्टेंट जैसे कि settings.MEDIA_URLऔर कुछ भाषा सेटिंग्स तक पहुंच प्रदान करता है यदि आप django के जेनेरिक व्यूज का उपयोग करते हैं या render_to_responseशॉर्टकट फ़ंक्शन में संदर्भ उदाहरण कीवर्ड तर्क में पास होते हैं । यहां प्रत्येक मामले का एक उदाहरण दिया गया है:

from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.generic.simple import direct_to_template

def my_generic_view(request, template='my_template.html'):
    return direct_to_template(request, template)

def more_custom_view(request, template='my_template.html'):
    return render_to_response(template, {}, context_instance=RequestContext(request))

इन दृश्यों में कई बार उपयोग की जाने वाली सेटिंग्स होंगी जैसे settings.MEDIA_URLकि टेम्पलेट के लिए उपलब्ध है {{ MEDIA_URL }}, आदि।

यदि आप सेटिंग में अन्य स्थिरांक तक पहुंच की तलाश कर रहे हैं, तो बस उन स्थिरांक को अनपैक करें और उन्हें उस संदर्भ शब्दकोश में जोड़ें जो आप अपने दृश्य फ़ंक्शन में उपयोग कर रहे हैं, जैसे:

from django.conf import settings
from django.shortcuts import render_to_response

def my_view_function(request, template='my_template.html'):
    context = {'favorite_color': settings.FAVORITE_COLOR}
    return render_to_response(template, context)

अब आप settings.FAVORITE_COLORअपने टेम्पलेट पर पहुँच सकते हैं {{ favorite_color }}।

Comments

यह ध्यान देने योग्य है कि RequestContext का उपयोग करके जोड़ा गया विशिष्ट मान TEMPLATE_CONTEXT_PROCESSORS के मान पर निर्भर है। इस प्रकार यदि आप चाहते हैं कि अतिरिक्त मान हर जगह पारित हो जाएं, तो बस अपना स्वयं का संदर्भ प्रोसेसर लिखें और इसे TEMPLATE_CONTEXT_PROFESSORS में जोड़ें।

— कार्ल मेयर

जेनेरिक विचारों, और कई कोर और कंट्रीब ऐप्स में स्थिरता पर एक बिंदु, अतिरिक्त संदर्भ को extra_context कहा जाता है, और बहुत बार यह दृश्य के तर्कों में शामिल होता है।

— सोवियुत

"Django सेटिंग में कुछ निश्चित, अक्सर उपयोग की जाने वाली सेटिंग्स को एक्सेस प्रदान करता है, जैसे settings.MEDIA_URL"। यह Django 1.3 में काम नहीं करता है, हालांकि मैं शायद इसका गलत उपयोग कर रहा हूं। क्या इस सुविधा के लिए कोई दस्तावेज है?

— सिस्टमपारॉक्स

@asofyan हाँ, एक कस्टम टेम्पलेट संदर्भ प्रोसेसर बनाएँ और सेटिंग्स में TEMPLATE_CONTEXT_PROCESSORS जोड़ें।

— पाओलो

पर लग रहे हो django-settings-exportहर दृश्य में इस कोड लिखने की जरूरत से बचने के लिए।

— १

Answer 2

यदि यह एक ऐसा मान है जिसे आप हर अनुरोध और टेम्पलेट के लिए रखना चाहते हैं, तो संदर्भ प्रोसेसर का उपयोग करना अधिक उचित है।

ऐसे:

1. context_processors.pyअपनी ऐप निर्देशिका में एक फ़ाइल बनाएँ । मान लें कि मैं ADMIN_PREFIX_VALUEहर संदर्भ में मूल्य रखना चाहता हूं :

   from django.conf import settings # import the settings file
   
   def admin_media(request):
       # return the value you want as a dictionnary. you may add multiple values in there.
       return {'ADMIN_MEDIA_URL': settings.ADMIN_MEDIA_PREFIX}

2. अपने संदर्भ प्रोसेसर को अपनी सेटिंग्स फ़ाइल में जोड़ें:

   TEMPLATES = [{
       # whatever comes before
       'OPTIONS': {
           'context_processors': [
               # whatever comes before
               "your_app.context_processors.admin_media",
           ],
       }
   }]

3. RequestContextअपने टेम्पलेट में अपने संदर्भ प्रोसेसर को जोड़ने के लिए अपने दृश्य में उपयोग करें । renderशॉर्टकट यह स्वचालित रूप से करता है:

   from django.shortcuts import render
   
   def my_view(request):
       return render(request, "index.html")

4. और अंत में, अपने टेम्पलेट में:

   ...
   <a href="{{ ADMIN_MEDIA_URL }}">path to admin media</a>
   ...

Comments

@MarkEssel ये घेरा बनाया गया है ताकि चर हर उस दृश्य में सुलभ हो जो आप तब तक बना पाएंगे जब तक यह RequestConportxt फ़ंक्शन का उपयोग करता है। आप हमेशा प्रत्येक दृश्य में मैन्युअल रूप से एक सेटिंग चर प्राप्त कर सकते हैं। मैं अच्छे ol 'कॉपी और पेस्ट के बजाय किसी भी समय पुन: प्रयोज्य संदर्भ प्रोसेसर चुनूंगा।

— बछनां २५'१२ बजे १४:०२

हर जगह कॉपी / पेस्ट से बचने की मेरी पूरी कोशिश है। क्या प्रत्येक (प्रत्येक परियोजना के भीतर) एक संदर्भ_प्रोसेसर की आवश्यकता होती है, क्या उन सभी के लिए एक संदर्भ_प्रोसेसर बनाने का कोई तरीका है?

— मार्क एस्सेल

@bchhun मैंने अभी परीक्षण किया है (Django 1.3): ऐप्स के बीच एक संदर्भ प्रोसेसर साझा करना ठीक काम करता है। :-) मैंने context_process.pyअपनी settings.pyफ़ाइल के बगल में रखा और "context_processors.admin_media"अपनी TEMPLATE_CONTEXT_PROCESSORSसूची में जोड़ा । इसके अलावा, आप इस तथ्य के बारे में अपने उत्तर में एक नोट जोड़ना चाह सकते हैं कि TEMPLATE_CONTEXT_PROCESSORS का डिफ़ॉल्ट मान रिक्त नहीं है, इसलिए यदि कोई भी मौजूदा कोड उन डिफ़ॉल्ट संदर्भ प्रोसेसर द्वारा निर्धारित किसी भी मान का उपयोग करता है, तो वे आपके द्वारा उन्हें वापस जोड़ने पर काम नहीं करेंगे। सूची स्पष्ट रूप से

— 18

@MarkEssel बिल्कुल भी दर्दनाक नहीं है - उसने सब कुछ ठीक कर दिया है। यह वास्तव में केवल 6 छोटी लाइनें (चरण 1 और 2) हैं। चरण 3 और 4 या उनके समतुल्य वैसे भी अधिकांश टेम्पलेट्स के लिए आवश्यक हैं।

— रिक वेस्टेरा

Django 1.3 के रूप में, आप अनुरोध कोrender शामिल करने से बचने के लिए शॉर्टकट का उपयोग कर सकते हैं जिसमें RequestContext शामिल है: docs.djangoproject.com/en/1.6/topics/http/shortcuts/#render

— yndolod

Answer 3

मुझे लगता है कि सबसे सरल दृष्टिकोण एक एकल कस्टम टेम्पलेट टैग है :

from django import template
from django.conf import settings

register = template.Library()

# settings value
@register.simple_tag
def settings_value(name):
    return getattr(settings, name, "")

उपयोग:

{% settings_value "LANGUAGE_CODE" %}

Comments

मुझे टेम्पलेट्स में किसी भी सेटिंग में ऑन-डिमांड एक्सेस होना पसंद है, और यह वह सुरुचिपूर्ण ढंग से प्रदान करता है। यह वास्तव में अन्य उत्तरों की तुलना में बहुत बेहतर है यदि आप अक्सर अपने टेम्पलेट्स में विभिन्न सेटिंग्स का उपयोग कर रहे हैं: 1) स्वीकृत उत्तर वर्ग-आधारित विचारों के साथ असंगत या क्लंकी है। 2) ओवर-वोटेड टेम्प्लेट संदर्भ प्रोसेसर समाधान के साथ, आपको व्यक्तिगत सेटिंग्स (या सभी) को निर्दिष्ट करना होगा और यह हर एक अनुरोध के लिए चलेगा जो टेम्पलेट को रेंडर करता है - अक्षम! 3) ऊपर के अधिक जटिल टैग की तुलना में इसका सरल।

— बेन रॉबर्ट्स

@BenRoberts मैं सहमत हूं कि यह एक सुरुचिपूर्ण समाधान है ... लेकिन केवल एक ही डेवलपर के साथ छोटी परियोजनाओं के लिए जो सब कुछ करता है। यदि आपके पास डिजाइन और विकास के लिए अलग-अलग लोग / टीमें हैं, तो यह समाधान संभवतः सबसे खराब है । डिजाइनर को इस टैग को किसी चीज़ के साथ गाली देने से रोकने के लिए क्या है {% settings_value "DATABASES" %}:? इस उपयोग-केस को यह स्पष्ट करना चाहिए कि सेटिंग शुरू करने के लिए टेम्पलेट्स में उपलब्ध क्यों नहीं है।

— मोकिस्टीन

"हम सभी यहां वयस्कों की सहमति दे रहे हैं"

— फर्नहर

मुझे नौसिखिया होने के लिए क्षमा करें। आपने यह कोड कहां रखा है? Views.py? या एक नई फाइल पर?

— नोएल लेवलेरेस

अन्य लोगों के लिए स्पष्ट होने के लिए, आपको इसकी आवश्यकता है: 1) templatetagsअपने एप्लिकेशन के अंदर एक खाली __init__.pyफ़ाइल और इस कोड को settings.pyउस फ़ोल्डर के अंदर एक फ़ोल्डर बनाएं । 2) अपने टेम्पलेट में आप जोड़ते हैं {% load settings %}और फिर अपने नए टैग का उपयोग करते हैं!

— डेमियो

Answer 4

बाहर की जाँच करें django-settings-export(अस्वीकरण: मैं इस परियोजना का लेखक हूँ)।

उदाहरण के लिए...

$ pip install django-settings-export

settings.py

TEMPLATES = [
    {
        'OPTIONS': {
            'context_processors': [
                'django_settings_export.settings_export',
            ],
        },
    },
]

MY_CHEESE = 'Camembert';

SETTINGS_EXPORT = [
    'MY_CHEESE',
]

template.html

<script>var MY_CHEESE = '{{ settings.MY_CHEESE }}';</script>

Comments

और ध्यान दें कि आपके विचार में आपको उपयोग करने की आवश्यकता है renderऔर नहींrender_to_response

— एवरेट टॉस

मुझे टेम्प्लेट्स में सेटिंग से मान पढ़ने की समान आवश्यकता है, लेकिन जब मैं फ़ाइल सेट करने में 'django_settings_export.settings_export' जोड़ता हूं, तो मुझे 500 त्रुटि मिल रही हैं। क्या आप सुझाव देते हैं कि मैं यहां क्या गलत कर रहा हूं

— Sahu

यह 2019 है और मैं इसे अपने प्रोजेक्ट में इस्तेमाल कर रहा हूं। धन्यवाद!

— शिवाबुध

मैं @sivabudh से सहमत हूं। यह मेरे लिए भी सबसे अच्छा समाधान है क्योंकि 1. यह केंद्रीकृत है जिसका अर्थ है कि मुझे अतिरिक्त फ़ोल्डर और फ़ाइलों की आवश्यकता नहीं है, 2. मैं अपने टेम्पलेट में सेटिंग्स नाम स्थान देख सकता हूं जो कई एप्लिकेशन के संदर्भ प्राप्त करने के लिए बहुत सहायक है।

— ywiyogo

Answer 5

ऐसा करने का एक और तरीका कस्टम टेम्पलेट टैग बनाना है जो आपको सेटिंग्स से मछली के मूल्यों को दे सकता है।

@register.tag
def value_from_settings(parser, token):
    try:
        # split_contents() knows not to split quoted strings.
        tag_name, var = token.split_contents()
    except ValueError:
        raise template.TemplateSyntaxError, "%r tag requires a single argument" % token.contents.split()[0]
    return ValueFromSettings(var)

class ValueFromSettings(template.Node):
    def __init__(self, var):
        self.arg = template.Variable(var)
    def render(self, context):        
        return settings.__getattr__(str(self.arg))

आप तब उपयोग कर सकते हैं:

{% value_from_settings "FQDN" %}

संदर्भ-प्रोसेसर हुप्स के माध्यम से कूद के बिना, किसी भी पृष्ठ पर इसे प्रिंट करने के लिए

Comments

मुझे लगता है कि यह सबसे सुरुचिपूर्ण समाधान है, क्योंकि यह कोड बदलने के बिना ड्रॉपिन के रूप में काम करता है।

— फ्लाइंग भेड़ 7

आप अपने शेष आवेदन को अनछुए छोड़ सकते हैं: आप संदर्भ प्रोसेसर जोड़ने के बजाय एक टैग जोड़ते हैं और उसका उपयोग करते हैं (जिसका अर्थ है कि आपको कई स्थानों पर अपने आवेदन को संपादित करना होगा)

— उड़ान भेड़

@Mark - में produi / src / produi / template_utils / templatetags / custom_template_filters.py टेम्पलेट_utils को settings.py INSTALLED_APPS से संदर्भित किया जाता है - यह भी देखें dj.djangoproject.com/en/dev/howo/custom-template-tags

— fadedbee

मदद क्रिस की सराहना करते हैं, custom_template_filters सहित एक templatetags उपनिर्देशिका के साथ एक उत्परिवर्ती एप्लिकेशन जोड़ा। फिर भी होमपेज में त्रुटि हो रही है। "अमान्य ब्लॉक टैग: 'value_from_settings', अपेक्षित 'एंडब्लॉक' या 'एंडब्लॉक बैनर'"

— मार्क एस्सेल

मुझे लगता है कि यह "स्पष्ट रूप से निहित से बेहतर है" के संदर्भ में जाता है, संदर्भ डेकोरेटर संस्करण का उपयोग करके आप बिल्कुल वही चुनते हैं जिसे उजागर करना है।

— 15

Answer 6

मुझे बेरीस्लाव का समाधान पसंद है, क्योंकि साधारण साइटों पर, यह साफ और प्रभावी है। मुझे क्या पसंद नहीं है सभी सेटिंग्स को उजागर कर रहा है विली-नीली। तो मैंने जो किया वह यह था:

from django import template
from django.conf import settings

register = template.Library()

ALLOWABLE_VALUES = ("CONSTANT_NAME_1", "CONSTANT_NAME_2",)

# settings value
@register.simple_tag
def settings_value(name):
    if name in ALLOWABLE_VALUES:
        return getattr(settings, name, '')
    return ''

उपयोग:

{% settings_value "CONSTANT_NAME_1" %}

यह किसी भी स्थिरांक की रक्षा करता है जिसे आपने टेम्पलेट में उपयोग से नाम नहीं दिया है, और यदि आप वास्तव में फैंसी प्राप्त करना चाहते हैं, तो आप सेटिंग्स में एक टपल सेट कर सकते हैं, और विभिन्न पृष्ठों, एप्लिकेशन या क्षेत्रों के लिए एक से अधिक टेम्पलेट टैग बना सकते हैं, और बस आवश्यकतानुसार स्थानीय ट्यूपल के साथ संयोजन करें, फिर सूची को यह समझने के लिए करें कि क्या मूल्य स्वीकार्य है।
मैं सहमत हूं, एक जटिल साइट पर, यह थोड़ा सरल है, लेकिन ऐसे मान हैं जो सार्वभौमिक रूप से टेम्पलेट्स में होना अच्छा होगा, और यह अच्छी तरह से काम करता है। मूल विचार के लिए बेरीस्लाव को धन्यवाद!

Comments

बस क्यों नहींif name in ALLOWABLE_VALUES: ...

— frnhr

क्योंकि मुझे लगा कि मैं चालाक हो रहा था, और उप-स्ट्रिंग्स को सेटिंग्स var को ट्रिगर करने से रोकना चाहता था। ;-) वापसी शायद होनी चाहिए: रिटर्न गेटअटर (सेटिंग्स, is_allowable, '')

— MontyThreeCard

: बस किसी को जो सोच रहा है के लिए स्पष्ट करने के लिए 'val' in ('val_first', 'second_val',)कर रहा है False, कोई यहाँ समस्या सबस्ट्रिंग।

— frnhr

मैं ifबयान में इसका उपयोग कैसे कर सकता हूं ? मैं DEBUGमूल्य की जांच करना चाहता हूं

— एजे

यदि किसी को फिर से शामिल संस्करण के साथ की आवश्यकता होगी gist.github.com/BrnoPCmaniak/632f56ddb907108b3d43fa862510dfca

— फिलिप

Answer 7

मैंने क्रिसड्यू के उत्तर में सुधार किया (अपना टैग बनाने के लिए) थोड़ा सा।

सबसे पहले, वह फ़ाइल बनाएँ yourapp/templatetags/value_from_settings.pyजिसमें आप अपना नया टैग परिभाषित करते हैं value_from_settings:

from django.template import TemplateSyntaxError, Variable, Node, Variable, Library
from yourapp import settings

register = Library()
# I found some tricks in URLNode and url from defaulttags.py:
# https://code.djangoproject.com/browser/django/trunk/django/template/defaulttags.py
@register.tag
def value_from_settings(parser, token):
  bits = token.split_contents()
  if len(bits) < 2:
    raise TemplateSyntaxError("'%s' takes at least one " \
      "argument (settings constant to retrieve)" % bits[0])
  settingsvar = bits[1]
  settingsvar = settingsvar[1:-1] if settingsvar[0] == '"' else settingsvar
  asvar = None
  bits = bits[2:]
  if len(bits) >= 2 and bits[-2] == 'as':
    asvar = bits[-1]
    bits = bits[:-2]
  if len(bits):
    raise TemplateSyntaxError("'value_from_settings' didn't recognise " \
      "the arguments '%s'" % ", ".join(bits))
  return ValueFromSettings(settingsvar, asvar)

class ValueFromSettings(Node):
  def __init__(self, settingsvar, asvar):
    self.arg = Variable(settingsvar)
    self.asvar = asvar
  def render(self, context):
    ret_val = getattr(settings,str(self.arg))
    if self.asvar:
      context[self.asvar] = ret_val
      return ''
    else:
      return ret_val

आप अपने टेम्प्लेट में इस टैग का उपयोग कर सकते हैं:

{% load value_from_settings %}
[...]
{% value_from_settings "FQDN" %}

या के माध्यम से

{% load value_from_settings %}
[...]
{% value_from_settings "FQDN" as my_fqdn %}

as ...अंकन का लाभ यह है कि यह blocktransएक साधारण के माध्यम से ब्लॉकों में उपयोग करना आसान बनाता है {{my_fqdn}}।

Answer 8

Django 2.0+ के साथ इसे हल करने वाले कस्टम टेम्प्लेट टैग बनाने के लिए पूरे निर्देशों के साथ एक उत्तर जोड़ना

अपने ऐप-फोल्डर में, टेम्प्लेटेटैग्स नामक एक फोल्डर बनाएं । इसमें __init__.py और custom_tags.py बनाएँ :

में custom_tags.py कस्टम टैग समारोह है कि में एक मनमाना कुंजी तक पहुँच प्रदान करता बनाने सेटिंग्स निरंतर:

from django import template
from django.conf import settings

register = template.Library()

@register.simple_tag
def get_setting(name):
    return getattr(settings, name, "")

इस कोड को समझने के लिए मैं Django डॉक्स में सरल टैग पर अनुभाग पढ़ने की सलाह देता हूं ।

फिर, आपको Django को इस (और किसी भी अतिरिक्त) कस्टम टैग से इस फ़ाइल को किसी भी टेम्पलेट में लोड करके जागरूक करना होगा जहां आप इसका उपयोग करेंगे। जैसे आपको स्थैतिक टैग में निर्मित लोड करने की आवश्यकता है:

{% load custom_tags %}

इसे लोड करने के साथ ही इसे किसी अन्य टैग की तरह ही इस्तेमाल किया जा सकता है, बस उस विशिष्ट सेटिंग की आपूर्ति करें जिसकी आपको जरूरत है। इसलिए यदि आपकी सेटिंग में BUILD_VERSION वैरिएबल है:

{% get_setting "BUILD_VERSION" %}

यह समाधान सरणियों के साथ काम नहीं करेगा, लेकिन अगर आपको ज़रूरत है कि आप अपने टेम्प्लेट में बहुत तर्क लगा सकते हैं।

नोट: एक अधिक स्वच्छ और विफल समाधान शायद एक कस्टम संदर्भ प्रोसेसर बनाना होगा जहां आप उन सेटिंग्स को जोड़ते हैं जो आपको सभी टेम्पलेट के लिए उपलब्ध संदर्भ में चाहिए। इस तरह आप गलती से अपने टेम्प्लेट में संवेदनशील सेटिंग्स को आउटपुट करने के जोखिम को कम करते हैं।

Answer 9

इस कोड को एक फ़ाइल में जोड़ें context_processors.py:

from django.conf import settings as django_settings


def settings(request):
    return {
        'settings': django_settings,
    }

और फिर, अपनी सेटिंग्स फ़ाइल में, एक पथ इस तरह के रूप में शामिल हैं 'speedy.core.base.context_processors.settings'में (आपके ऐप्लिकेशन नाम और पथ के साथ) 'context_processors'में सेटिंग्स TEMPLATES।

(उदाहरण के लिए आप देख सकते हैं सेटिंग्स / base.py और context_processors.py )।

फिर आप किसी भी टेम्पलेट कोड में विशिष्ट सेटिंग का उपयोग कर सकते हैं। उदाहरण के लिए:

{% if settings.SITE_ID == settings.SPEEDY_MATCH_SITE_ID %}

अपडेट: ऊपर दिया गया कोड आपकी सभी संवेदनशील जानकारी सहित टेम्प्लेट की सभी सेटिंग्स को उजागर करता है SECRET_KEY। एक हैकर टेम्प्लेट में ऐसी जानकारी प्रदर्शित करने के लिए इस सुविधा का दुरुपयोग कर सकता है। यदि आप टेम्प्लेट में केवल विशिष्ट सेटिंग्स को उजागर करना चाहते हैं, तो इस कोड का उपयोग करें:

def settings(request):
    settings_in_templates = {}
    for attr in ["SITE_ID", ...]: # Write here the settings you want to expose to the templates.
        if (hasattr(django_settings, attr)):
            settings_in_templates[attr] = getattr(django_settings, attr)
    return {
        'settings': settings_in_templates,
    }

Comments

मैंने कल इस समस्या को मारा, इस पोस्ट को पाया, फिर 2 अन्य और एक ब्लॉग पोस्ट और महसूस किया कि उनमें से हर एक एक तरह से अत्यधिक जटिल था (दुर्भाग्य से मैंने इसे इस पृष्ठ से दूर नहीं किया, मुझे शर्म आती है)। तो फिर मैं अपना खुद का रोल खत्म कर दिया, जो वास्तव में यह समाधान है। मैं अभी वापस आया क्योंकि यह मुझे परेशान कर रहा था कि लोग ^ ^ ^ ^ 3-लाइन फ़ंक्शन और सेटिंग्स-थ्रू में 1-लाइन परिवर्तन होने पर प्लगइन्स और पूरे लोट्टा कोड की सिफारिश कर रहे थे।

— DXM

@DXM धन्यवाद!

— स्पीडी मैच

वास्तव में मेरा समाधान संवेदनशील जानकारी सहित, टेम्प्लेट की सभी सेटिंग्स को उजागर करता है SECRET_KEY। टेम्प्लेट में ऐसी जानकारी प्रदर्शित करने के लिए कोई हैकर इस सुविधा का दुरुपयोग कर सकता है।

— स्पीडी मैच

मैंने अपना उत्तर अपडेट कर दिया।

— स्पीडी मैच

अच्छा ... महान, अब मेरी वेबसाइट में एक ही समस्या है :) लेकिन ... मुझे कुछ याद आ रहा है, हालांकि, क्या हमें यकीन है कि कोई समस्या है? टेम्पलेट अनिवार्य रूप से आपकी वेबसाइट के स्रोत कोड के समान हैं, क्या वे नहीं हैं? वे फ्रंट-एंड से सीधे सर्वर-साइड और दुर्गम संग्रहीत होते हैं। यदि कोई हैकर टेम्पलेट बदल सकता है, तो उस समय वे किसी भी .py फ़ाइल को बदल सकते हैं।

— DXM

Answer 10

Bchhun से ऊपर का उदाहरण अच्छा है, सिवाय इसके कि आपको सेटिंगफ्रेम से अपना संदर्भ शब्दकोश स्पष्ट रूप से बनाने की आवश्यकता है। नीचे एक उदाहरण दिया गया है कि आप सेटिंग के सभी अपर-केस विशेषताओं से संदर्भ शब्दकोश को ऑटो-कैसे बना सकते हैं (पुनः: "^ [A-Z0-9 _] + $")।

सेटिंग्स के अंत में:

_context = {} 
local_context = locals()
for (k,v) in local_context.items():
    if re.search('^[A-Z0-9_]+$',k):
        _context[k] = str(v)

def settings_context(context):
    return _context

TEMPLATE_CONTEXT_PROCESSORS = (
...
'myproject.settings.settings_context',
...
)

Answer 11

अगर किसी को यह सवाल लगता है जैसे मैंने किया, तो मैं अपना समाधान पोस्ट करूंगा जो कि Django 2.0 पर काम करता है:

यह टैग टेम्प्लेट के वैरिएबल के लिए कुछ सेटिंग्स। चर चर प्रदान करता है:

उपयोग: {% get_settings_value template_var "SETTINGS_VAR" %}

एप्लिकेशन / templatetags / my_custom_tags.py:

from django import template
from django.conf import settings

register = template.Library()

class AssignNode(template.Node):
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def render(self, context):
        context[self.name] = getattr(settings, self.value.resolve(context, True), "")
        return ''

@register.tag('get_settings_value')
def do_assign(parser, token):
    bits = token.split_contents()
    if len(bits) != 3:
        raise template.TemplateSyntaxError("'%s' tag takes two arguments" % bits[0])
    value = parser.compile_filter(bits[2])
    return AssignNode(bits[1], value)

आपका टेम्प्लेट:

{% load my_custom_tags %}

# Set local template variable:
{% get_settings_value settings_debug "DEBUG" %}

# Output settings_debug variable:
{{ settings_debug }}

# Use variable in if statement:
{% if settings_debug %}
... do something ...
{% else %}
... do other stuff ...
{% endif %}

Django के दस्तावेज़ देखें कि यहां कस्टम टेम्पलेट टैग कैसे बनाए जाएं : https://docs.djangoproject.com/en/2.0/howto/custom-template-tags/

Comments

{% if settings_debug %}

— user66081

धन्यवाद @ user66081! बदली गई {% if settings_debug == True %}अपने सुझाव के लिए{% if settings_debug %}

— NullIsNot0

Answer 12

यदि क्लास-आधारित दृश्य का उपयोग कर रहे हैं:

#
# in settings.py
#
YOUR_CUSTOM_SETTING = 'some value'

#
# in views.py
#
from django.conf import settings #for getting settings vars

class YourView(DetailView): #assuming DetailView; whatever though

    # ...

    def get_context_data(self, **kwargs):

        context = super(YourView, self).get_context_data(**kwargs)
        context['YOUR_CUSTOM_SETTING'] = settings.YOUR_CUSTOM_SETTING

        return context

#
# in your_template.html, reference the setting like any other context variable
#
{{ YOUR_CUSTOM_SETTING }}

Answer 13

मुझे यह Django 1.3 के लिए सबसे सरल तरीका लगता है:

1. views.py

   from local_settings import BASE_URL
   
   def root(request):
       return render_to_response('hero.html', {'BASE_URL': BASE_URL})

2. hero.html

   var BASE_URL = '{{ JS_BASE_URL }}';

Answer 14

IANSR और bchhun दोनों ने सेटिंग में TEMPLATE_CONTEXT_PROCESSORS को ओवरराइड करने का सुझाव दिया। ध्यान रखें कि इस सेटिंग में एक डिफ़ॉल्ट है जो कुछ खराब चीजों का कारण बन सकता है यदि आप इसे चूक को फिर से सेट किए बिना ओवरराइड करते हैं। Django के हाल के संस्करणों में चूक भी बदल गए हैं।

https://docs.djangoproject.com/en/1.3/ref/settings/#template-context-processors

डिफ़ॉल्ट TEMPLATE_CONTEXT_PROCESSORS:

TEMPLATE_CONTEXT_PROCESSORS = ("django.contrib.auth.context_processors.auth",
"django.core.context_processors.debug",
"django.core.context_processors.i18n",
"django.core.context_processors.media",
"django.core.context_processors.static",
"django.contrib.messages.context_processors.messages")

Answer 15

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

यदि आप टेम्पलेट टैग विकल्प के साथ जाने का निर्णय लेते हैं, तो निम्न कोड का उपयोग करें क्योंकि यह आपको डिफ़ॉल्ट मान को पास करने की अनुमति देता है, बस मामले में चर-प्रश्न अपरिभाषित था।

उदाहरण: get_from_settings my_variable my_context_value के रूप में

उदाहरण: get_from_settings my_variable my_default as my_context_value

class SettingsAttrNode(Node):
    def __init__(self, variable, default, as_value):
        self.variable = getattr(settings, variable, default)
        self.cxtname = as_value

    def render(self, context):
        context[self.cxtname] = self.variable
        return ''


def get_from_setting(parser, token):
    as_value = variable = default = ''
    bits = token.contents.split()
    if len(bits) == 4 and bits[2] == 'as':
        variable = bits[1]
        as_value = bits[3]
    elif len(bits) == 5 and bits[3] == 'as':
        variable     = bits[1]
        default  = bits[2]
        as_value = bits[4]
    else:
        raise TemplateSyntaxError, "usage: get_from_settings variable default as value " \
                "OR: get_from_settings variable as value"

    return SettingsAttrNode(variable=variable, default=default, as_value=as_value)

get_from_setting = register.tag(get_from_setting)

Comments

या आप फाइनलवेयरSITE_EXTRA_CONTEXT_DICT में उपयोग कर सकते हैं इसे करने के लिए ।

— un33k