1. რა არის REST API ?

რა არის აპლიკაციის პროგრამირების ინტერფეისი ?

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

რა არის REST ?

პირველ რიგში გავარკვიოთ თუ საიდან მოდის ეს დასახელება - ინგ : Representational State Transfer, ანუ წარმოდგენის, პრეზენტაციის მდგომარეობის ტრანსფერი. ახლა შევეცადოთ გავარკვიოთ თუ რას ნიშნავს ეს :))

განვიხილოთ HTTP პროტოკოლის კლასიკური მაგალითი :

რეპრეზენტაცია (Representation)

მომხმარებელმა გაგზავნა მოთხოვნა სერვერზე (მაგ: მაუსი დააჭირა ბმულს, ღილაკს, აკრიფა რომელიმე ვებ-გვერდის მისამართი ბრაუზერის სამისამართო ველში და ა.შ). სერვერმა პასუხად დააბრუნა წყარო, რესურსი, ინფორმაცია (resource). აღსანიშნავია, რომ ხშირ შემთხვევაში შეუძლებელია ამ რესურსის მომხმარებელთან იმ სახით მიტანა, რომლითაც სერვერზეა შენახული. იგი აუცილებლად ადვილად წაკითხვადი და გარჩევადი უნდა იყოს მისთვის, მაგალითად ბრაუზერში უნდა იხილოს ფოტო, ან მიიღოს ინფორმაცია მისთვის სასურველ ფორმატში (JSON, XML ...). სწორედ ამიტომ საჭიროა პასუხად წამოსული ინფორმაციის დამუშავება (მაგალითად HTML-ის მიერ). პროცესს რომლის დასრულების შემდეგაც ეს რესურსი ხდება მომხმარებლისათვის ადვილად წაკითხვადი და ასევე ფორმატდება მისთვის სასურველ ფორმატში, ეწოდება რეპრეზენტაცია.

მაგალითისათვის თუ შევალთ ამ მისამართზე : http://vnadiradze.ge/info/rest/images/3.jpg ვიხილავთ უშუალოდ ფოტოს, ხოლო პასუხის აღწერილობასა და სათაურებსაც (headers) თუ გადავამოწმებთ დავინახავთ, რომ სერვერიდან მიღებული ინფორმაციის რეპრეზენტაცია ანუ ჩვენამდე მოტანა მოხდა "image/jpeg" ფორმატში:



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



მდგომარეობა (State)

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

ტრანსფერი (Transfer)

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

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





მაგალითად თუ გადავამოწმებთ ამ გვერდის მოთხოვნა-პასუხის მახასიათებლებს, სადაც ეხლა ვიმყოფებით დავინახავთ, რომ ჩვენი მოთხოვნის ტიპი არის GET :



მოთხოვნის ყველაზე გავრცელებული ტიპებია : GET, POST, PUT, DELETE. ნებისმიერი ამ მეთოდით სერვერთან მიმართვისას ხდება ინფორმაციის გაცვლა-გამოცვლა მომხმარებელსა და სერვერს შორის. სწორედ ეს გაცვლა-გამოცვლა, მოიაზრება "Representational State Transfer" განმარტების მე-3-ე სიტყვის - "Transfer"-ის უკან.

REST არქიტექტურა

წვდომის წერტილი (Endpoint)

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

***

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

როდესაც დეველოპერი მუშაობს REST API-სთან, ბუნებრივია, რომ მისთვის ხშირ შემთხვევაში ხელსაყრელი არ იქნება ინფორმაციის იმ ფორმატში მიღება, რომელიც მისაღებია ჩვეულებრივი მომხმარებლისათვის. ყველაზე გავრცელებული საჭირო ფორმატებია :
  • REST
  • XML-RPC
  • SOAP
  • JSON
  • Serialized PHP
2. მარტივი REST API-ს შექმნა (PHP - PDO)

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

კატეგორიების ცხრილი

CREATE TABLE `categories` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(255) NOT NULL,
    `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`)
);                    
                
INSERT INTO `categories` (`id`, `name`, `created_at`) VALUES
(1, 'Laravel', '2019-10-11 12:48:39'),
(2, 'PHP', '2019-10-11 12:48:39'),
(3, 'Javascript', '2019-10-11 12:48:39'),
(4, 'Angular', '2019-10-11 12:48:39'),
(5, 'CSS', '2019-10-11 12:48:39');

სიახლეების ცხრილი

CREATE TABLE `posts` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `category_id` int(11) NOT NULL,
    `title` varchar(255) NOT NULL,
    `body` text NOT NULL,
    `author` varchar(255) NOT NULL,
    `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (`id`)
);                   
                
INSERT INTO `posts` (`id`, `category_id`, `title`, `body`, `author`, `created_at`) VALUES
(1, 1, 'Laravel ცნობარი', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.', 'თვით კოტე', '2019-10-11 12:49:21'),
(2, 2, 'PHP დამწყებთათვის', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.\r\n\r\n', 'ჩვენი კოტე', '2019-10-11 12:49:21'),
(3, 1, 'რა არის Laravel ?', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.', 'კოტე ჩვენი', '2019-10-11 12:49:21'),
(4, 4, 'Angular წიგნი', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.', 'კოტე თვით', '2019-10-11 12:49:21'),
(5, 4, 'რატომ Angular-ი ?', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.', 'ქეთო და კოტე', '2019-10-11 12:49:21'),
(6, 1, 'Laravel-ის ისტორია', 'შემთხვევითად გენერირებული ტექსტი ეხმარება დიზაინერებს და ტიპოგრაფიული ნაწარმის შემქმნელებს, რეალურთან მაქსიმალურად მიახლოებული შაბლონი წარუდგინონ შემფასებელს. ხშირადაა შემთხვევა, როდესაც დიზაინის შესრულებისას საჩვენებელია, თუ როგორი იქნება ტექსტის ბლოკი. სწორედ ასეთ დროს არის მოსახერხებელი ამ გენერატორით შექმნილი ტექსტის გამოყენება, რადგან უბრალოდ „ტექსტი ტექსტი ტექსტი“ ან სხვა გამეორებადი სიტყვების ჩაყრა, ხელოვნურ ვიზუალურ სიმეტრიას ქმნის და არაბუნებრივად გამოიყურება.', 'მარტო კოტე', '2019-10-11 12:49:21');

სტანდარტული პროცესები

პროექტის ძირ საქაღალდეში შევქმნათ საქაღალდე config, მასში კი ფაილი - Database.php. ამ ფაილში აღვწეროთ ბაზასთან დასაკავშირებელი კოდი : 
<?php

class Database 
{
    private $host = 'localhost';
    private $db_name = 'rest';
    private $username = 'root';
    private $password = '';
    private $conn;

    public function connect() 
    {
        $this->conn = null;
        
        try 
        {
            $this->conn = new PDO('mysql:host=' . $this->host . ';dbname=' . $this->db_name, $this->username, $this->password, array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
            $this->conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        } 
        catch (PDOException $e) 
        {
            echo 'Connection Error: ' . $e->getMessage();
        }
        
        return $this->conn;
    }

}
პროექტის ძირ საქაღალდეში შევქმნათ კიდევ ერთი საქაღალდე models, მასში კი ფაილი - Post.php. ამ ფაილში აღვწეროთ სიახლეებთან სამუშაო კლასი : 
<?php

class Post 
{
    // DB 
    private $conn;
    private $table = 'posts';
    
    // სიახლის ატრიბუტები
    public $id;
    public $category_id;
    public $category_name;
    public $title;
    public $body;
    public $author;
    public $created_at;

    // ბაზასთან დაკავშირება კონსტრუქტორში
    public function __construct($db) 
    {
        $this->conn = $db;
    }

    // სიახლეების ამოღება ბაზიდან
    public function read() 
    {
        // ბრძანების ტანი
        $query = 'SELECT c.name as category_name, p.id, p.category_id, p.title, p.body, p.author, p.created_at
                                FROM ' . $this->table . ' p
                                LEFT JOIN
                                  categories c ON p.category_id = c.id
                                ORDER BY
                                  p.created_at DESC';

        // წინასწარგანსაზღვრული ბრძანების გენერირება
        $stmt = $this->conn->prepare($query);
        
        // ბრძანების შესრულება
        $stmt->execute();
        
        return $stmt;
        
    }

    // კონკრეტული სიახლის ამორება
    public function read_single() 
    {
        $query = 'SELECT c.name as category_name, p.id, p.category_id, p.title, p.body, p.author, p.created_at
                                    FROM ' . $this->table . ' p
                                    LEFT JOIN
                                      categories c ON p.category_id = c.id
                                    WHERE
                                      p.id = ?
                                    LIMIT 0,1';
        
        $stmt = $this->conn->prepare($query);
        
        $stmt->bindParam(1, $this->id);
        
        $stmt->execute();
        $row = $stmt->fetch(PDO::FETCH_ASSOC);
        
        $this->title = $row['title'];
        $this->body = $row['body'];
        $this->author = $row['author'];
        $this->category_id = $row['category_id'];
        $this->category_name = $row['category_name'];
    }

    // სიახლის შექმნა
    public function create() 
    {
        $query = 'INSERT INTO ' . $this->table . ' SET title = :title, body = :body, author = :author, category_id = :category_id';
       
        $stmt = $this->conn->prepare($query);
        
        $this->title = htmlspecialchars(strip_tags($this->title));
        $this->body = htmlspecialchars(strip_tags($this->body));
        $this->author = htmlspecialchars(strip_tags($this->author));
        $this->category_id = htmlspecialchars(strip_tags($this->category_id));
        
        $stmt->bindParam(':title', $this->title);
        $stmt->bindParam(':body', $this->body);
        $stmt->bindParam(':author', $this->author);
        $stmt->bindParam(':category_id', $this->category_id);
        
        if ($stmt->execute()) 
        {
            return true;
        }
        
        printf("Error: %s.\n", $stmt->error);
        
        return false;
    }

    // სიახლის განახლება
    public function update() 
    {
        $query = 'UPDATE ' . $this->table . '
                                SET title = :title, body = :body, author = :author, category_id = :category_id
                                WHERE id = :id';
        
        $stmt = $this->conn->prepare($query);
        
        $this->title = htmlspecialchars(strip_tags($this->title));
        $this->body = htmlspecialchars(strip_tags($this->body));
        $this->author = htmlspecialchars(strip_tags($this->author));
        $this->category_id = htmlspecialchars(strip_tags($this->category_id));
        $this->id = htmlspecialchars(strip_tags($this->id));
        
        $stmt->bindParam(':title', $this->title);
        $stmt->bindParam(':body', $this->body);
        $stmt->bindParam(':author', $this->author);
        $stmt->bindParam(':category_id', $this->category_id);
        $stmt->bindParam(':id', $this->id);
        
        if ($stmt->execute()) 
        {
            return true;
        }
        
        printf("Error: %s.\n", $stmt->error);
        
        return false;
    }

    // სიახლის წაშლა
    public function delete() 
    {
        $query = 'DELETE FROM ' . $this->table . ' WHERE id = :id';
        
        $stmt = $this->conn->prepare($query);
        
        $this->id = htmlspecialchars(strip_tags($this->id));
        
        $stmt->bindParam(':id', $this->id);
        
        if ($stmt->execute()) 
        {
            return true;
        }
        
        printf("Error: %s.\n", $stmt->error);
        
        return false;
    }

}

ინფორმაციის წაკითხვა

პროექტის ძირ საქაღალდეში შევქმნათ საქაღალდე api, მასში ქვე-საქაღალდე post, ხოლო ამ უკანასკნელში კი ფაილი - read.php. ამ ფაილში აღწერილი კოდის მეშვეობით მოვახერხებთ სიახლეების შესახებ ინფორმაციის მიღებას.

Access-Control-Allow-Origin

Access-Control-Allow-Origin განსაზღვრავს სხვადასხვა წყაროებს შორის ინფორმაციის გაზიარების ჩარჩოებს, ანუ არის CORS (Cross-Origin Resource Sharing) სათაური.

როდესაც საიტი A ცდილობს ინფორმაციის მიღებას საიტ B-დან, საიტ B-ს შეუძლია პასუხი გააგზავნოს სათაურით (header) Access-Control-Allow-Origin, ამ სათაურის მეშვეობით ბრაუზერი დაადგენს თუ რომელი წყაროებისთვისაა ხელმისაწვდომი საიტ B-ზე მოთხოვნილი ინფორმაცია (წყარო შეიძლება იყოს რომელიმე დომენი ან იპ მისამართი). ნაგულისხმეობის პრინციპით ნებისმიერი საიტის ნებისმიერ ინფორმაციასთან "დაუკითხავად წვდომა" შეზღუდულია, Access-Control-Allow-Origin სათაური კი ამის საშუალებას აძლევს კონკრეტულ ან ყველა წყაროს.

გამოყენების მაგალითები

პასუხი, რომელიც ბრაუზერს ეუბნება, რომ ინფორმაცია ხელმისაწვდომია ნებისმიერი წყაროსათვის Access-Control-Allow-Origin: * პასუხი, რომელიც ბრაუზერს ეუბნება, რომ ინფორმაცია ხელმისაწვდომია მხოლოდ კონკრეტული წყაროსათვის Access-Control-Allow-Origin: http://vnadiradze.ge

Content-Type

ამ სათაურის მეშვეობით ბრაუზერი ადგენს თუ რა ტიპისაა სერვერიდან პასუხად დაბრუნებული ინფორმაცია. მაგალთად : Content-Type: text/html; charset=UTF-8 Content-Type: multipart/form-data; boundary=something

დავუბრუნდეთ ჩვენს read.php ფაილს :)) შევიტანოთ მასში შემდეგი კოდი : 
<?php


// სათაურები
header('Access-Control-Allow-Origin: *'); // ინფორმაცია ხემლისაწვდომია ყველა წყაროსათვის
header('Content-Type: application/json'); // ინფორმაცია დაპორმატდება json ფორმატში

include_once '../../config/Database.php';
include_once '../../models/Post.php';

// კავშირი მბ-სთან
$database = new Database();
$db = $database->connect();

// სიახლის ობიექტი
$post = new Post($db);

// სიახლეების ამოღება ბაზიდან
$result = $post->read();

// ამოღებული ჩანაწერების დათვლა
$num = $result->rowCount();

// თუ მოიძებნა რაიმე ბაზაში
if($num > 0) 
{
    // სიახლეების მასივი
    $posts_arr = array();
    
    while ($row = $result->fetch(PDO::FETCH_ASSOC)) 
    {
        extract($row);
        $post_item = array(
            'id' => $id,
            'title' => $title,
            'body' => html_entity_decode($body),
            'author' => $author,
            'category_id' => $category_id,
            'category_name' => $category_name
        );
        
        array_push($posts_arr, $post_item);
    }
    
    // ინფორმაციის დაფორმატება json ფორმატში
    echo json_encode($posts_arr);
} 
else 
{
    // ვერაფერი მოიძებნა ბაზაშო
    echo json_encode(array('message' => 'ვერაფერი მოიძებნა'));
}
თუ ახლა ამ მისამართზე : http://localhost/projects/rest/api/post/read.php (მწვანე ფერით მონიშნულია ჩვენი API-ს წვდომის წერტილი (endpoint), რომლის შესახებაც ზემოთ ვისაუბრეთ). გავგზავნით GET ტიპის მოთხოვნას, ვიხილავთ შემდეგ სურათს :



კონკრეტული ინფორმაციის წაკითხვა

models/Post.php ფაილში კი უკვე გვაქვს კონკრეტული სიახლის წასაკითხი მეთოდი, ესაა - read_single(). api/post საქაღალდეში შევქმნათ ფაილი read_single.php და შევიტანოთ მასში შემდეგი კოდი : 
<?php

// სათაურები
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');

include_once '../../config/Database.php';
include_once '../../models/Post.php';

// მბ-სთან დაკავშირება
$database = new Database();
$db = $database->connect();

// სიახლის ობიექტის შექმნა
$post = new Post($db);

// id პარამეტრის ამოღება url-დან
$post->id = isset($_GET['id']) ? $_GET['id'] : die();

// სიახლის ამოღება id-ის მიხედვით
$post->read_single();

$post_arr = array(
    'id' => $post->id,
    'title' => $post->title,
    'body' => $post->body,
    'author' => $post->author,
    'category_id' => $post->category_id,
    'category_name' => $post->category_name
);

// ინფორმაციის დაფორმატება json ფორმატში
print_r(json_encode($post_arr));
ახლა გავაგზავნოთ GET ტიპის მოთხოვნა შემდეგ მისამართზე : http://localhost/projects/rest/api/post/read_single.php?id=3

ახალი ინფორმაციის შექმნა

Access-Control-Allow-Methods

სერვერიდან მიღებული პასუხის სათაური Access-Control-Allow-Methods განსაზღვრავს მოთხოვნის მეთოდს/მეთოდებს, რომლითაც/რომლებითაც ნებადართულია სერვერზე მოთხოვნის გაგზავნა. მისი გამოყენების სინტაქსი ასეთია : Access-Control-Allow-Methods: method>, method, ...
Access-Control-Allow-Methods: * კონკრეტული მაგალითები კი ასეთი Access-Control-Allow-Methods: POST, GET, OPTIONS
Access-Control-Allow-Methods: * models/Post.php ფაილში კი უკვე გვაქვს სიახლის დასამატებელი მეთოდი, ესაა - create(). api/post საქაღალდეში შევქმნათ ფაილი create.php და შევიტანოთ მასში შემდეგი კოდი : 
<?php

// სათაურები
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');
header('Access-Control-Allow-Methods: POST');
header('Access-Control-Allow-Headers: Access-Control-Allow-Headers,Content-Type,Access-Control-Allow-Methods, Authorization, X-Requested-With');

include_once '../../config/Database.php';
include_once '../../models/Post.php';

// მბ-სთან დაკავშირება
$database = new Database();
$db = $database->connect();

// სიახლის ობიექტი
$post = new Post($db);

// გამოგზავნილი ინფორმაცია
$data = json_decode(file_get_contents("php://input"));

$post->title = $data->title;
$post->body = $data->body;
$post->author = $data->author;
$post->category_id = $data->category_id;

// სიახლის შექმბა
if ($post->create()) 
{
    echo json_encode(array('message' => 'Post Created'));
} 
else 
{
    echo json_encode(array('message' => 'Post Not Created'));
}
ახლა გავაგზავნოთ POST ტიპის მოთხოვნა შემდეგ მისამართზე : http://localhost/projects/rest/api/post/create.php











ინფორმაციის განახლება

models/Post.php ფაილში კი უკვე გვაქვს სიახლის განახლების მეთოდი, ესაა - update(). api/post საქაღალდეში შევქმნათ ფაილი update.php და შევიტანოთ მასში შემდეგი კოდი : 
<?php

// სათაურები
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');
header('Access-Control-Allow-Methods: PUT');
header('Access-Control-Allow-Headers: Access-Control-Allow-Headers,Content-Type,Access-Control-Allow-Methods, Authorization, X-Requested-With');

include_once '../../config/Database.php';
include_once '../../models/Post.php';

// კავშირი მბ-სთან
$database = new Database();
$db = $database->connect();

// ბლოგის კლასის ობიექტი
$post = new Post($db);

// აკრეფილი ინფორმაცია, რომელიც უნდა ჩაჯდეს განახლებისას
$data = json_decode(file_get_contents("php://input"));

$post->id = $data->id;
$post->title = $data->title;
$post->body = $data->body;
$post->author = $data->author;
$post->category_id = $data->category_id;

if ($post->update()) 
{
    echo json_encode(array('message' => 'Post Updated'));
}
else 
{
    echo json_encode(array('message' => 'Post Not Updated'));
}
ახლა გავაგზავნოთ PUT ტიპის მოთხოვნა შემდეგ მისამართზე : http://localhost/projects/rest/api/post/update.php



ინფორმაციის წაშლა

models/Post.php ფაილში კი უკვე გვაქვს სიახლის წაშლის მეთოდი, ესაა - delete(). api/post საქაღალდეში შევქმნათ ფაილი delete.php და შევიტანოთ მასში შემდეგი კოდი : 
<?php

// სათაურები
header('Access-Control-Allow-Origin: *');
header('Content-Type: application/json');
header('Access-Control-Allow-Methods: DELETE');
header('Access-Control-Allow-Headers: Access-Control-Allow-Headers,Content-Type,Access-Control-Allow-Methods, Authorization, X-Requested-With');

include_once '../../config/Database.php';
include_once '../../models/Post.php';

$database = new Database();
$db = $database->connect();

$post = new Post($db);

$data = json_decode(file_get_contents("php://input"));
$post->id = $data->id;

if ($post->delete()) 
{
    echo json_encode(array('message' => 'Post Deleted'));
} 
else 
{
    echo json_encode(array('message' => 'Post Not Deleted'));
}
ახლა გავაგზავნოთ DELETE ტიპის მოთხოვნა შემდეგ მისამართზე : http://localhost/projects/rest/api/post/delete.php