როგორ დავიცვათ Flask REST API JSON Web Token?

მოდით ვისწავლოთ როგორ უზრუნველყოთ REST API JSON ვებ ტოქსებით, რათა მომხმარებლებმა და მესამე მხარის აპლიკაციებმა არ გამოიყენონ იგი.


ჩვენ შევქმნით მონაცემთა ბაზის სერვისს გამოყენებით SQLite და საშუალებას მისცემს მომხმარებლებს მას წვდომა ჰქონდეთ REST API– ით HTTP მეთოდების გამოყენებით, როგორიცაა POST და PUT.

გარდა ამისა, ჩვენ გავეცნობით, რატომ არის JSON ვებ ტოქსონები შესაფერისი საშუალება დასვენების API დასაცავად, დაიშურისა და ძირითადი ავთენტიფიკაციის ნაცვლად. სანამ გავაგრძელებთ, გავიგოთ ტერმინი JSON web tokens, REST API და Flask ჩარჩო.

JSON ვებ ტოქსები

JSON ვებ-ნიშანი, ასევე ცნობილია, როგორც JWT, წარმოადგენს ორ მხარეს ან ერთეულს შემთხვევითი ნიშნის გადაცემის უსაფრთხო გზა. JSON ჩვეულებრივ შედგება სამი ნაწილისგან, როგორც შემდეგი.

  • Payload
  • თავსაბურავი
  • ხელმოწერა

JSON იყენებს ორ ტიპის სტრუქტურულ ფორმას ორ მხარეს შორის მონაცემების ან ინფორმაციის გადაცემისას.

  • სერიალიზებულია
  • დესერიალიზაცია

სერიული ფორმა გამოიყენება მონაცემების ქსელში მონაცემების გადაცემისას თითოეული თხოვნისა და პასუხის საშუალებით, ხოლო დესერიალიზებული ფორმა გამოიყენება მონაცემების ინტერნეტ-ნიშანზე წაკითხვისა და წერის დროს..

სერიული ფორმით, არსებობს სამი კომპონენტი.

  • თავსაბურავი
  • Payload
  • ხელმოწერა

სასაქონლო კომპონენტი განსაზღვრავს ტიპების შესახებ კრიპტოგრაფიულ ინფორმაციას. Მაგალითად:

  • არის ის ხელმოწერილი ან ხელმოწერილი JWT?
  • ალგორითმის ტექნიკის განსაზღვრა

დესერიალიზებული ფორმა, სერიული ფორმისგან განსხვავებით, შეიცავს ორ კომპონენტს.

  • Payload
  • თავსაბურავი

REST API

API (განაცხადის პროგრამირების ინტერფეისი) საშუალებას აძლევს კომუნიკაციას ორ პროგრამას შორის მონაცემების მოძიება ან წარდგენა. არსებობს ორი პოპულარული ტიპი API – ვებ და სისტემა API.

ამ სტატიაში, ჩვენ მხოლოდ გადავხედავთ ვებ API- ს. არსებობს ორი ტიპის ვებ API.

  • მოთხოვნა – პასუხის API: დასვენება, GraphQL, დისტანციური პროცედურის ზარი (RPC)
  • მოვლენებზე ორიენტირებული API: WebHooks, Web Sockets, HTTP Streaming

REST API მოთხოვნა-პასუხის კატეგორიას მიეკუთვნება. ის იყენებს HTTP მეთოდებს, როგორიცაა GET, POST და PUT, API ოპერაციების შესასრულებლად.

კლასიკური მაგალითია, როდესაც მომხმარებელი უგზავნის GET მეთოდს ვებ – სერვისში, რომ მოითხოვოს ან მოიპოვოს კონკრეტული რესურსი ან რესურსების შეგროვება. სერვერი შემდეგ აგზავნის სპეციფიკურ რესურსს ან რესურსების შეგროვებას იმ მომხმარებლისთვის, ვინც ამას ითხოვდა.

ფლაკონის ჩარჩო

Flask არის ჩარჩო, რომელიც დაფუძნებულია პითონზე. ეს არის მიკრო ჩარჩო, რომელსაც Python– ის დეველოპერები იყენებენ დანარჩენი API– ს დასამყარებლად. მას უწოდებენ მიკრო ჩარჩოს, რადგან ის საშუალებას აძლევს დეველოპერებს, დაამატოთ პერსონალური ავტორიზაცია და ნებისმიერი სხვა სარეზერვო სისტემა, პრეფერენციებზე დაყრდნობით..

დავიწყოთ მისი შესრულებით. ჩემი სისტემის დაყენება შემდეგია.

  • Ubuntu როგორც OS
  • პითონი 2.7+
  • ფოსტალიონი

ვირტუალური გარემოს შექმნა ვირტუალურივის გამოყენებით

ჩვენ უნდა შევქმნათ ვირტუალური გარემო იმისთვის, რომ ზოგიერთი პაკეტი არ ეწინააღმდეგებოდეს სისტემის პაკეტებს. მოდით გამოვიყენოთ virtualenv ახალი ვირტუალური გარემოს დასაყენებლად.

თუ ვიმსჯელებთ, რომ თქვენს პიპზე ხელმისაწვდომია pip ბრძანება, დააინსტალირეთ შემდეგი ბრძანება pip– ის მეშვეობით, რომ დააინსტალიროთ.

პიპ ინსტალაცია virtualenv

თუ თქვენს აპარატზე პიპი არ გაქვთ, მიჰყევით ამას დოკუმენტაცია დააყენოთ პიპი თქვენს სისტემაში.

შემდეგი, მოდით შევქმნათ დირექტორია, რომ შევინახოთ ან შეინახოთ ჩვენი ვირტუალური გარემო. გამოიყენეთ ქვემოთ მითითებული mkdir ბრძანება, დირექტორია რომ შექმნათ

mkdir flaskproject

შეიცვალეთ flaskproject დირექტორიაში შემდეგი ბრძანების გამოყენებით

cd flaskproject

ვირტუალურ გარემოს შესაქმნელად გამოიყენეთ ვირტუალური გარემოს ინსტრუმენტი, რომელიც ნაჩვენებია ქვემოთ:

virtualenv flaskapi

მას შემდეგ, რაც ვირტუალური გარემოს შესაქმნელად გამოიყენეთ virtualenv ინსტრუმენტი, განახორციელეთ cd ბრძანება, რომ შეიცვალოთ flaskapi დირექტორიაში, როგორც ვირტუალური გარემო და გააქტიურეთ იგი ქვემოთ მოცემული ბრძანების გამოყენებით.

წყაროს ყუთი / გააქტიურება

შეასრულეთ ამ პროექტთან დაკავშირებული ყველა დავალება ვირტუალურ გარემოში.

დააინსტალირეთ პაკეტები პიპის გამოყენებით

ახლა დროა დავაყენოთ ისეთი პაკეტები, როგორიცაა ფარკის ჩარჩო და PyJWT, რომელსაც ჩვენ გამოვიყენებთ დანარჩენი API და სხვა საჭირო პაკეტების მისაღებად ჩვენი API პროექტისთვის.

შექმენით მოთხოვნები.txt ფაილი შემდეგი პაკეტებით.

ფლაკონი
დრო
uuid
ფლაკ-SQLAlhemhemy
PyJWT

დააინსტალირეთ პიპით.

პიპ ინსტალაცია -r მოთხოვნები.txt

მონაცემთა ბაზის შექმნა

მოდით დავაყენოთ SQLite.

apt-get install sqlite3

შექმენით მონაცემთა ბაზა, სახელწოდებით ბიბლიოთეკა. ამ მონაცემთა ბაზის შიგნით, ჩვენ შევქმნით ორ ცხრილს, კერძოდ მომხმარებელთა და ავტორთა ცხრილს.

მომხმარებელთა ცხრილი შეიცავს რეგისტრირებულ მომხმარებლებს. მხოლოდ რეგისტრირებულ მომხმარებლებს შეუძლიათ ავტორების ცხრილში წვდომა.

ავტორთა ცხრილში განთავსდება ავტორთა ინფორმაცია ან დეტალები, როგორიცაა ავტორს სახელი, დაბადების ქვეყანა და ა.შ..

შექმენით მონაცემთა ბაზა შემდეგი ბრძანების გამოყენებით:

sqlite3 ბიბლიოთეკა.db

შეგიძლიათ შეამოწმოთ თუ არა თქვენ წარმატებით შექმენი მონაცემთა ბაზა ქვემოთ მოცემული ბრძანების გამოყენებით:

.მონაცემთა ბაზა

გახსენით ახალი ტერმინალი და შეასრულეთ შემდეგი ადრე შექმნილ ვირტუალურ გარემოში.

შეეხეთ app.py

ჩასვით შემდეგი კოდი ფაილის სახელით app.py

ფარშის იმპორტიდან ფლაკონი, მოთხოვნა, jsonify, make_response
საწყისი flask_sqlalchemy იმპორტის SQLAlchemy
werkzeug.security იმპორტისგან generate_password_hash, check_password_hash
იმპორტის გამოყენება
იმპორტი jwt
იმპორტის დრო
საწყისი functools იმპორტი გადატანა

პირველი კოდის ზემოთ მოცემულია ისეთი პაკეტები, როგორიცაა მოთხოვნა და jsonify. ჩვენ გამოვიყენებთ თხოვნას, რომ თვალყური ადევნოთ მოთხოვნის დონის მონაცემებს მოთხოვნის დროს და გამოვიყენოთ jsonify გამომავალი პასუხებისთვის JSON ფორმატში.

შემდეგ ხაზზე, ჩვენ შემოვიტანეთ SQLAlchemy საწყისი flask_sqlalchemy, რათა განვათავსოთ SQLAlchemy თვისებები ფარაში..

Werkzeug.security– დან ჩვენ შემოვიტანეთ generate_password_hash, მომხმარებლისათვის პაროლის ჰეშტის შესაქმნელად და check_password_hash– ის შესამოწმებლად, მომხმარებლის პაროლი, მომხმარებლის მიერ წარმოდგენილი პაროლის შედარებისას, მონაცემთა ბაზაში დაცულ მომხმარებელთა პაროლებთან..

დაბოლოს, ჩვენ შემოვიტანეთ uuid, რომელიც ასევე ცნობილია როგორც უნივერსალური უნიკალური იდენტიფიკატორი, მომხმარებლისათვის შემთხვევითი პირადობის ნომრების შესაქმნელად.

მიუხედავად ამისა, app.py ფაილის შიგნით განახორციელეთ ბიბლიოთეკის API- ის კონფიგურაციის პარამეტრები, ქვემოთ მოყვანილი კოდის გამოყენებით app.py ფაილის შიგნით..

განათავსეთ შემდეგი კოდი იმპორტის განცხადების ქვეშ.

აპი = ფლაკი (__ სახელი__)

app.config [‘SECRET_KEY’] = ‘Th1s1ss3cr3t’
app.config [‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite: /////home/michael/geekdemos/geekapp/library.db’
app.config [‘SQLALCHEMY_TRACK_MODIFICATIONS’] = მართალია

db = SQLAlchemy (აპლიკაცია)

ახლა შექმენით ორი მოდელი მომხმარებლებისა და ავტორთა ცხრილისთვის, როგორც ქვემოთ მოცემულია. დააკოპირეთ და ჩასვით კოდი app.py ფაილში.

მოათავსეთ კოდი ქვემოთ მოცემული მონაცემთა ბაზის ქვეშ, db = SQLAlchemy (app)

კლასის მომხმარებლები (db.Model):
id = db.Column (db.Integer, basic_key = True)
public_id = db. Column (db.Integer)
name = db. Column (db.String (50))
პაროლი = db.Column (db.String (50))
ადმინ = db. Column (db.Boolean)
კლასის ავტორები (დბ.მოდელი):
id = db.Column (db.Integer, basic_key = True)
name = db.Column (db.String (50), უნიკალური = მართალია, nullable = მცდარი))
წიგნი = db.Column (db.String (20), უნიკალური = მართალია, nullable = მცდარი))
ქვეყანა = db. Column (db.String (50), nullable = False))
booker_prize = db. Column (db.Boolean)

შექმენით მომხმარებლები და ავტორები მაგიდები

ტერმინალზე მიუთითეთ შემდეგი კოდი ვირტუალურ გარემოში, რათა შექმნათ ან შექმნათ ცხრილი როგორც მომხმარებლების, ასევე ავტორთა ცხრილები, როგორც ეს მოცემულია ქვემოთ

საწყისი იმპორტიდან db
db.create_all ()

ამის შემდეგ, გახსენით app.py ფაილი ვირტუალურ გარემოში და შექმენით სხვა ფუნქცია.

ეს ფუნქცია წარმოქმნის ტოქსენს, რათა მხოლოდ რეგისტრირებულ მომხმარებლებს შეეძლოთ წვდომა და განახორციელონ API ოპერაციების მთელი რიგი ავტორების ცხრილის საწინააღმდეგოდ..

მოათავსეთ ეს კოდი მონაცემთა ბაზის მოდელის ქვეშ, ავტორთა ცხრილისთვის

def token_required (f):
@wraps (ვ)
დეფის დეკორატორის (* არგუმენტები, ** კვარტალი):

token = არცერთი

თუ მოთხოვნით ‘x- წვდომის ნიშნები’. თავში:
token = request.headers [‘x- წვდომის ნიშნები’]

თუ არა ნიშანი:
Return jsonify (message ‘გაგზავნა’: ‘მართებული ნიშანი არ აკლია’})

სცადე:
მონაცემები = jwt.decode (ნიშანი, app.config [SECRET_KEY])
current_user = Users.query.filter_by (public_id = მონაცემები [‘public_id’]). პირველი ()
გარდა:
Return jsonify (message ‘გაგზავნა’: ‘ნიშანი არასწორია’})

დაბრუნება f (current_user, * args, ** kwargs)
დაბრუნება დეკორატორი

შექმენით მარშრუტები მომხმარებლების ცხრილში

ახლა შევქმნათ მარშრუტი, რომლის საშუალებითაც მომხმარებლებს შეეძლებათ დარეგისტრირდნენ ავტორთა API მომხმარებლის სახელი და პაროლი, როგორც ეს მოცემულია ქვემოთ.

კვლავ გახსენით app.py ფაილი ვირტუალურ გარემოში და ჩასვით შემდეგი კოდი ფუნქციის token_required (f)

@ app.route (‘/ რეგისტრაცია’, მეთოდები = [‘მიიღეთ’, ‘POST’])
def signup_user ():
მონაცემები = მოთხოვნა.get_json ()

hashed_password = generate_password_hash (მონაცემები [‘პაროლი’], მეთოდი = ‘sha256’)

new_user = მომხმარებლები (public_id = str (uuid.uuid4 ()), name = data [‘name’], პაროლი = hashed_password, ადმინ = მცდარი)
db.session.add (new_user)
db.session.commit ()

Return jsonify (message ‘გაგზავნა’: ‘წარმატებით დარეგისტრირებული’)

ვირტუალურ გარემოში, შექმენით სხვა მარშრუტი app.py ფაილში, რათა რეგისტრირებულ მომხმარებლებს შეხვიდეთ.

როდესაც მომხმარებელი შესვლა ხდება, შემთხვევითი ნიშანი იქმნება მომხმარებლისთვის ბიბლიოთეკის API- ზე შესასვლელად.

ჩასვით კოდი ჩვენს მიერ შექმნილ წინა მარშრუტზე.

@ app.route (‘/ შესვლა’, მეთოდები = [‘მიიღეთ’, ‘POST’])
def login_user ():

auth = მოთხოვნა.ავტორიზაცია

თუ არა auth.username ან არა auth.password:
დაბრუნება make_response (‘ვერ გადამოწმება’, 401, {‘WWW.Anthentication’: ‘ძირითადი სფერო: "შესვლა საჭიროა"’})

მომხმარებელი = Users.query.filter_by (სახელი = auth.username) .პირველი ()

თუ check_password_hash (user.password, auth.password):
token = jwt.encode ({‘public_id’: user.public_id, ‘exp’: datetime.datetime.utcnow () + datetime.timedelta (წუთი = 30)}, app.config [‘SECRET_KEY’])
Return jsonify (tok ‘token’: token.decode (‘UTF-8’)})

დაბრუნება make_response (‘ვერ გადამოწმება’, 401, {‘WWW.Anthentication’: ‘ძირითადი სფერო: "შესვლა საჭიროა"’})

და მაინც, ვირტუალურ გარემოში შექმენით სხვა მარშრუტი app.py ფაილში, რომ მიიღოთ ან მიიღოთ ყველა რეგისტრირებული მომხმარებელი.

ეს კოდი ამოწმებს მომხმარებლების ცხრილში ყველა რეგისტრირებულ მომხმარებელს და აბრუნებს საბოლოო შედეგს JSON ფორმატით.

ჩასვით კოდი ჩასასვლელი მარშრუტის ქვემოთ

@ app.route (‘/ / მომხმარებლები’, მეთოდები = [‘მიიღეთ’])
def get_all_users ():

მომხმარებლები = Users.query.all ()

შედეგი = []

მომხმარებლისთვის მომხმარებლებში:
user_data =}
user_data [‘public_id’] = user.public_id
user_data [‘name’] = user.name
user_data [‘პაროლი’] = user.password
user_data [‘admin’] = user.admin

შედეგი.append (user_data)

Return jsonify (users ‘მომხმარებლები’: შედეგი})

შექმენით მარშრუტები ავტორთა ცხრილში 

მოდით შევქმნათ ავტორები ცხრილისთვის, რათა მომხმარებლებმა მონაცემთა ბაზაში ყველა ავტორს დავაბრუნოთ და ავტორები წაშალოთ.

მხოლოდ მოქმედი ტოქსების მომხმარებლებს შეუძლიათ შეასრულონ ეს API ოპერაციები.

App.py ფაილის შიგნით შექმენით მარშრუტი დარეგისტრირებულ მომხმარებლებზე, რომ შექმნან ახალი ავტორები.

ჩასვით ეს კოდი მარშრუტის ქვეშ, რომლის საშუალებითაც მომხმარებელს შეუძლია დაიბრუნოს ყველა რეგისტრირებული მომხმარებელი.

@ app.route (‘/ ავტორი’, მეთოდები = [‘POST’, ‘მიიღეთ’])
@token_required
def შექმნა_author (current_user):

მონაცემები = მოთხოვნა.get_json ()

new_autectors = ავტორები (სახელი = მონაცემები [‘სახელი’], ქვეყანა = მონაცემები [‘ქვეყანა’], წიგნი = მონაცემები [‘წიგნი’], booker_prize = მართალია, user_id = current_user.id)
db.session.add (new_autectors)
db.session.commit ()

Return jsonify (message ‘გაგზავნა’: ‘შეიქმნა ახალი ავტორი’)

შემდეგი, შექმენით სხვა მარშრუტი, რომ დარეგისტრირებულ მომხმარებელს სწორი ნიშანი ჰქონდეთ, რომ ავტორების ცხრილში ყველა ავტორია, როგორც ეს მოცემულია ქვემოთ.

ჩასვით ეს კოდი მარშრუტის ქვემოთ, რაც მომხმარებელს საშუალებას აძლევს შექმნას ახალი ავტორი.

