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 բլոգում՝ ավելի շատ բովանդակության համար և մինչև հաջորդ անգամ: