Dev.to-ն բլոգային հարթակ է, որտեղ ծրագրավորողները հոդվածներ են հրապարակում թեմաներով, որոնք օգնում են այլ ծրագրավորողներին լուծել խնդիրը կամ սովորել նոր բան: Dev.to-ն ծառայում է որպես ծրագրակազմ մշակողների համայնք, որոնք հավաքվում են միմյանց օգնելու համար: Django-ն անվճար և բաց կոդով Python-ի վրա հիմնված վեբ շրջանակ է, որը հետևում է մոդել-կաղապար-դիտումների ճարտարապետական օրինակին: Django-ն խրախուսում է արագ զարգացումը և մաքուր, պրագմատիկ դիզայնը:
PostgreSQL-ը, որը նաև հայտնի է որպես Postgres, անվճար և բաց կոդով հարաբերական տվյալների բազայի կառավարման համակարգ է, որն ընդգծում է SQL-ի համապատասխանությունը:
Նախադրյալներ
Առաջին հերթին, այս ձեռնարկին հետևելու համար ձեզ հարկավոր է տեքստային խմբագրիչ, որը տեղադրված է ձեր մեքենայի վրա: Այս դեպքում ես կօգտագործեմ Visual Studio Code խմբագրիչը, բայց դուք կարող եք օգտագործել ձեր ընտրած կոդերի խմբագրիչը: Նաև համոզվեք, որ ձեր մեքենայի վրա տեղադրված են Python և PostgreSQL:
Ծրագրի կարգավորում
Այս ձեռնարկը սկսելու համար ձեր մեքենայի վրա ստեղծեք Blog անունով թղթապանակ: Աջ սեղմեք թղթապանակի վրա և բացեք այն Visual Studio Code տեքստային խմբագրիչով կամ ձեր ընտրած տեքստային խմբագրիչով: Visual Studio կոդը օգտագործելիս սեղմեք վերևում գտնվող տերմինալի տարբերակը և ընտրեք Նոր տերմինալ, ինչպես ցույց է տրված ստորև:
Եկեք հիմա տեղադրենք Django մեր Blog Django նախագծում: Django-ն տեղադրելու համար մենք կօգտագործենք python-ի փաթեթավորման գործիք, որը կոչվում է Pipenv: Pipenv-ն օգտագործվում է Django նախագծերում վիրտուալ միջավայրերը կառավարելու համար: Դուք կարող եք Pipenv-ը տեղադրել ձեր մեքենայի վրա՝ օգտագործելով այս ուղեցույցը: Այժմ գործարկեք ստորև նշված հրամանը՝ ձեր նախագծում Django-ն տեղադրելու համար.
pipenv install django
Այնուհետև նախագծում ստեղծեք վիրտուալ միջավայր՝ գործարկելով ստորև ներկայացված հրամանը:
pipenv shell
Այժմ դուք պետք է տեսնեք փակագծեր Բլոգի շուրջ ձեր հրամանի տողում, ինչպես ցույց է տրված ստորև:
((Blog))
Բլոգի շուրջ փակագծերը ցույց են տալիս, որ վիրտուալ միջավայրն ակտիվացել է։
Եկեք հիմա ստեղծենք նոր Django նախագիծ, որը կոչվում է Articles՝ գործարկելով ստորև ներկայացված հրամանը: Մի մոռացեք վերջում (.) ժամանակահատվածը:
django-admin startproject Articles .
Այժմ գործարկեք ստորև ներկայացված հրամանը և այցելեք http://127.0.0.1:8000:
python manage.py runserver
Դուք պետք է տեսնեք Django-ի ողջույնի էջը, ինչպես ցույց է տրված ստորև:
Եկեք հիմա ստեղծենք հավելված, որը կոչվում է posts մեր Django նախագծում: Հրամանի տողից դուրս եկեք սերվերից control+c-ով: Այնուհետև գործարկեք ստորև ներկայացված հրամանը:
python manage.py startapp posts
Ձեր Visual Studio Code-ի խմբագրիչի պատուհանում սեղմեք Հոդվածներ պանակը և բացեք settings.py ֆայլը, ինչպես ցույց է տրված ստորև:
Settings.py ֆայլում ոլորեք դեպի INSTALLED_APPS
բաժինը, որտեղ արդեն այնտեղ կտեսնեք ներկառուցված Django հավելվածներ: Ավելացրեք մեր նոր հաղորդագրությունների հավելվածը ներքևում, ինչպես ցույց է տրված ստորև:
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'posts', # new
]
Postgres-ի կարգավորում
Postgres-ը ձեր ապարատում տեղադրելուց հետո գործարկեք ստորև նշված հրամանը՝ տեղադրումը հաստատելու համար:
psql --version
Դուք պետք է կարողանաք տեսնել ձեր համակարգում տեղադրված Postgres-ի տարբերակը: Այժմ գործարկեք ստորև ներկայացված հրամանը՝ Postgres հուշումը բացելու համար:
sudo -u postgres psql postgres
Երբ PostgreSQL-ը բացվի հրամանի տողում, գործարկեք ստորև նշված հրամանը՝ դրա համար գաղտնաբառ սահմանելու համար:
\password postgres
PostgreSQL հուշումից դուրս գալու համար գործարկեք ստորև ներկայացված հրամանը:
\q
Postgres-ի հուշումը նորից բացելու համար գործարկեք ստորև ներկայացված հրամանը և մուտքագրեք այն գաղտնաբառը, որը դուք սահմանել եք postgres-ի համար:
psql -U postgres -W
Եկեք հիմա ստեղծենք տվյալների բազա Postgres-ում, որը կօգտագործվի մեր բլոգի նախագծի համար գրառումները պահելու համար՝ գործարկելով ստորև նշված հրամանը:
CREATE DATABASE posts;
Այնուհետև գործարկեք ստորև ցուցադրված հրամանը՝ տեսնելու, թե արդյոք ձեր ստեղծած տվյալների բազան գտնվում է Postgres-ի տվյալների բազաների ցանկում:
\l
Ինչպես տեսնում եք ստորև ներկայացված սքրինշոթից, գրառումների տվյալների բազան ստեղծվել է PostgreSQL-ում:
Պոստգրեսի ինտեգրում Ջանգոյի հետ
Եկեք տեղադրենք psycopg2 փաթեթը, որը թույլ կտա մեզ օգտագործել Postgres տվյալների բազան, որը մենք ստեղծել ենք՝ գործարկելով ստորև նշված հրամանը:
pipenv install psycopg2
Բացեք settings.py ֆայլը Հոդվածներ պանակում և ոլորեք ներքև դեպի ՏՎՅԱԼՆԵՐԻ ԲԱԺԻՆՆԵՐ, որն ունի ստորև ներկայացված տեսքը:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
Նախագիծը կազմաձևված է SQLite-ը որպես տվյալների բազա օգտագործելու համար: Այն, ինչ դուք պետք է անեք, դա փոխելն է, որպեսզի նախագիծը փոխարենը կարողանա օգտագործել մեր ստեղծած Postgres տվյալների բազան:
Փոխեք շարժիչը այնպես, որ այն օգտագործի Postgres ադապտեր sqlite3 ադապտորի փոխարեն: NAME-ի համար օգտագործեք ձեր տվյալների բազայի անվանումը, որտեղ այս դեպքում դա գրառումներ է: Դուք նաև պետք է ավելացնեք մուտքի հավատարմագրերը ձեր տվյալների բազայի համար:
USER-ը պետք է լինի postgres, իսկ PASSWORD-ը պետք է լինի այն գաղտնաբառը, որը դուք սահմանել եք postgres-ի համար: Settings.py ֆայլի ՏՎՅԱԼՆԵՐԻ ՏՎՅԱԼՆԵՐԸ բաժինն այժմ պետք է նայվի ստորև ներկայացվածին:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'posts',
'USER': 'postgres',
'PASSWORD': 'password',
'HOST': 'localhost',
'PORT': '',
}
}
Django Models
Եկեք հիմա ստեղծենք Django մոդելը, որը սահմանում է տվյալների դաշտերը, որոնք մենք ցանկանում ենք, որ պահվեն Postgres տվյալների բազայում: Մոդելը ստեղծելու համար նավարկեք դեպի models.py ֆայլը գրառումների պանակում, ինչպես ցույց է տրված ստորև:
Ձեր models.py ֆայլն այժմ պետք է նայվի ստորև ներկայացվածին:
from django.db import models
import datetime
class Article(models.Model):
title = models.TextField(blank=True)
description = models.TextField(blank=True)
cover_image = models.TextField(blank=True)
article_body = models.TextField(blank=True)
published_at = models.DateTimeField(
default=datetime.date.today, blank=True, null=True)
def __str__(self):
return self.title
Եկեք ստեղծենք և կիրառենք միգրացիաներ մեր տվյալների բազայում՝ գործարկելով ստորև նշված հրամանները:
python manage.py makemigrations
python manage.py migrate
Այժմ գրանցենք մոդելը՝ բացելով admin.py ֆայլը գրառումների պանակում: Այժմ admin.py ֆայլը պետք է նայվի, ինչպես ցույց է տրված ստորև:
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import Article
class ArticleAdmin(admin.ModelAdmin):
list_display = ('id', 'title')
admin.site.register(Article, ArticleAdmin)
Հաջորդ քայլը ադմինիստրատորի հաշիվ ստեղծելն է՝ գործարկելով ստորև նշված հրամանը: Ձեզանից կպահանջվի ընտրել օգտվողի անուն, տրամադրել էլփոստի հասցե, ընտրել և հաստատել հաշվի գաղտնաբառը:
python manage.py createsuperuser
Django Views
Այժմ այցելեք Dev.to API documentation՝ իմանալու, թե ինչպես ստանալ API բանալին տարբեր API վերջնակետերի հետ միասին: Վեբ էջի ձախ կողմում ընտրեք Նույնականացում բաժինը՝ իմանալու, թե ինչպես ստանալ API բանալի:
Այնուհետև նույնականացման բաժնի տակ ընտրեք հոդվածներ բաժինը: Ոլորեք ներքև բացվող ընտրացանկից մինչև Օգտատիրոջ հրապարակված հոդվածները: Սա այն վերջնակետն է, որը թույլ է տալիս հաճախորդին վերբերել հրապարակված հոդվածների ցանկը վավերացված օգտատիրոջ անունից:
Էջի աջ կողմում կարող եք տեսնել հարցումների նմուշները, որոնք կարող եք կատարել Dev.to API-ում:
Եկեք հիմա ստեղծենք python դիտման ֆունկցիա views.py ֆայլում, որը http հարցումներ է կատարում Dev.to API-ին, ինչպես ցույց է տրված ստորև:
from django.shortcuts import render
import requests
from .models import Article
def get_articles(request):
all_articles = {}
API_KEY = 'Your_API_KEY'
url = 'https://dev.to/api/articles/me/published'
headers = {'api-key': API_KEY}
response = requests.get(url, headers=headers)
data = response.json()
for i, item in enumerate(data):
article_data = Article(
title=data[i]['title'],
description=data[i]['description'],
cover_image=data[i]['cover_image'],
article_body=data[i]['body_markdown'],
published_at=data[i]['published_at']
)
article_data.save()
all_articles = Article.objects.all().order_by(
'-published_at').distinct('published_at')
return render(request, "blog.html", {"all_articles": all_articles})
Հոդվածի հիմնական մասը ցուցադրելու համար մենք պետք է ստեղծենք մեկ այլ դիտման ֆունկցիա, որը հարցում է անում հոդվածին ըստ id-ի:
def blogBody(request, id):
article = Article.objects.get(id=id)
return render(request, "blogBody.html", {"article": article})
Ձեր views.py ֆայլն այժմ պետք է նայվի ստորև ներկայացվածին:
from django.shortcuts import render
import requests
from .models import Article
def get_articles(request):
all_articles = {}
API_KEY = 'Your_API_KEY'
url = 'https://dev.to/api/articles/me/published'
headers = {'api-key': API_KEY}
response = requests.get(url, headers=headers)
data = response.json()
for i, item in enumerate(data):
article_data = Article(
title=data[i]['title'],
description=data[i]['description'],
cover_image=data[i]['cover_image'],
article_body=data[i]['body_markdown'],
published_at=data[i]['published_at']
)
article_data.save()
all_articles = Article.objects.all().order_by(
'-published_at').distinct('published_at')
return render(request, "blog.html", {"all_articles": all_articles})
def blogBody(request, id):
article = Article.objects.get(id=id)
return render(request, "blogBody.html", {"article": article})
Django URL-ներ
Այժմ մենք պետք է կարգավորենք մեր նախագծի urls-ները՝ ստեղծելով նոր urls.py ֆայլ գրառումների պանակում: urls.py ֆայլն այժմ պետք է նայվի այնպես, ինչպես ցույց է տրված ստորև:
from django.urls import path
from .views import blogBody
urlpatterns = [
path("blog", blog, name="blog"),
path("article/<int:id>", blogBody, name="article"),
]
Վերջին քայլը Articles/urls.py ֆայլի թարմացումն է. ֆայլը պետք է ունենա հետևյալ տեսքը.
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path("", include("posts.urls"))
]
Django կաղապարներ
Ստեղծեք գրացուցակ, որը կոչվում է կաղապարներ, այնուհետև ստեղծեք երկու HTML ֆայլեր՝ blog.html և blogBody.html այսպես կոչված:
mkdir templates
touch templates/blog.html
touch templates/blogBody.html
Եկեք այժմ թարմացնենք Articles/settings.py ֆայլը՝ Django-ին հայտնելու մեր նոր ձևանմուշների գրացուցակի գտնվելու վայրը: Սա «DIRS» պարամետրի մեկ տողով փոփոխություն է Կաղապարներ բաժնում, ինչպես ցույց է տրված ստորև:
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')], #new
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
Չմոռանաք նշել inport ossettings.pyֆայլի վերևում, այլապես սխալ կստանաք, որ OS-ը սահմանված չէ: Ձեր կաղապարներ/blog.html ֆայլն այժմ պետք է նայվի այնպես, ինչպես ցույց է տրված ստորև:
{% for article in all_articles %}
<img src="" alt="">
<h4></h4>
<p></p>
<a href="{% url 'article' article.id %}">Read More...</a>
{% endfor %}
Նավարկեք 127.0.01:800/blog և դուք պետք է տեսնեք հոդվածներ Dev To-ից, ինչպես ցույց է տրված ստորև:
Հոդվածի մարմինը
Երբ մենք զանգում ենք API-ին, հոդվածի մարմինը վերցվում է որպես article markdown
: Նշումը ստացվում է API-ից որպես տող: Սա նշանակում է, որ այն նման կլինի այն չմշակված բովանդակությանը, որը դուք մուտքագրում եք DEV To-ում, այլ ոչ թե նախադիտման/հրապարակված տարբերակի (այսինքն՝ վերնագրերի համար նախատեսված ##-ի նման շարահյուսությամբ): Որպեսզի այն ցուցադրվի ձեր կայքում այնպես, ինչպես երևում է DEV To-ում, դուք պետք է ավելացնեք լրացուցիչ քայլ՝ տողերի նշումը HTML-ի վերածելու համար: Կան բազմաթիվ նշումներ վերլուծող գրադարաններ, որոնք կարող են դա անել ձեզ համար, բայց այս նախագծում մենք կօգտագործենք Django-ի համար նշագրման վերլուծող գրադարան, որը կոչվում է Markdown
:
Markdown
-ն օգտագործելու համար մենք պետք է այն տեղադրենք մեր նախագծում՝ օգտագործելով ստորև նշված հրամանը.
pipenv install markdown
Եկեք ստեղծենք հատուկ ձևանմուշի զտիչ, որն օգտագործում է Markdown
: Ստեղծեք templatetags
գրացուցակ մեր հաղորդագրությունների հավելվածում, այնուհետև markdown_extras.py
ֆայլ, ինչպես ցույց է տրված ստորև:
mkdir posts/templatetags
touch posts/templatetags/markdown_extras.py
Ֆայլն ինքնին կներմուծի նշագրման փաթեթը և կօգտագործի ցանկապատված կոդի բլոկի ընդլայնումը:
# posts/templatetags/markdown_extras.py
from django import template
from django.template.defaultfilters import stringfilter
import markdown as md
register = template.Library()
@register.filter()
@stringfilter
def markdown(value):
return md.markdown(value, extensions=['markdown.extensions.fenced_code'])
Այժմ եկեք բեռնենք հատուկ զտիչը մեր ձևանմուշում, որպեսզի Markdown-ով գրված բովանդակությունը թողարկվի որպես HTML: Մեր blogBody.html
ֆայլն այժմ պետք է այսպիսի տեսք ունենա.
{% load markdown_extras %}
<h4></h4>
<img src="" alt="">
<span>{{article.published_at }}</span>
<p></p>
Նավարկեք 127.0.01:800/բլոգ և կտտացրեք Կարդալ ավելին կոճակը ներքևում: Դուք պետք է վերահղվեք հոդվածի մարմնին, ինչպես ցույց է տրված ստորև:
Postgres-ի տվյալների հարցում Arctype SQL Client-ի միջոցով
PostgreSQL-ում պահվող բլոգի տվյալները դիտելու կամ փոխազդելու համար կարող եք օգտագործել SQL հաճախորդը և տվյալների բազայի կառավարման գործիքը, ինչպիսին է Arctype-ը: Arctype-ն օգտագործելու համար անցեք Arctype-ի գլխավոր էջ և ներբեռնեք Arctype հավելվածը ձեր մեքենայի վրա: Ներկայումս Arctype-ն աջակցում է Linux-ին, Windows-ին և MacOS-ին.
Հավելվածը տեղադրվելուց հետո բացեք այն և ձեզ կառաջարկվի ստեղծել հաշիվ, ինչպես ցույց է տրված ստորև:
Հաշիվ ստեղծելուց հետո ձեզ կառաջարկվի ընտրել ձեր տվյալների բազան: Այս դեպքում ընտրեք Postgres:
Հաջորդ քայլը Postgres-ի հավատարմագրերն ավելացնելն է՝ Arctype-ը ձեր Postgres տվյալների բազայի հետ միացնելու համար: Օգտագործեք այն հավատարմագրերը, որոնք ստեղծել եք Postgres-ի հուշում տվյալների բազա ստեղծելիս:
Հենց որ տվյալների բազայի միացումը հաջող լինի, դուք պետք է կարողանաք մուտք գործել աղյուսակներ Postgres-ի գրառումների տվյալների բազայում, ինչպես ցույց է տրված ստորև:
Եթե ցանկանում եք սովորել, թե ինչպես ստեղծել և գործարկել հարցումներ Arctype-ում, ստուգեք այս ուղեցույցը:
Եզրակացություն
Այս հոդվածում դուք սովորել եք, թե ինչպես ստեղծել բլոգ ձեր կայքում՝ առանց վճարովի բովանդակության կառավարման համակարգ օգտագործելու կամ զրոյից ստեղծելու: Ես ձեզ ուղղորդել եմ ձեր բլոգում Dev.to-ի գրառումները հաջողությամբ ցուցադրելու քայլերով՝ օգտագործելով Django-ն և Dev.to API-ն: Այս բլոգում ներկայացված ամբողջ կոդը հասանելի է GitHub-ում, եթե ձեզ դուր է եկել այս հոդվածը, համոզվեք, որ կառչեք Arctype բլոգում՝ ավելի շատ բովանդակության համար և մինչև հաջորդ անգամ: