ວິທີການສ້າງໂປແກຼມ Web ທີ່ເປັນມິດກັບມືຖືໂດຍໃຊ້ Django Framework - ພາກທີ 3


ໃນພາກທີ 1 ຂອງຊຸດນີ້ທ່ານໄດ້ຮຽນຮູ້ວິທີຕິດຕັ້ງແລະຕັ້ງຄ່າ Django ໃນສະພາບແວດລ້ອມເສມືນແລະທ່ານໄດ້ສ້າງໂຄງກະດູກຂອງໂຄງການ ທຳ ອິດຂອງທ່ານ.

ຫຼັງຈາກນັ້ນໃນພາກທີ 2 ພວກເຮົາໄດ້ສ້າງແອັບພລິເຄຊັນແລະຮູບແບບ ສຳ ລັບ Post object, ເຊິ່ງຕໍ່ມາພວກເຮົາໄດ້ຍ້າຍເຂົ້າຖານຂໍ້ມູນ. ສຸດທ້າຍ, ພວກເຮົາໄດ້ສະແດງວິທີການລວມເອົາ ຄຳ ຮ້ອງສະ ໝັກ ທີ່ທ່ານສ້າງຂື້ນມາ ໃໝ່ ໃນການໂຕ້ຕອບຜູ້ໃຊ້ການບໍລິຫານ Django.

ບົດຂຽນເຫຼົ່ານີ້ແມ່ນສ່ວນ ໜຶ່ງ ຂອງຊຸດ Django:

ໃນຄູ່ມືສຸດທ້າຍນີ້ພວກເຮົາຈະປຶກສາຫາລືກ່ຽວກັບວິທີການເຂົ້າໃຊ້ແອັບພລິເຄຊັນໂດຍໃຊ້ UI ແລະວິທີທີ່ຈະເຮັດໃຫ້ມັນເປັນມິດກັບມືຖື ສຳ ລັບອຸປະກອນທຸກປະເພດ. ທີ່ເວົ້າວ່າ, ໃຫ້ເລີ່ມຕົ້ນ.

ການສ້າງວັດຖຸຜ່ານອິນເຕີເຟດ admin Django

ເພື່ອສ້າງວັດຖຸຂອງປະເພດ Post (ຈື່ວ່ານັ້ນແມ່ນຮູບແບບທີ່ພວກເຮົາໄດ້ ກຳ ນົດໄວ້ໃນພາກທີ 2 ຂອງຊຸດນີ້), ພວກເຮົາຈະ ນຳ ໃຊ້ອິນເຕີເຟດ admin Django.

ໃຫ້ແນ່ໃຈວ່າເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ທີ່ມີຢູ່ໃນ Django ແມ່ນເຮັດວຽກຢູ່ທີ່ port 8000 (ຫຼືອີກທາງເລືອກ ໜຶ່ງ ຂອງທ່ານ) ໂດຍການເຮັດວຽກຕາມ ຄຳ ສັ່ງຕໍ່ໄປນີ້ຈາກລາຍຊື່ myfirstdjangoproject ຂ້າງນອກ:

# cd ~/myfirstdjangoenv/myfirstdjangoproject
# python manage.py runserver 0.0.0.0:8000

ຕອນນີ້ເປີດໂປແກຼມທ່ອງເວັບຂອງທ່ານແລ້ວຊີ້ໄປທີ່ http:// ip-address: 8000/admin , ຈາກນັ້ນເຂົ້າສູ່ລະບົບໂດຍໃຊ້ຂໍ້ມູນປະ ຈຳ ຕົວທີ່ທ່ານຕັ້ງໄວ້ໃນບົດຂຽນກ່ອນແລະເລີ່ມຂຽນໂພດ (ເຊິ່ງອີກເທື່ອ ໜຶ່ງ, ຈະສ້າງວັດຖຸປະເພດຂອງ Post ແລະໃສ່ຂໍ້ມູນທີ່ກ່ຽວຂ້ອງເຂົ້າໃນຖານຂໍ້ມູນທີ່ຕິດພັນ):

ເຮັດເລື້ມຄືນຂະບວນການ 2 ຫຼື 3 ຄັ້ງ:

ຫຼັງຈາກທີ່ພວກເຮົາໄດ້ສ້າງສອງກະທູ້, ໃຫ້ເບິ່ງສິ່ງທີ່ພວກເຮົາຕ້ອງເຮັດເພື່ອສະແດງພວກມັນໂດຍໃຊ້ໂປແກຼມທ່ອງເວັບຂອງພວກເຮົາ.

ມຸມມອງເບື້ອງຕົ້ນຂອງພວກເຮົາ

ທັດສະນະ ທຳ ອິດຂອງພວກເຮົາ (~/myfirstdjangoenv/myfirstdjangoproject/myblog/views.py) ຈະເປັນຜູ້ຮັບຜິດຊອບໃນການກັ່ນຕອງວັດຖຸ Post ທັງ ໝົດ ແລະສົ່ງຄືນສິ່ງທີ່ມູນຄ່າຂອງເວລາທີ່ໂພດລົງຕໍ່າກວ່າຫລືເທົ່າກັບວັນທີແລະເວລາປະຈຸບັນ (whenPublished__lte = timezone.now)()) ສັ່ງໂດຍລົງເມື່ອລົງໂຄສະນາ, ເຊິ່ງແມ່ນ ຄຳ ດຽວກັນກັບ ຄຳ ວ່າ "ຄັ້ງ ທຳ ອິດທີ່ສຸດ".

ວັດຖຸເຫຼົ່ານີ້ຖືກບັນທຶກລົງໃນກະທູ້ທີ່ມີຊື່ຕົວແປຢ່າງ ເໝາະ ສົມ, ແລະຖືກສົ່ງຄືນ (ຖືກລະບຸວ່າເປັນນາມສະກຸນ) ເພື່ອຖືກຝັງໄວ້ໃນ HTML, ດັ່ງທີ່ພວກເຮົາຈະເຫັນໃນພາກຕໍ່ໄປ:

from django.shortcuts import render
from .models import Post
from django.utils import timezone
def posts(request):
        posts = Post.objects.filter(whenPublished__lte=timezone.now()).order_by('-whenPublished')
        return render(request, 'myblog/posts.html', {'allposts': posts})

ສຸດທ້າຍ, ໝາຍ ເລກສອງຂ້າງໃນ whenPublished__lte ຂ້າງເທິງຖືກໃຊ້ເພື່ອແຍກເຂດຂໍ້ມູນ (ເມື່ອຖືກເຜີຍແຜ່) ຈາກຕົວກອງຫຼືການປະຕິບັດງານ (lte = ນ້ອຍກວ່າຫຼືເທົ່າກັບ).

ເມື່ອພວກເຮົາໄດ້ ກຳ ນົດມຸມມອງເບື້ອງຕົ້ນຂອງພວກເຮົາ, ໃຫ້ເຮັດວຽກກັບແມ່ແບບທີ່ກ່ຽວຂ້ອງ.

ສ້າງແມ່ແບບ ສຳ ລັບໂຄງການ ທຳ ອິດຂອງພວກເຮົາ

ປະຕິບັດຕາມທິດທາງແລະເສັ້ນທາງທີ່ໄດ້ກ່າວໄວ້ໃນພາກກ່ອນ, ພວກເຮົາຈະເກັບແມ່ແບບເບື້ອງຕົ້ນຂອງພວກເຮົາໄວ້ໃນ myblog/ແມ່ແບບ/myblog. ນີ້ຫມາຍຄວາມວ່າທ່ານຈະຕ້ອງສ້າງໄດເລກະທໍລີທີ່ມີຊື່ວ່າແມ່ແບບແລະໄດເລກະທໍລີຍ່ອຍທີ່ເອີ້ນວ່າ myblog:

# cd ~/myfirstdjangoenv/myfirstdjangoproject/myblog
# mkdir -p templates/myblog

ພວກເຮົາຈະໂທຫາແມ່ແບບ posts.html ແລະໃສ່ລະຫັດຕໍ່ໄປນີ້ໃນມັນ. ທ່ານຈະສັງເກດເຫັນວ່າພວກເຮົາ ກຳ ລັງເພີ່ມການອ້າງອິງ online ໃສ່ jQuery, Bootstrap, FontAwesome ແລະ Google fonts.

ນອກຈາກນັ້ນ, ພວກເຮົາໄດ້ໃສ່ລະຫັດ Python ພາຍໃນວົງເລັບ curly ພາຍໃນ HTML. ກະລຸນາຮັບຊາບວ່າ ສຳ ລັບທຸກໆຈຸດປະສົງຂອງປະເພດ Post ພວກເຮົາຈະສະແດງຫົວຂໍ້, ວັນທີທີ່ເຜີຍແຜ່ແລະຜູ້ຂຽນ, ແລະສຸດທ້າຍຂໍ້ຄວາມຂອງມັນ. ສຸດທ້າຍ, ໃນສີແດງທ່ານຈະເຫັນວ່າພວກເຮົາອ້າງອີງໃສ່ວັດຖຸຕ່າງໆທີ່ສົ່ງຄືນຜ່ານ myblog/views.py:

