مسعود زاهي

واجهك خطأ عند إنشاء البيئة الإفتراضية "عملية غير مسموحة" (operation not permitted) وهذا يرجع  - حسب إعتقادي- إلى أمرين:

• أنت بصدد إنشاء البنية الافتراضية داخل بطاقة خارجية sd ف virtualenv لم يتمكن من إنشاء الروابط الرمزية.
• أو أنك لا تملك الصلاحيات الكافية داخل المجلد الذي أنت بصدد إنشاء البنية الافتراضية فيه.

حاول إنشاء البنية الافتراضية في مجلد آخر.

بالرغم من أن النوعين يمثلان الأعداد الحقيقية إلا أنهما يقومان بتمثيلهما بشكل مُختلف فالنوع FloatField يستعمل float من بايثون، بينما يستخدم DecimalField النوع Decimal.

أهم الفروق بينهما:

• DecimalField:
  • يجب تعيين الخاصية decimal_places والخاصية max_digits عند إنشاء الحقل.
  • جانغو يقوم بإثارة خطأ في حالة ما إذا كان عدد الأرقام أكبر  من قيمة max_digits. مثلاً إذا كان max_digits=5 فإن الأعداد يجب أن تكون أقل من  999.99.
  • جانغو كذلك يقوم بإثارة خطأ في حالة ما إذا كان عدد الأرقام وراء الفاصلة أكبر من قيمة decimal_places. مثلاً إذا كان decimal_places= 1 فأصغر قيمة سوف تكون وراء الفاصلة هي 0.1.
  • إذا قمنا بطباعة نوع القيمة الموجودة داخل الحقل، فإن المخرج سوف يكون decimal.Decimal.
  • في قاعدة البيانات postgresql يُحفظ على الشكل numeric(max_digits, decimal_places).
• FloatField:
  • إذا قمنا بطباعة نوع القيمة الموجودة داخل الحقل، فإن المخرج سوف يكون float.
  • لا يحتوي على دوال تحقق مثل الموجود في DecimalField.
  • في قاعدة البيانات postgresql يُحفظ على الشكل double precision.
  • لايوجد به تقريب ذكي. 

بعد عرض الفرق بين الحقلين يأتي السؤال الآن ماذا أستعمل: 

1.  عندما يتعلق الأمر بالأسعار فيُنصح دائما باستخدام نوع الحقل DecimalField.
2. يُمكن أيضاً استخدام تطبيق django-money فهو يقوم بإضافة حقل جديد MoneyField خاص بحفظ الأسعار بمختلف العملات.

نعم يُمكنك إستخدام تطبيق django-debug-toolbar الذي هو عبارة عن مجموعة من اللوحات التي تعرضُ معلومات لاكتشاف وتصحيح أخطاء متنوعة حول الطلب (requests) و الإستجابة (responses). إليك لقطة شاشة توضح هذا الشريط:

لتثبيت التطبيق نقوم بتنفيذ الأمر التالي:

pip install django-debug-toolbar

قم بإضافة التطبيق إلى قائمة تطبيقات المشروع في ملف الإعدادات settings.py:

INSTALLED_APPS = [
    # ...
    "debug_toolbar",
    # ...
]

أضف رابط التطبيق إلى ملف روابط المشروع:

from django.urls import include, path

urlpatterns = [
    # ...
    path('__debug__/', include('debug_toolbar.urls')),
]

بعدها أضف البرمجية الوسطية (middleware) التالية إلى قائمة البرمجيات الوسطية في ملف الإعدادات:

MIDDLEWARE = [
    # ...
    "debug_toolbar.middleware.DebugToolbarMiddleware",
    # ...
]

بقي فقط أن تُضيف الأيبي الخاص بك إلى الإعدادات كي يظهر الشريط فقط عندك: ( في حالتنا نستخدم الأيبي المحلي localhost)

INTERNAL_IPS = [
    # ...
    "127.0.0.1", # يمكنك إضافة الأيبي المحلي لوكالهوست أو الأيبي الداخلي مثلا: 192.168.1.1
    # ...
]

وبهذا تكون قد قُمت بإعداد الشريط.

ملاحظة: الشريط لا يظهر إلا في حالة DEBUG = True والأيبي الخاص بك مُتواجد داخل INTERNAL_IPS.

بتاريخ 25 دقائق مضت قال Zx Zx2:

شكر لك اخي انا شفت اجوبتك عن دجانغو سهلة الفهم ... اخي الكريم انا بحثت في الموقع الرسمي عن الدوال و الكلاسات المستخدمة في المشروع بكتابة اسم الدالة او الكلاس

لكن يرجع لي انه لم يجد شي 

يُمكن المُبرمج قام باستخدام مكتبات بايثون أو تطبيقات جانغو جاهزة ، لو في الإمكان قُم بوضع الشفرة التي لم تفهمها هُنا وإن شاء الله سوف نُساعدك على فهمها ومعرفة مصدرها.

نعم يُمكن إنشاء نماذج models إنطلاقا من قاعدة بيانات مٌنشأة مٌسبقاً. أولاً عليك بعمل إتصال لهذه القاعدة وذلك بوضع الإعدادات الخاصة بها في ملف إعدادات المشروع settings.py.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql', # في هذا المثال استعملنا Postgres
        'NAME': 'mydatabase', # ضغ هنا اسم قاعدة البيانات
        'USER': 'mydatabaseuser', # ضع هنا اسم المستخدم
        'PASSWORD': 'mypassword', # ضع هنا الرقم السري للمستخدم
        'HOST': '127.0.0.1',  # ضع هنا عنوان الايبي أو اسم النطاق الذي تتواجد فيه قاعدة البيانات
        'PORT': '5432', # ضع هنا رقم المنفذ الخاص بقاعدة البيانات المختارة
    }
}

بمجرد إعداد الاتصال مع قاعدة البيانات يمكنك إنشاء النماذج تلقائيا باستعمال الأمر inspectdb

python manage.py inspectdb

الأمر السابق يقوم بإخراج كل النماذج التي يُمكن لجانغو إنشاؤها من قاعدة البيانات الموجودة . يُمكنك حفظها داخل ملف باستخدام الأمر التالي:

python manage.py inspectdb > models.py

يُمكنك أيضاً إستخراج نماذج محددة من قاعدة البيانات باستخدام الأمر التالي:

python manage.py inspectdb table1 table2

مرحبا Zx

لفهم مشروع أُنجز بإطار العمل جانغُو يجب أن يكونً لك معرفة مُسبقة بالهيكلة العامة التي ينتهجها جانغو لتنظيم مُختلف أجزاء المشروع.

• جانغو يقوم باستخدام مجلدات لتنظيم المشروع. المجلدات قد تكون:
  • مُجلد يحمل إسم المشروع:  هذا المجلد عادةً يحتوي على الملفات الأساسية لتشيغل المشروع مثل:
    • settings.py: ملف الإعدادات الخاصة بجانغو.
    •  urls.py: يوجد به الروابط الأساسية للمشروع.
    • wsgi.py: يستخدم هذا الملف كنقطة تواصل بين المشروع وبين خادم الويب في حالة الإنتاج (Production)
  • تطبيقات (Django APP): جانغو يتميز بمبدأ التصميم DRY (Don't repeat yourself) أي بمعنى: لا تقُم بتكرار أعمال عملتها من قبل لأن هذا يؤدي إلى عمل إضافي ويستغرق وقتًا طويلا. هنا يأتي دور التطبيقات التي يُمكن إستخدامها في مشاريع أخرى. لمعرفة ما إذا كان المجلد عبارة عن تطبيق نذهب إلى ملف الإعدادات settings.py ونرى إذا كان إسم التطبيق موجوداً داخل INSTALLED_APPS أو لا.
  • مُجلد يتضمن القوالب المستعملة في المشروع. لمعرفة هذا نذهب إلى ملف الإعدادات settings.py ونبحث عن إسم المجلد داخل TEMPLATES.
  • مُجلد يتضمن الملفات الثابتة المستعملة في المشروع، أي ملفات ال CSS و JAVASCRIPT والصور.
  • مُجلد يتضمن الملفات المُحملة من طرف العميل. لمعرفة هذا نذهب إلى ملف الإعدادات settings.py ونبحث عن إسم المجلد داخل MEDIA_URL.
• والتطبيقاتُ بدورها تحتوي على مُجلدات وملفات أساسية نذكرُ منها:
  • views.py:  يحتوي على الدوال (functions) التي تُعتَبر المتحكم في إستقبال الطلبات (Requests).
  • models.py: فيه النماذج الخاصة بالتطبيق والتي سوف تُحول إلى جداول في قاعدة البيانات.
  • admins.py: يتم إستخدامه لعرض النماذج في لوحة التحكم الخاصة بالمشروع.
  • urls.py: يوجد فيه عناوين ال URL مربوطة بالدوال الخاصة بها.
  • test.py: يوجد فيه كود إختبار تطبيق الويب.

أما بالنسبة لسؤالك الثاني عن كيفية البحث عن أشياء لا تعرفها في جانغو، فأحسن مصدر لتلقي المعلومات هو الموقع الرئيسي لإطار العمل فهو يحتوي على توثيقات عالية الجودة ومبسطة وسهلة للإستيعاب مع أمثلة للإستخدام.

للوصول إلى قيمة id الخاصة بكائن من نموذج ما بعد إنشائه نقوم بحفظ الكائن في متغير ما:

# نحفظ الكائن داخل المتغير 
# obj
obj = MyModel.objects.create(title="post 1", content="Hello, Wolrd")

وبعدها للحصول على ال id نكتب:

obj.id

أو يُمكننا أيضا إستعمال:

obj.pk

توجد عدة طرق لجعل الحقل gender إختياري في جانغو ModelForm:

• إعادة كتابة الحقل وإضافة required=False

  class Registration_FORM(ModelForm):
    	#هنا نقوم بإعادة صياغة الحقل gender
      # وإضافة خاصية اختياري له
      gender = forms.CharField(required=False)
      class Meta:
          model = My_Class
          fields = ('name', 'email' , 'gender')

   

• أول من خلال الدالة __init__ الخاصة ب Registration_FORM:

  class Registration_FORM(ModelForm):
      class Meta:
          model = My_Class
          fields = ('name', 'email' , 'gender')
      def __init__(self, *args, **kwargs):
          super(Registration_FORM, self).__init__(*args, **kwargs)
          # نقوم بإعطاء خاصية إختياري للحقل gender
          self.fields['gender'].required = False

   

• أو جعل الحقل  gender إختياري في النموذج My_Class:

  class My_Class(models.Model):
      ....
      gender = models.Charfield(max_length=20, blank=True, null=True)
                                               ^^^^^^^^^^^  ^^^^^^^^^

  نُضيف blank=True و null=True لكي نجعل الحقل يقبل القيمة None والقيمة الفارغة.

لحساب عدد المنتجات في كل وسم (Tag) نقوم بالدمج بين الدوال التالية:

• Count: التي تقومُ بحساب المنتجات في كل وسم
• annotate: التي تقوم بإنشاء حقل جديد للنتيجة. (الحقل الذي سوف نضيفه هو count).
• values: لتحديد حقول معينة من الكائنات في النتيجة النهائية.

from django.db.models import Count # نستدعي الدالة Count
result = Product.objects
    .values('tag')                 # نحدد الحقول التي ستظهر في النتيجة النهائية
    .annotate(count=Count('tag'))   # نقوم بإنشاء حقل جديد  count
    .order_by()

النتيجة سوف تكون مماثلة لجملة ال SQL التالية:

SELECT tag_id, COUNT(tag_id) AS count
FROM product GROUP BY tag_id

النتيجة النهائية سوف تكون على الشكل:

[{'tag': 'tag1', 'count': 12},  {'tag': 'tag2', 'count': 20}, ....]

عندما نٌريد حصر الوصول إلى URL ما فقط للمستخدمين المُسجلين نستخدم الزخرفة (decorator) login_required فوق الدالة ولإعادة توجيه المستخدم إلى صفحة تسجيل الدخول نقوم ب:

• إضافة LOGIN_URL إلى ملف الإعدادات الخاص بمشروعنا في Django

  LOGIN_URL='/path/to/url' #هنا أكتب رابط صفحة تسجيل الدخول

   

• أو عن طريق تمرير قيمة login_url إلى الزخرفة login_required

  @login_required(login_url='أضف هنا رابط صفحة تسجيل الدخول')
  def my_view(request):
      ...

   

في حالة ما إذا كنا نستخدم صنف  (Class) كجانغو View

class MyView(View):
    ....

وأردنا حصر إستخدامها فقط للمستخدمين المسجلين يُمكننا استعمال LoginRequiredMixin على الشكل التالي:

from django.contrib.auth.mixins import LoginRequiredMixin

class MyView(LoginRequiredMixin, View):
    login_url = '/login/' #هنا نقوم بإضافة صفحة تسجيل الدخول 

لإنشاء تعريف الدالة IsValidNamePass نُلاحظ أنها:

• تٌستعمل مباشرة من الفئة OrganizationManager لا من الكائن فهذا يعني أنها دالة ثابتة static.
• تقبل ثلاث متغيرات،( الظاهر أن المتغيرات من النوع النصي string).
• تقوم بإرجاع قيمة نصية string.

namespace Organization_Manager
{
    internal class OrganizationManager

    {
      public static string IsValidNamePass(string textBoxName, string textBoxPassword, string sql) {
            //أكتب شفرة الدالة هنا
      
      		return "قم بإرجاع قيمة نصية";
      }

    }
}

نعم كما تفضلت يجب تحميلُ الصورة ثم تخزينها. يمكن إستعمال مكتبة requests لتحميلها على الشكل التالي:

from urllib.parse import urlparse
import requests
from django.core.files.base import ContentFile
from myapp.models import Photo

img_url = 'هنا ضع رابط الصورة'
name = urlparse(img_url).path.split('/')[-1] # جلب اسم الصورة من الرابط 
                                             # عادةً يكونُ اسم الصورة  هو آخر كلمة في الرابط

photo = Photo() # إنشاء كائن للنموذج

response = requests.get(img_url) # تحميل الصورة باستخدام  مكتبة requests
if response.status_code == 200: 
    # نحفظ الصورة في الحقل باستخدام الدالة
    # save
    photo.image.save(name, ContentFile(response.content), save=True)

أو يُمكن حفظ الصورة في ملف مؤقت قبل حفظها في النموذج:

from django.core.files import File
from django.core.files.temp import NamedTemporaryFile

photo = Photo()

photo.save()

# نحمل الصورة ونحفظها داخل ملف مؤقت من نوع
# NamedTemporaryFile
# باستعمال المكتبة 
# urlopen
image_url = 'هنا ضع رابط الصورة'
img_temp = NamedTemporaryFile(delete = True)
img_temp.write(urlopen(image_url).read())
img_temp.flush()

# نحفظ الصورة في النموذج
photo.image.save("image_%s" % photo.pk, File(img_temp))
photo.save() 

يتوفر Django على حقل ImageField  هو عبارة عن FileField لكن يسمح فقط بحفظ الصور. لاستخدام هذا الحقل يجب تثبيت مكتبة بايثون Pillow. لتثبيتها نقوم ب:

pip install Pillow 

اما بالنسبة لطريقة استعمال ImageField  فهو على الشكل التالي:

field_name = models.ImageField(upload_to="uploads/", max_length=100)

حيث:

• upload_to: هو مجلد حفظ الصور المُحَملة.

أما إذا أردت استخدام FileField لحفظ مجموعة مختلفة من أنواع الملفات بشرط أن تقوم بالتحقق منها قبل حفظها فهنا يُمكن أن نستعمل المُدَقِقْ validator.

المدقق التالي يقوم بالتحقق من نوع الملف:

import magic # نستخدم مكتبة بايثون ماجيك

from django.utils.deconstruct import deconstructible
from django.template.defaultfilters import filesizeformat

# نقوم بانشاء المدقق
@deconstructible
class FileValidator(object):
    error_messages = {
     'content_type': "Files of type %(content_type)s are not supported.",
    }

    def __init__(self, content_types=()):
        self.content_types = content_types

    def __call__(self, data):
        # content_types
        # هو المتغير الذي يقوم بتمرير أنوع الملفات المقبولة
        if self.content_types:
            content_type = magic.from_buffer(data.read(), mime=True)
            data.seek(0)
            
            # إذا كان نوع الملف  خارج القائمة نقوم بارسال خطأ
            if content_type not in self.content_types:
                params = { 'content_type': content_type }
                raise ValidationError(self.error_messages['content_type'],
                                   'content_type', params)

    def __eq__(self, other):
        return (
            isinstance(other, FileValidator) and self.content_types == other.content_types
        )

لاستعمال هذا المدقق:

#نحدد قائمة الملفات المسموحة
validate_file = FileValidator(content_types=('image/png', 'video/mp4', 'audio/wav'))
# نضيف المدقق للحقل
file = models.FileField(upload_to=settings.XML_ROOT,  validators=[validate_file])

توجد عدة طرقٍ لتغيير كلمة السر الخاصة بأحد المستخدمين من بينها:

1. الطريقة الأولى: عن طريق جانغو shell:

• نقوم بفتح جانغو shell

python manage.py shell

• داخل جانغو نقوم باستدعاء النموذج User 

>>> from django.contrib.auth.models import User

• نقوم بجلب المستخدم الذي نريد تغيير رقمه السري:

>>> my_user = User.objects.get(username="zahi")

•  لتغيير الرقم السري نستخدم الدالة set_password

>>> my_user.set_password('_new_password_')
#بعدها نحفظ التغييرات
>>> user.save()

2. الطريقة الثانية: من خلال لوحة التحكم الخاصة بجانغو

• نقوم بالدخول إلى لوحة التحكم الخاصة بجانغو
• نذهب إلى AUTHENTICATION AND AUTHORIZATION ونختار النموذج User
• نُحَدد  اسم المستخدم الذي نُريد تغيير اسمه نضغط عليه
• تظهر لنا صفحة فيها معلومات المستخدم ومن بينها الرقم السري. الرقم السري يكون مشفر. لتغييره نجد جملة مكتوب فيها اذا اردت تغيير الرقم السري إضغط هنا.
• عند الضغط يظهر لنا نموذج لتغيير الرقم السري من غير ما نحط الرقم السري القديم.

عليكَ بمحاولة كتابة هذا البرنامج لوحدك فهو بسيطُ جداً وإن واجهتك صعوبات سوف نُساعدك . لن تستفيد شيئًا إذا قُمنا بحله لك.

تحياتي.

أفضل مكان لوضع القوالب هو داخل التطبيقات داخل مٌجلد اسمه templates حتى تكون هذه التطبيقات قابلة للإستعمال في مشروع آخر. أما عامةً فيُمكن وضع القوالب  أيضا داخل مجلد اسمه templates في جذر المشروع .

يُرجى الذكر أنه يجب توفر الخاصية TEMPLATES في ملف الإعدادات حتى يعرف جانغو أين يقوم بالبحث عن القوالب.

# داخل ملف settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'], # مٌجلد القوالب العام
        'APP_DIRS': True, # تفعيل خاصية البحث عن القوالب داخل التطبيقات
        ...
    },
]

إبتداءًا من النسخة رقم 1.8 من جانغو يمكننا إستخدام الدالة Length والتي تقوم بنفس عمل الدالة LENGTH الموجودة في نظام قواعد البيانات. لاستخدام هذه الدالة للقيام بتصفية كائنات النموذج نقوم بالتالي:

Model.objects.annotate(password_len=Length('password')).filter(password_len__gt=10)

شرح الشفرة:

• قُمنا بإضافة حقل إلى ال QuerySet وسميناه password_len، هذا الحقل هو نتيجة حساب طول الحقل password باستخدام الدالة Length.
• قُمنا بتصفية ال QuerySet باستخدام عملية البحث gt والتي هي مختصر Greater than أي أكبر من.

هذا بسبب أن ال ORM يقوم بالتحقق من وجود الكائن seller والكائن products في قاعدة البيانات، في حالة عدم وجود أحد منهم جانغو يقوم بالتنبيه بهذا الخطأ RelatedObjectDoesNotExist.

لتجنب هذا الخطأ يجب تغيير الدالة has_related_object إلى ما يلي:

def has_related_object(self):
	if hasattr(self, "seller") and hasattr(self, "products"):
		return (self.seller is not None) and (self.products is not None)
	return False  

الدالة hasattr تقوم بالتحقق من وجود الرابط بين الكائن من الصنف store مع الكائن seller ومع الكائن products.