@ app.route (‘/ ავტორები’, მეთოდები = [‘POST’, ‘მიღება’])
@token_required
def get_autectors (current_user):

ავტორები = Autories.query.filter_by (user_id = current_user.id) .all ()

გამომავალი = []
ავტორი ავტორებისთვის:

author_data = {}
author_data [‘name’] = author.name
author_data [‘book’] = author.book
author_data [‘ქვეყანა’] = author.country
author_data [‘booker_prize’] = author.booker_prize
გამომავალი.append (author_data)

დაბრუნება jsonify (list ‘list_of_autectors’: გამომავალი})

დაბოლოს, ჯერ კიდევ app.py ფაილის შიგნით, შექმენით მარშრუტი, რომ წაშალოთ მითითებული ავტორი, როგორც ეს მოცემულია ქვემოთ.

ჩასვით ეს კოდი მარშრუტის ქვეშ, რომელიც საშუალებას აძლევს მომხმარებელს აიღოს ავტორთა სია.

@ app.route (‘/ ავტორები /’, მეთოდები = [‘DELETE’])
@token_required
def Delete_author (current_user, author_id):
ავტორი = Author.query.filter_by (id = author_id, user_id = current_user.id) .პირველი ()
თუ არა ავტორი:
Return jsonify (message ‘გაგზავნა’: ‘ავტორი არ არსებობს’)

db.session.delete (ავტორი)
db.session.commit ()

Return jsonify (message ‘გაგზავნა’: ‘ავტორი ამოღებულია’)

თუ __name__ == ‘__main__’:
app.run (გამართვა = მართალია)

ამის შემდეგ შეინახეთ და დახურეთ app.py ფაილი ვირტუალურ გარემოში.

ბიბლიოთეკის API ტესტირება Postman- ით

ამ განყოფილებაში ჩვენ გამოვიყენებთ ფოსტალიონის ხელსაწყოს საშუალებით, რომლითაც მოთხოვნის გაგზავნა ხდება მონაცემთა ბაზის სერვისებში. თუ თქვენ არ გაქვთ ფოსტალიონი თქვენს აპარატში, შეგიძლიათ გაიგოთ როგორ გადმოწეროთ და დააინსტალიროთ იგი აქ.

ფოსტალიონის გარდა, ჩვენ შეგვიძლია გამოვიყენოთ სხვა საშუალებები, როგორიცაა ტალღოვანი სერვერზე მოთხოვნის გაგზავნა.

გახსენით ახალი ტერმინალი და აკრიფეთ შემდეგი:

ფოსტალიონი

ბრძანების გამომგზავნი გამოიწვევს თქვენს ბრაუზერს, რომ ქვემოთ მოყვანილი გვერდი აჩვენოს:

postman_signup

თქვენ შეგიძლიათ გადაწყვიტოთ დარეგისტრირება და შექმნათ უფასო ანგარიში, მაგრამ ჩვენ გამოტოვებთ და პირდაპირ მივიღებთ პროგრამას ბიბლიოთეკის API– ს შესამოწმებლად, როგორც ეს ნაჩვენებია ქვემოთ:

გამოცადეთ ბიბლიოთეკა api

ამ განყოფილებაში, ჩვენ საშუალებას მისცემს მომხმარებელს დაარეგისტრიროს ბიბლიოთეკის API, მომხმარებლის სახელი და უნიკალური პაროლი JSON ფორმატით, POST მეთოდის გამოყენებით, შემდეგი ნაბიჯების გამოყენებით:

  • დააჭირეთ ჩანართს, რომელსაც ეტიკეტია Body
  • შემდეგ შეარჩიეთ ნედლეული ღილაკი და შეარჩიეთ JSON ფორმატში
  • შეიყვანეთ სახელი და პაროლი, რომ დარეგისტრირდეთ, როგორც ნაჩვენებია ეკრანის სურათზე
  • გაგზავნის ღილაკის გარდა, ჩადეთ შემდეგი URL http://127.0.0.1/register
  • დაბოლოს, შეცვალეთ მეთოდი POST და დააჭირეთ გაგზავნის ღილაკს.