Ok, ນີ້ແມ່ນເອກະສານ posts.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
<link href='https://fonts.googleapis.com/css?family=Indie+Flower' rel='stylesheet' type='text/css'>
<link href='https://fonts.googleapis.com/css?family=Pacifico' rel='stylesheet' type='text/css'>
<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css" rel="stylesheet" type='text/css'">
<script src="https://code.jquery.com/jquery-2.1.4.min.js">
</script>
    <style>
      .title {
        font-family: 'Indie Flower', serif;
        font-size: 30px;
        color: #1E90FF;
      }
      h1 {
        font-family: 'Pacifico', serif;
        font-size: 45px;
        color: #1E90FF;
      }
    </style>
</head>
<body>
<div class="container"><h1>My blog</h1><br>
{% for post in allposts %}
    <div>
        <div class="title">{{ post.title }}</div>
        <strong>Published on {{ post.whenPublished }} by {{ post.author }}.</strong>
        <p>{{ post.text|linebreaks }}</p>
    </div>
{% endfor %}
</div>
</body>
</html>

ໃນແມ່ແບບຂ້າງເທິງ, ຕົວກອງທີ່ຖືກແຍກແມ່ນໃຊ້ເພື່ອທົດແທນການຢຸດເສັ້ນໃນຂໍ້ຄວາມ ທຳ ມະດາທີ່ມີລະດັບ HTML ເທົ່າກັນ (
ຫຼື

) ເພື່ອຈັດຮູບແບບແຕ່ລະອັນ ໂພສໃຫ້ຖືກຕ້ອງດ້ວຍການແຍກແຍກວັກ.

ຕໍ່ໄປ, ພວກເຮົາຕ້ອງຕັ້ງການສ້າງແຜນທີ່ລະຫວ່າງ URL ໃນແອັບພລິເຄຊັນຂອງພວກເຮົາແລະມຸມມອງທີ່ກົງກັນທີ່ສົ່ງຄືນຂໍ້ມູນ. ເພື່ອເຮັດແນວນັ້ນ, ສ້າງເອກະສານທີ່ມີຊື່ urls.py ພາຍໃນ myblog ດ້ວຍເນື້ອຫາຕໍ່ໄປນີ້:

from django.conf.urls import url
from . import views
urlpatterns = [
    url(r'^$', views.posts, name='posts'),
]

ລະຫັດ $^ລະຫັດ ເໝາະ ສົມກັບ ຄຳ ອະທິບາຍເລັກນ້ອຍ. ລະຫັດ ນຳ ໜ້າ r ແນະ ນຳ Django ໃຫ້ຮັກສາສາຍພາຍໃນວົງຢືມດຽວເປັນການສະແດງອອກເປັນປະ ຈຳ.

ໂດຍສະເພາະ, r ^$ ເປັນຕົວແທນຂອງສາຍເຊືອກທີ່ບໍ່ມີຂໍ້ມູນດັ່ງນັ້ນເມື່ອພວກເຮົາຊີ້ຕົວທ່ອງເວັບຂອງພວກເຮົາໄປທີ່ http:// ip-address: 8000 (ແລະບໍ່ມີຫຍັງອີກ) ຂໍ້ມູນກໍ່ໄດ້ສົ່ງຄືນ ໂດຍຂໍ້ຄວາມທີ່ມີຕົວແປຢູ່ພາຍໃນ views.py (ອ້າງອີງເຖິງພາກກ່ອນ ໜ້າ) ຈະຖືກ ນຳ ສະ ເໜີ ໃນ ໜ້າ ທຳ ອິດຂອງພວກເຮົາ:

ສຸດທ້າຍນີ້, ພວກເຮົາຈະລວມເອົາເອກະສານ urls.py ຂອງໂປແກຼມ blog ຂອງພວກເຮົາ (~/myfirstdjangoenv/myfirstdjangoproject/myblog/urls.py) ເຂົ້າໃນ urls.py ຂອງໂຄງການຫລັກຂອງພວກເຮົາ (~/myfirstdjangoenv/myfirstdjangoproject/myfirstdjangoproject/urls .py):

from django.conf.urls import include, url
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', include(admin.site.urls)),
    url(r'', include('myblog.urls')),
]

ຫຼັງຈາກນັ້ນ, ໃຫ້ເລີ່ມຕົ້ນຂອງເຄື່ອງແມ່ຂ່າຍເວັບ:

# cd ~/myfirstdjangoenv/myfirstdjangoproject
# python manage.py runserver 0.0.0.0:8000

ດຽວນີ້ພວກເຮົາຄວນຈະສາມາດເຫັນລາຍການຂອງຂໍ້ຄວາມທີ່ພວກເຮົາສ້າງຂື້ນກ່ອນ ໜ້າ ນີ້:

ຂໍຂອບໃຈກັບ Bootstrap, ທ່ານຍັງສາມາດມີການເບິ່ງເຫັນທີ່ດີເລີດໃນອຸປະກອນນ້ອຍກວ່າ:

Summing Up

ຕອນນີ້ຂໍທົບທວນຄືນແນວຄວາມຄິດທີ່ພວກເຮົາໄດ້ເວົ້າເຖິງໃນບົດຄວາມນີ້ແລະຕະຫຼອດໄລຍະການເຜີຍແຜ່ນີ້:

1. ແຕ່ລະຮູບແບບ ກຳ ນົດວັດຖຸແລະແຜນທີ່ໄປຫາຕາຕະລາງຖານຂໍ້ມູນ, ເຊິ່ງທົ່ງນາຂອງມັນເປັນແຜນທີ່ແລະຄຸນລັກສະນະຂອງວັດຖຸນັ້ນ. ໃນທາງກົງກັນຂ້າມ, ແມ່ແບບ ກຳ ນົດການໂຕ້ຕອບຂອງຜູ້ໃຊ້ບ່ອນທີ່ຂໍ້ມູນຈະກັບຄືນໂດຍມຸມມອງຈະຖືກສະແດງ.

ໃຫ້ເວົ້າວ່າພວກເຮົາຕ້ອງການດັດແປງຮູບແບບຂອງພວກເຮົາໂດຍການຕື່ມຂໍ້ມູນໃສ່ຊື່ທີ່ຫຍໍ້ເຂົ້າໄປໃນ Post object, ເຊິ່ງພວກເຮົາຈະເກັບລາຍລະອຽດສັ້ນໆທີ່ເປັນທາງເລືອກຂອງແຕ່ລະໂພດ. ໃຫ້ຕື່ມສາຍຕໍ່ໄປນີ້ໃນ myblog/models.py:

summary = models.CharField(max_length=350, blank=True, null=True)

ດັ່ງທີ່ພວກເຮົາໄດ້ຮຽນຮູ້ໃນບົດຂຽນກ່ອນ ໜ້າ ນີ້, ພວກເຮົາ ຈຳ ເປັນຕ້ອງໄດ້ຍ້າຍການປ່ຽນແປງຂອງຖານຂໍ້ມູນ:

# python manage.py makemigrations myblog
# python manage.py migrate myblog

ຫຼັງຈາກນັ້ນໃຫ້ໃຊ້ອິນເຕີເຟດ admin ເພື່ອດັດແກ້ຂໍ້ຄວາມແລະເພີ່ມບົດສະຫຼຸບສັ້ນໆໃນແຕ່ລະໂພດ. ສຸດທ້າຍ, ປ່ຽນສາຍຕໍ່ໄປນີ້ໃນແມ່ແບບ (posts.html):

<p>{{ post.text|linebreaks }}</p>

ກັບ

<p>{{ post.summary }}</p>

ໂຫຼດຫນ້າຈໍຄືນຫນ້າທໍາອິດເພື່ອເບິ່ງການປ່ຽນແປງ:

2. ໜ້າ ທີ່ການເບິ່ງເຫັນຕ້ອງໃຊ້ ຄຳ ຮ້ອງຂໍ HTTP ແລະສົ່ງ ຄຳ ຕອບກັບ HTTP. ໃນບົດຂຽນນີ້, def posts (ຄຳ ຮ້ອງຂໍ) ໃນ views.py ເຮັດໃຫ້ການໂທຫາຖານຂໍ້ມູນທີ່ຕິດພັນເພື່ອດຶງເອົາທຸກໆຂໍ້ຄວາມ. ຖ້າພວກເຮົາຕ້ອງການດຶງເອົາທຸກໆຫົວຂໍ້ທີ່ມີ ຄຳ ສັບທີ່ສາມາດຕອບໄດ້ໃນຫົວຂໍ້, ພວກເຮົາຄວນປ່ຽນແທນ.

posts = Post.objects.filter(whenPublished__lte=timezone.now()).order_by('-whenPublished')

ກັບ

posts = Post.objects.filter(title__icontains="ansible").order_by('-whenPublished')