كما يمكننا أيضا إستخدام try .. catch لتفادي الخطأ قبل وُقوعه

def has_related_object(self):
	try:
		return (self.seller is not None) and (self.products is not None)
	catch RelatedObjectDoesNotExist as e:
		pass
	return False
	

تحتوي الوحدة unittest في Python على مجموعة من الزخرفات (decorators) التي تسمح لك بتخطي إختبارٍ ما:

• الزخرفة skip: يُمكن إستخدامها مع الإختبارات الفردية:

class MyTestCase(unittest.TestCase):

    @unittest.skip("demonstrating skipping") # نقوم بوضع الزخرفة فوق الدالة 
    def test_nothing(self):
        self.fail("shouldn't happen")

  أو مع مجموعة من الإختبارات تحت صنف واحد:

@unittest.skip("showing class skipping") #نقوم بوضع الزخرفة فوق الصنف
class MySkippedTestCase(unittest.TestCase):
    def test_not_run(self):
        pass

• الزخرفة skipIf: تعمل نفس عمل الزخرفة skip لكن إذا تحقق شرطٌ ما.

class MyTestCase(unittest.TestCase):

    @unittest.skipIf(mylib.__version__ < (1, 3), "not supported in this library version")
    def test_format(self):
        # إختبار يعمل فقط في نسخ ذات إصدارات معينة
        pass

كما يُمكنك إستخدام الزخرفة tag من الوحدة django.test والتي تسمح بوضع علامة على الإختبار حتى يقوم جانغو بتخطيه

from django.test import tag

class SampleTestCase(TestCase):

    @tag('fast') #علامة سريع 
    def test_fast(self):
        ...

    @tag('slow') # علامة بطيئ
    def test_slow(self):
        ...

    @tag('slow', 'core') # علامات مختلفة
    def test_slow_but_core(self):
        ...

لتخطي الإختبارات التي تحمل علامة معينة نقوم بتنفيذ الأمر:

python manage.py test --exclude-tag=slow #مثلا تخطينا الإختبارات التي تحمل العلامة بطيئ

نعم يُمكن التحكم في عنوان ال URL الذي يتم إعادة التوجيه إليه بعد تسجيل الخروج Logout سواءًا بإضافة المتغير LOGOUT_REDIRECT_URL إلى قائمة الإعدادات في ملف settings.py الخاص بالمشروع.

# في ملف settings.py
LOGOUT_REDIRECT_URL="هنا أكتب الرابط الذي تُريد إعادة التوجيه إليه أو إسم النمط"

أو بإضافة المتغير next إلى عنوان ال URL لطلب تسجيل الخروج:

<!-- غير path_to_the_page -->
<!-- إلى الرابط الذي تريد -->
<a href="{% url 'auth_logout' %}?next=/path_to_the_page"> Logout</a>

كما يُمكن إعادة كتابة الدالة الخاصة بعمل تسجيل الخروج وإضافة HttpResponseRedirect لتوجيه العميل إلى الصفحة التي نُريد

# ملف views.py
from django.contrib.auth import logout

@login_required
def custom_logout(request):
    logout(request) # تسجيل الخروج
    return HttpResponseRedirect('/path_to_the_page') #إعادة توجيه
  

#ملف urls.py
urlpatterns = [
  	url(r'^logout/$', custom_logout, name='logout'),
]

ملاحظة: المتغير LOGOUT_REDIRECT_URL تم إضافته إلى جانغو في النسخة رقم 1.10.

قُم بترتيب الحقول على الشكل الموجود داخل النموذج بعدها قُم بفحص إذا كان الحقل الأخير هو الحقل الذي يتم التحقق من صحته، وإلا قم بإرجاع القيمة دون تحديد.

@validates('password', 'repassword')
def validates_fields(self, key, value):
    if key == 'repassword':
        if (self.password != value) {
        	raise ValueError("Please make sure your passwords match.")
        }
    return value

يكنك أيضا استخدام مُستمع أحداث للحدث before_flush للوصول إلى ما تبحث عنه:

@event.listens_for(Session, 'before_flush')
def validate_passwords(session, flush_context, instances):
    """
    """
    
    for instance in session.new:
        if isinstance(instance, MyData):
            if instance.password != instance.repassword
                raise ValueError("Please make sure your passwords match.")

import settings

سيقوم باستيراد أول ملف بايثون باسم settings.py موجود في المسار sys.path. عادةً يكون هذا الملف هو ملف الإعدادات الخاص بمشروع Django. وهذا الملف يحِلُّ محل ملف الإعدادات الإفتراضية الخاص ب Django والموجود في django.conf.global_settings.

أما بالنسبة ل:

from django.conf import settings

هو ليسَ ملفاً وإنما كائن تابع للنموذج  LazySettings كما هو موضح في شفرة المصدر الخاص بجانغو

settings = LazySettings()

هذا الكائن يقوم بجمع كل الإعدادات سواءًا الافتراضية (الخاصة بجانغو) أو الخاصة بالمشروع وعمل ملخص منها. هذا الملخص يكون أَعَم وأَشمل من  الإستيراد الأول.

تُستخدم الطريقة الثانية أيضا في حالة ما إذا كنا نملك ملفين للإعدادات. الملف الأول مثلا ملف إعدادات التطوير settings_dev.py والملف الثاني ملف إعدادات الإنتاج settings_prod.py فهو يقوم باستيراد إعدادات الملف الذي نقوم بتنفيذ المشروع به.

Redis هو عبارة عن مَخزَن قيم مفاتيح key value store مفتوح المصدر يمكنه العمل كمخزن لتخزين البيانات في الذاكرة in-memory store أو كمخزن تخزين بيانات مؤقت. يُمكن استخدامه إمّا كخادوم قاعدة بيانات لوحده أو مرتبطًا مع قاعدة بيانات أخرى مثل MySQL لتسريع بعض الأشياء.

يتم إستخدام Redis مع Django كذاكرة تخزين مؤقت cache لتخفيف الحمل الزائد على عمليات الاستعلام queries التي تتم على قاعدة البيانات المُستخدمة.

إنطلاقا من النسحة رقم 4.0 لجانغو أصبح التخزين المؤقت باستخدام Redis من الأمور المُدمجة والمدعومة بعد أن كان عبارة عن تطبيق طرف ثالث.

لاستعمل Redis مع جانغو نحتاجُ أولاً إلى تثبيت الخادم الخاص به. ندخل إلى  الموقع الرسمي ونقوم بتثبيته على حسب النظام الذي نستخدمه.

بعد تثبيت Redis سنحتاج إلى تثبيت redis-py وهي مكتبة في بايثون تقوم بالربط مع الخادم.