მომხმარებელი დარეგისტრირდება api- სთვის

ეს აჩვენებს შემდეგ გამომავალს, როგორც ქვემოთ მოცემულია:

ახლა ჩვენ წარმატებით დავარეგისტრირეთ მომხმარებელი. მოდით, წინ მივუდგეთ იმ მომხმარებელს, რომელიც ახლახან დარეგისტრირდა, რათა დროებითი შემთხვევითი ნიშნის შექმნა შექმნას ავტორთა ცხრილში, შემდეგი ნაბიჯების გამოყენებით:

  •  დააჭირეთ ავტორიზაციის ჩანართს.
  • ტიპის განყოფილების ქვეშ აირჩიეთ ძირითადი ავთენტიფიკაცია.
  • შემდეგ შეავსეთ მომხმარებლის სახელი და პაროლი ფორმა, ადრე დარეგისტრირებულ მომხმარებლის სახელით და პაროლით.
  • დაბოლოს, დააჭირეთ გაგზავნის ღილაკს შესასვლელად და შექმენით შემთხვევითი ნიშანი.

მას შემდეგ, რაც მომხმარებელი წარმატებით შეხვალთ, მომხმარებლისთვის შემთხვევითი ნიშანი იქმნება, როგორც ნაჩვენებია ეკრანის სურათზე.

გამოვიყენებთ შემთხვევითი ნიშნის გამოყენებას ავტორთა ცხრილში შესასვლელად.

ამ განყოფილებაში ავტორთა ცხრილს ავტორთა ცხრილს დავამატებთ POST მეთოდით შემდეგი ნაბიჯების გამოყენებით:

  • დააჭირეთ სათაურების ჩანართს
  • ჩართეთ ეკრანის სურათზე ნაჩვენები შემდეგი HTTP სათაურები

  • შემდეგი, დააჭირეთ ტაბულას და მიუთითეთ ახალი ავტორის დეტალები
  • შემდეგ დააჭირეთ გაგზავნის ღილაკს, რომ დაამატეთ ავტორის დეტალები ავტორთა ცხრილში

ასევე შეგიძლიათ ავტორთა ცხრილში მოძიება ავტორთა ცხრილში შემდეგით:

  • დარწმუნდით, რომ თქვენი შექმნილი ნიშანი არის სათაურების განყოფილებაში. თუ ის იქ არ არის, თქვენ უნდა შეავსოთ იგი თქვენი ნიშნით.
  • გაგზავნის ღილაკის გარდა, შეიყვანეთ ეს URL http://127.0.0.1/autectors
  • შემდეგ შეცვალეთ HTTP მეთოდი GET და დააჭირეთ გაგზავნის ღილაკს ავტორების დეტალების მისაღებად.

დაბოლოს, ავტორთა ცხრილში შეგიძლიათ წაშალოთ ავტორ (ებ) ის DELETE მეთოდით შემდეგი ნაბიჯების გამოყენებით:

  • დარწმუნდით, რომ თქვენი ნიშანი კვლავ სათაურების განყოფილებაშია. თქვენ შეგიძლიათ აკონტროლოთ სათაურების ჩანართი იმისთვის, რომ უზრუნველყოთ საჭირო ინფორმაცია.
  • გაგზავნის ღილაკის გარდა, შეიყვანეთ ეს URL http://127.0.0.1/sam
  • შემდეგ დააჭირეთ გაგზავნის ღილაკს თქვენს მიერ მითითებული მომხმარებლის წაშლისთვის.

შეგიძლიათ იპოვოთ სრული კოდის შესახებ გითუბი.  შეგიძლიათ დააკოპიროთ ის და შეამოწმოთ ის თქვენს აპარატზე.

ტეგები:

  • პითონი

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map