ໂດຍການແຍກອິນເຕີເຟດຜູ້ໃຊ້ຈາກເຫດຜົນການ ນຳ ໃຊ້ໃນການ ນຳ ໃຊ້ເວັບຕ່າງໆ, Django ອຳ ນວຍຄວາມສະດວກໃຫ້ແກ່ວຽກງານໃນການຮັກສາແລະຍົກລະດັບກິດ.

3. ຖ້າທ່ານປະຕິບັດຕາມ ຄຳ ແນະ ນຳ ທີ່ໄດ້ສະ ເໜີ ໃນຊຸດນີ້, ໂຄງສ້າງຂອງໂຄງການຂອງທ່ານຄວນຈະເປັນດັ່ງຕໍ່ໄປນີ້:

myfirstdjangoenv/myfirstdjangoproject
├── db.sqlite3
├── manage.py
├── myblog
│   ├── admin.py
│   ├── admin.pyc
│   ├── __init__.py
│   ├── __init__.pyc
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   ├── 0001_initial.pyc
│   │   ├── __init__.py
│   │   └── __init__.pyc
│   ├── models.py
│   ├── models.pyc
│   ├── templates
│   │   └── myblog
│   │       └── posts.html
│   ├── tests.py
│   ├── urls.py
│   ├── urls.pyc
│   ├── views.py
│   └── views.pyc
└── myfirstdjangoproject
    ├── __init__.py
    ├── __init__.pyc
    ├── settings.py
    ├── settings.pyc
    ├── urls.py
    ├── urls.pyc
    ├── wsgi.py
    └── wsgi.pyc

ໃນກໍລະນີທີ່ບັນຊີລາຍຊື່ຂ້າງເທິງບໍ່ສະແດງຢູ່ໃນໂປແກຼມທ່ອງເວັບຂອງທ່ານຢ່າງຖືກຕ້ອງ, ນີ້ແມ່ນພາບຫນ້າຈໍຂອງຜົນຜະລິດຂອງ ຄຳ ສັ່ງຕໍ່ໄປນີ້:

# tree myfirstdjangoenv/myfirstdjangoproject

ບົດສະຫຼຸບ

ເຖິງແມ່ນວ່າແນວຄິດທັງ ໝົດ ເຫຼົ່ານີ້ອາດເບິ່ງຄືວ່າເປັນການຂົ່ມຂູ່ເລັກນ້ອຍໃນຕອນ ທຳ ອິດ, ຂ້ອຍສາມາດຮັບປະກັນວ່າທ່ານ Django ແມ່ນຄຸ້ມຄ່າກັບຄວາມພະຍາຍາມທີ່ ຈຳ ເປັນເພື່ອຈະໄດ້ຮູ້ຈັກກັບມັນ.

ຂ້າພະເຈົ້າຫວັງວ່າຕົວຢ່າງທີ່ພວກເຮົາໄດ້ ນຳ ໃຊ້ໃນຊຸດນີ້ເພື່ອແນະ ນຳ ທ່ານກ່ຽວກັບກອບເວັບທີ່ດີເດັ່ນນີ້ຈະກະຕຸ້ນໃຫ້ທ່ານຮຽນຮູ້ເພີ່ມເຕີມ. ຖ້າເປັນດັ່ງນັ້ນ, ເອກະສານ Django ຢ່າງເປັນທາງການ (ເຊິ່ງຖືກເກັບຮັກສາໄວ້ຢ່າງບໍ່ຢຸດຢັ້ງ) ແມ່ນບ່ອນທີ່ດີທີ່ສຸດທີ່ຈະເລີ່ມຕົ້ນ.

ຂ້າພະເຈົ້າສາມາດຮັບປະກັນທ່ານໄດ້ວ່າ Django ມີຫຼາຍຢ່າງຫຼາຍກ່ວາທີ່ພວກເຮົາສາມາດປົກຄຸມຢ່າງຄົບຖ້ວນໃນຊຸດຂອງບົດຄວາມ, ສະນັ້ນຮູ້ສຶກວ່າທ່ານສາມາດ ສຳ ຫຼວດມັນແລະຮຽນຮູ້ໂດຍການເຮັດ!

ຮູ້ສຶກວ່າບໍ່ເສຍຄ່າທີ່ຈະຝາກຈົດ ໝາຍ ໃຫ້ພວກເຮົາດ້ວຍ ຄຳ ຖາມຫຼື ຄຳ ແນະ ນຳ ໂດຍໃຊ້ແບບຟອມລຸ່ມນີ້.