لاستخدام Redis كخلفية لذاكرة التخزين المؤقت مع Django نقوم ب:

• في ملف الإعدادات settings.py نضيف django.core.cache.backends.redis.RedisCache.

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379', # هنا ضع عنوان الايبي مع المنفذ الخاص بالخادم
                                              # redis
    }
}

• عادة ما يكون Redis محمياً باسم مستخدم وكلمة مرور نضيفهما إلى عنوان URL:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://username:password@127.0.0.1:6379',
    }
}

• إذا كنا نملك عدة خوادم Redis تم إعدادها في وضع النسخ المتماثل (replication)، فيمكننا إضافتها على الشكل التالي:

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': [
            'redis://127.0.0.1:6379', # القائد
            'redis://127.0.0.1:6378', # النسخة رقم 1
            'redis://127.0.0.1:6377', # النسخة رقم 2
        ],
    }
}

هكذا نكون قد أتممنا إضافة Redis إلى جانغو.

للإستزادة من المعلومات يمكن الإطلاع على المقالات التالية الموجودة في أكاديمية حسوب:

عند إستعمال save مع commit=False  الكائن المُعاد من الدالة لن يُحفظ في قاعدة البيانات عكس الأمر عند إستخدام commit=True الكائن سوف يٌحفظ وبعدها يُعاد. يكون هذا الفعل مٌفيداً عندما نٌريد إجراء مُعالجة إضافية للكائن قبل  حفظه في قاعدة البيانات.

كمثال تطبيقي، نفرض أننا نملك نموذجاً حيثُ يكون عنوان البريد الالكتروني واسم المستخدم  مُتماثلين دائما في هذه الحالة عند رسم النموذج نقوم بوضع حقل واحد خاص بالبريد الإلكتروني مثلاً وعند حفظ النموذج نُعبئ حقل اسم المستخدم بنفس القيمة.

class UserForm(forms.ModelForm):
    ...
    def save(self):
        # نقوم بتمرير
        #commit=False
        # للنموذج
        # الكائن  المُعاد
        # لا يكون محفوظا في قاعدة البيانات في هذه اللحظة
        user = super(UserForm, self).save(commit=False)
        # "هنا نجعل قيمة "اسم المستخدم" هي نفس قيمة "البريد الالكتروني
        user.username = user.email
        # هنا يتم الحفظ
        user.save()
        return user

عكس ما إذا استخدمنا commit=True فإن الكائن سوف يٌحفظ في قاعدة البيانات قبل أن نقوم بوضع قيمة "اسم المستخدم".

python3 manage.py sqlflush blog

الأمر الذي استعملته هنا يقوم فقط بطباعة مجموعة أوامر بصيغة SQL، هذه الأوامر تعمل على حذف البيانات فقط ولا تحذف الجداول الخاصة بالتطبيق blog.

إذا أردت حذف بيانات التطبيق blog فقط قُم بدمْج الأمر السابق مع الأمر dbshell:

pyhon3 manage.py sqlflush blog | python3 manage.py dbshell

الأمر dbshell وظيفته فتح ال shell الخاص بقاعدة البيانات.

أما إذا أردت حذف كل بيانات التطبيقات استعمل الأمر 

python3 manage.py flush
# أو
django-admin flush

أما إذا أردت حذف الجداول مع البيانات قم بتنفيذ الشفرة التالية في django shell

python3 manage.py shell #نقوم بفتح django shell

#نقوم بتنفيذ أوامر الحذف داخل قاعدة البيانات
>>> from django.db import connection
>>> cursor = connection.cursor()
>>> cursor.execute('show tables;')
>>> parts = ('DROP TABLE IF EXISTS %s;' % table for (table,) in cursor.fetchall())
>>> sql = 'SET FOREIGN_KEY_CHECKS = 0;\n' + '\n'.join(parts) + 'SET FOREIGN_KEY_CHECKS = 1;\n'
>>> connection.cursor().execute(sql)