სარეგისტრაციო სისტემის შექმნის პროცესი საკმაოდ დიდი სამუშაოა. თქვენ უნდა დაწეროთ კოდი, რომელიც ორჯერ ამოწმებს ელ.ფოსტის მისამართების ნამდვილობას, აგზავნის დამადასტურებელ წერილებს, გთავაზობთ პაროლების აღდგენის შესაძლებლობას, ინახავს პაროლებს უსაფრთხო ადგილას, ამოწმებს შეყვანის ფორმებს და მრავალი სხვა. მაშინაც კი, როცა ამ ყველაფერს აკეთებთ, მომხმარებლები თავს არიდებენ რეგისტრაციას, რადგან ყველაზე მინიმალური რეგისტრაციაც კი მოითხოვს მათ აქტიურობას.
დღევანდელ გაკვეთილზე ჩვენ შევიმუშავებთ მარტივი რეგისტრაციის სისტემას, რომელიც არ საჭიროებს პაროლს! შედეგები იქნება სისტემა, რომელიც შეიძლება ადვილად შეიცვალოს ან ინტეგრირებული იყოს არსებულ PHP ვებსაიტში. თუ გაინტერესებთ, განაგრძეთ კითხვა.
PHP
ახლა ჩვენ მზად ვართ დავიწყოთ PHP კოდით. სარეგისტრაციო სისტემის ძირითად ფუნქციონირებას უზრუნველყოფს User კლასი, რომელიც შეგიძლიათ იხილოთ ქვემოთ. კლასი იყენებს (), რომელიც არის მინიმალისტური მონაცემთა ბაზის ბიბლიოთეკა. მომხმარებლის კლასი პასუხისმგებელია მონაცემთა ბაზებზე წვდომაზე, შესვლის ნიშნების გენერირებაზე და მათ დადასტურებაზე. ის გვთავაზობს მარტივ ინტერფეისს, რომელიც ადვილად შეიძლება იყოს ჩართული თქვენი PHP ვებსაიტების სარეგისტრაციო სისტემაში.
User.class.php
// პირადი ORM ინსტანცია
პირადი $orm;
/**
* იპოვნეთ მომხმარებელი ნიშნის სტრიქონით. მიიღება მხოლოდ მოქმედი ნიშნები
* გათვალისწინება. ჟეტონი მოქმედებს გენერირებიდან 10 წუთის განმავლობაში.
* @param string $token საძიებელი ნიშანი
* @return მომხმარებელი
*/
საჯარო სტატიკური ფუნქცია findByToken($token)(
// იპოვეთ იგი მონაცემთა ბაზაში და დარწმუნდით, რომ დროის ანაბეჭდი სწორია
->where ("token", $token)
->where_raw ("token_validity > NOW()")
-> find_one();
თუ(!$result)(
დაბრუნება false;
}
ახალი მომხმარებლის დაბრუნება ($result);
}
/**
* ან შედით ან დაარეგისტრირეთ მომხმარებელი.
* @return მომხმარებელი
*/
საჯარო სტატიკური ფუნქცია loginOrRegister($email)(
// თუ ასეთი მომხმარებელი უკვე არსებობს, დააბრუნეთ იგი
თუ(მომხმარებელი::არსებობს($email))(
დააბრუნეთ ახალი მომხმარებელი ($email);
}
// წინააღმდეგ შემთხვევაში შექმენით და დააბრუნეთ
Return User::create($email);
}
/**
* შექმენით ახალი მომხმარებელი და შეინახეთ იგი მონაცემთა ბაზაში
* @param string $email მომხმარებლის ელფოსტის მისამართი
* @return მომხმარებელი
*/
პირადი სტატიკური ფუნქციის შექმნა ($email)(
// ჩაწერეთ ახალი მომხმარებელი მონაცემთა ბაზაში და დააბრუნეთ იგი
$result = ORM::for_table("reg_users")->create();
$result->email = $email;
$result->save();
ახალი მომხმარებლის დაბრუნება ($result);
}
/**
* შეამოწმეთ არის თუ არა ასეთი მომხმარებელი მონაცემთა ბაზაში და დააბრუნეთ ლოგიკური მნიშვნელობა.
* @param string $email მომხმარებლის ელფოსტის მისამართი
* @Return Boolean
*/
არსებობს საჯარო სტატიკური ფუნქცია ($email)(
// არსებობს თუ არა მომხმარებელი მონაცემთა ბაზაში?
$result = ORM::for_table ("რეგ_მომხმარებლები")
->where ("email", $email)
->count();
დააბრუნეთ $result == 1;
}
/**
* შექმენით ახალი მომხმარებლის ობიექტი
* @param $param ORM მაგალითი, ID, ელ.ფოსტა ან null
* @return მომხმარებელი
*/
საჯარო ფუნქცია __კონსტრუქცია ($param = null)(
თუ (ORM-ის $param მაგალითი)(
// ORM ინსტანცია გაიარა
$this->orm = $param;
}
else if(is_string($param))(
// წერილი გადაეცა
$this->
->where ("ელფოსტა", $param)
-> find_one();
}
სხვა (
If(is_numeric($param))(
// მომხმარებლის ID გადაეცა პარამეტრად
$id = $param;
}
else if(isset($_SESSION["loginid"]))(
// მომხმარებლის ID არ არის გადაცემული, გადახედეთ სესიას
$id = $_SESSION["loginid"];
}
$this->orm = ORM::for_table("reg_users")
->where ("id", $id)
-> find_one();
}
/**
* ქმნის ახალ SHA1 შესვლის ჟეტონს, წერს მას მონაცემთა ბაზაში და აბრუნებს.
* @return სტრიქონი
*/
საჯარო ფუნქცია generateToken())(
// ჟეტონის გენერირება შესული მომხმარებლისთვის. შეინახეთ იგი მონაცემთა ბაზაში.
$token = sha1($this->email.time().rand(0, 1000000));
// შეინახეთ ნიშანი მონაცემთა ბაზაში,
// და მონიშნეთ როგორც მოქმედი მხოლოდ მომდევნო 10 წუთის განმავლობაში
$this->orm->set("token", $token);
$this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")");
$this->orm->save();
$token-ის დაბრუნება;
}
/**
*შედით ამ მომხმარებლის სისტემაში
* @return void
*/
საჯარო ფუნქციის შესვლა ()
// მონიშნეთ მომხმარებელი, როგორც შესული
$_SESSION["loginid"] = $this->orm->id;
// განაახლეთ last_login db ველი
$this->orm->set_expr("last_login", "NOW()");
$this->orm->save();
}
/**
* გაანადგურეთ სესია და გამოდით მომხმარებელი.
* @return void
*/
საჯარო ფუნქციის გამოსვლა ()
$_SESSION = მასივი();
unset ($_SESSION);
}
/**
* შეამოწმეთ არის თუ არა მომხმარებელი შესული.
* @Return Boolean
*/
საჯარო ფუნქცია შესული ())(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}
/**
* შეამოწმეთ არის თუ არა მომხმარებელი ადმინისტრატორი
* @Return Boolean
*/
საჯარო ფუნქცია არის Admin())(
return $this->rank() == "ადმინისტრატორი";
}
/**
* იპოვნეთ მომხმარებლის ტიპი. ეს შეიძლება იყოს ადმინისტრატორი ან რეგულარული.
* @return სტრიქონი
*/
საჯარო ფუნქციის რანგი())(
if($this->orm->rank == 1)(
დაბრუნება "ადმინისტრატორი";
}
დაბრუნება "რეგულარული";
}
/**
* ჯადოსნური მეთოდი პირადი ელემენტების წვდომისთვის
* $orm მაგალითი, როგორც მომხმარებლის ობიექტის თვისებები
* @param string $key წვდომა ქონების სახელი
* @return შერეული
*/
საჯარო ფუნქცია __get($key)(
if(isset($this->orm->$key))(
დაბრუნება $this->orm->$key;
}
დაბრუნება null;
}
}
ტოკენები გენერირდება ალგორითმის გამოყენებით და ინახება მონაცემთა ბაზაში. ჩვენ ვიყენებთ MySQL token_validity სვეტის 10 წუთზე დასაყენებლად. ჟეტონის ვალიდაციისას ჩვენ ვეუბნებით ძრავას, რომ გვჭირდება ჟეტონი, token_validity ველი ჯერ არ გასულა. ამ გზით ჩვენ ვზღუდავთ დროს, რომლის განმავლობაშიც ჟეტონი მოქმედებს.
გაითვალისწინეთ, რომ ჩვენ ვიყენებთ __get() ჯადოსნურ მეთოდს დოკუმენტის ბოლოს მომხმარებლის ობიექტის თვისებებზე წვდომისთვის. ეს საშუალებას გვაძლევს მივიღოთ მონაცემები, რომლებიც ინახება მონაცემთა ბაზაში თვისებების სახით: $user->email, $user->token. მაგალითად, ვნახოთ, როგორ შეგვიძლია გამოვიყენოთ ეს კლასი შემდეგ კოდის ნაწყვეტში:
კიდევ ერთი ფაილი, რომელიც ინახავს საჭირო ფუნქციონირებას, არის functions.php. ჩვენ გვაქვს რამდენიმე დამხმარე ფუნქცია, რომელიც საშუალებას გვაძლევს შევინარჩუნოთ დანარჩენი კოდი უფრო სწორად.
ფუნქციები.php
ფუნქცია send_email($from, $to, $subject, $message)(
// დამხმარე ფუნქცია ელფოსტის გაგზავნისთვის
$headers = "MIME-ვერსია: 1.0" . "\r\n";
$headers .= "შინაარსის ტიპი: text/plain; charset=utf-8" . "\r\n";
$headers .= "From: ".$from . "\r\n";
ფოსტის დაბრუნება ($to, $subject, $message, $headers);
}
ფუნქცია get_page_url())(
// შეიტყვეთ PHP ფაილის URL
$url = "http".(ცარიელი($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVER_NAME"];
If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
სხვა (
$url.= $_SERVER["PATH_INFO"];
}
დააბრუნეთ $url;
}
ფუნქცია rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)(
// შესვლის მცდელობების რაოდენობა ბოლო საათის განმავლობაში ამ IP მისამართით
$count_hour = ORM::for_table ("reg_login_ttempt")
->
->where_raw("ts > SUBTIME(NOW(),"1:00")")
->count();
// შესვლის მცდელობების რაოდენობა ბოლო 10 წუთის განმავლობაში ამ IP მისამართით
$count_10_min = ORM::for_table ("reg_login_ttempt")
->where("ip", sprintf("%u", ip2long($ip)))
->where_raw("ts > SUBTIME(NOW(),"0:10")")
->count();
If($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
გადაყარეთ ახალი გამონაკლისი ("ძალიან ბევრი შესვლის მცდელობა!");
}
}
ფუნქცია rate_limit_tick ($ip, $email)(
// შექმენით ახალი ჩანაწერი შესვლის მცდელობის ცხრილში
$login_attempt = ORM::for_table("reg_login_attempt")->create();
$login_attempt->email = $email;
$login_attempt->ip = sprintf("%u", ip2long($ip));
$login_attempt->save();
}
ფუნქციის გადამისამართება($url)(
header ("მდებარეობა: $url");
გასასვლელი;
}
rate_limit და rate_limit_tick ფუნქციები საშუალებას გვაძლევს შევზღუდოთ ავტორიზაციის მცდელობების რაოდენობა გარკვეული პერიოდის განმავლობაში. ავტორიზაციის მცდელობები ჩაწერილია reg_login_attempt მონაცემთა ბაზაში. ეს ფუნქციები ამოქმედდება, როდესაც შესვლის ფორმა დამოწმებულია, როგორც ხედავთ შემდეგ კოდის ნაწყვეტში.
ქვემოთ მოყვანილი კოდი აღებულია index.php-დან და პასუხისმგებელია შესვლის ფორმის დადასტურებაზე. ის აბრუნებს JSON პასუხს, რომელიც გამოწვეულია jQuery კოდით, რომელიც ვნახეთ assets/js/script.js-ში.
index.php
თუ(! ცარიელი ($_POST) && არის დაყენებული($_SERVER["HTTP_X_REQUESTED_WITH"]))(
// JSON სათაურის გამოტანა
Header("შინაარსის ტიპი: განაცხადი/json");
// ელ.ფოსტის მისამართი მოქმედებს?
If(!isset($_POST["ელფოსტა"]) || !filter_var($_POST["ელფოსტა"], FILTER_VALIDATE_EMAIL))(
გადაყარეთ ახალი გამონაკლისი ("გთხოვთ, შეიყვანოთ სწორი ელ.წერილი.");
}
// ეს გამოიწვევს გამონაკლისს, თუ ადამიანი ზემოთ არის
// შესვლის მცდელობის დაშვებული ლიმიტები (იხილეთ functions.php მეტისთვის):
rate_limit ($_SERVER["REMOTE_ADDR"]);
// ჩაწერეთ ეს შესვლის მცდელობა
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["ელფოსტა"]);
// შეტყობინების გაგზავნა მომხმარებლისთვის
$message = "";
$email = $_POST["email"];
$subject = "თქვენი შესვლის ბმული";
თუ(!მომხმარებელი::არსებობს($email))(
$subject = "გმადლობთ რეგისტრაციისთვის!";
$message = "გმადლობთ, რომ დარეგისტრირდით ჩვენს საიტზე!\n\n";
}
// შეეცადეთ შეხვიდეთ ან დაარეგისტრიროთ პირი
$user = მომხმარებელი::loginOrRegister($_POST["ელფოსტა"]);
$message.= "შეგიძლიათ შეხვიდეთ ამ URL-დან:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n";
$message.= "ბმული ავტომატურად იწურება 10 წუთის შემდეგ.";
$result = send_email ($fromEmail, $_POST["email"], $subject, $message);
თუ(!$result)(
გადაყარეთ ახალი გამონაკლისი ("თქვენი ელფოსტის გაგზავნისას მოხდა შეცდომა. გთხოვთ სცადოთ ხელახლა.");
}
Die(json_encode(მასივი(
"message" => "გმადლობთ! ჩვენ გამოგიგზავნეთ ბმული თქვენს შემოსულებში. შეამოწმეთ თქვენი სპამის საქაღალდეც."
)));
}
}
catch(გამონაკლისი $e)(
Die(json_encode(მასივი(
"error"=>1,
"message" => $e->getMessage()
)));
}
წარმატებული ავტორიზაციის ან რეგისტრაციის შემდეგ, ზემოაღნიშნული კოდი უგზავნის ელ.წერილს პირს ავტორიზაციის ბმულით. ჟეტონი ხელმისაწვდომია როგორც $_GET ცვლადი "tkn" გენერირებული URL-ის გამო.
index.php
If(isset($_GET["tkn"]))(
// ეს სწორი შესვლის ნიშანია?
$user = მომხმარებელი::findByToken($_GET["tkn"]);
//დიახ! შედით მომხმარებელი და გადამისამართდით დაცულ გვერდზე.
$user->login();
გადამისამართება ("protected.php");
}
// არასწორი ჟეტონი. გადამისამართება უკან შესვლის ფორმაში.
გადამისამართება ("index.php");
}
$user->login()-ის გაშვება შექმნის სესიის აუცილებელ ცვლადებს, რაც მომხმარებელს საშუალებას მისცემს დარჩეს სისტემაში შემდგომ შესვლაზე.
სისტემიდან გამოსვლა ხორციელდება დაახლოებით იმავე გზით:
ინდექსი.php
If(isset($_GET["გასვლა"]))(
$user = ახალი მომხმარებელი();
If($user->logedIn())(
$user->logout();
}
გადამისამართება ("index.php");
}
კოდის ბოლოს, ჩვენ კვლავ გადამისამართებთ მომხმარებელს index.php-ზე, ამიტომ URL-ში ?logout=1 პარამეტრი აღმოიფხვრება.
ჩვენს index.php ფაილს ასევე დასჭირდება დაცვა - არ გვინდა, რომ უკვე შესულმა მომხმარებლებმა ნახონ ფორმა. ამისათვის ჩვენ ვიყენებთ $user->loggedIn() მეთოდს:
ინდექსი.php
$user = ახალი მომხმარებელი();
if($user->loggedIn())(
გადამისამართება ("protected.php");
}
და ბოლოს, მოდით შევხედოთ, თუ როგორ შეგიძლიათ დაიცვათ თქვენი ვებგვერდის გვერდი და გახადოთ ის ხელმისაწვდომი მხოლოდ ავტორიზაციის შემდეგ:
დაცულია.php
// თქვენს საიტზე ნებისმიერი php გვერდის დასაცავად, ჩართეთ main.php
// და შექმენით ახალი მომხმარებლის ობიექტი. ეს ასე მარტივია!
require_once "მოიცავს/მთავარ.php";
$user = ახალი მომხმარებელი();
if(!$user->loggedIn())(
გადამისამართება ("index.php");
}
ამ შემოწმების შემდეგ შეგიძლიათ დარწმუნდეთ, რომ მომხმარებელი წარმატებით შევიდა სისტემაში. თქვენ ასევე გექნებათ წვდომა იმ მონაცემებზე, რომლებიც ინახება მონაცემთა ბაზაში, როგორც $user ობიექტის თვისებები. მომხმარებლის ელფოსტის და მათი რანგის საჩვენებლად გამოიყენეთ შემდეგი კოდი:
Echo "თქვენი ელფოსტა: ".$user->email;
echo "თქვენი წოდება: ".$user->rank();
აქ rank() არის მეთოდი, რადგან მონაცემთა ბაზის რანგის სვეტი ჩვეულებრივ შეიცავს ციფრებს (0 ჩვეულებრივი მომხმარებლებისთვის და 1 ადმინისტრატორებისთვის) და ჩვენ უნდა გადავიყვანოთ ეს ყველაფერი რანგის სახელებად, რაც განხორციელდება ამ მეთოდის გამოყენებით. სტანდარტული მომხმარებლის ადმინისტრატორად გადასაყვანად, უბრალოდ შეცვალეთ მომხმარებლის ჩანაწერი phpmyadmin-ში (ან მონაცემთა ბაზის ნებისმიერ სხვა პროგრამაში). როგორც ადმინისტრატორი, მომხმარებელს არ მიენიჭება რაიმე განსაკუთრებული შესაძლებლობები. თქვენ თავად გაქვთ უფლება აირჩიოთ რა უფლებები მიანიჭოთ ადმინისტრატორებს.
მზადაა!
ამით ჩვენი მარტივი სარეგისტრაციო სისტემა მზად არის! თქვენ შეგიძლიათ გამოიყენოთ იგი არსებულ PHP საიტზე, ან მოდერნიზედეთ თქვენი მოთხოვნების შესაბამისად.
გამარჯობა, მეგობრებო ამ გაკვეთილზე ჩვენ ვისწავლით მომხმარებლის რეგისტრაციას და შესვლას PHP შენახული პროცედურის გამოყენებით.
ფაილის სტრუქტურა ამ გაკვეთილისთვის
config.php
index.php
check_availability.php
login.php
მოგესალმებით.php
გამოსვლა.php
sql ცხრილის tblregistration სტრუქტურა
შექმენით ცხრილი `tblregistration` (`id` int(11) NOT NULL, `FullName` varchar(200) NOT NULL, `EmailId` varchar(200) NOT NULL, `პაროლი` varchar(255) NOT NULL, `RegDate` დროის შტამპი NOT NULL DEFAULT CURRENT_TIMESTAMP) ENGINE=InnoDB DEFAULT CHARSET=latin1;
config.phpშექმენით db კონფიგურაციის ფაილი mysqli გაფართოების გამოყენებით. მიაწოდეთ რწმუნებათა სიგელები თქვენი კონფიგურაციის მიხედვით
index.php
შექმენით html ფორმა მომხმარებლის რეგისტრაციისთვის.
რეგისტრაცია სრული სახელი E-mail პაროლი
უკვე დარეგისტრირებულია. შედით აქ
Jquery / Ajax მომხმარებლის ელ.ფოსტის ხელმისაწვდომობისთვის
check_availability.php
ამ გვერდზე ჩვენ შევამოწმებთ მომხმარებლის ელ.ფოსტის ხელმისაწვდომობას. შექმენით მაღაზიის პროცედურა სახელის შემოწმების ხელმისაწვდომობით
შენახვის პროცედურის კოდი:
DELIMITER $ CREATE DEFINER=`root`@`localhost` PROCEDURE `checkavailbilty`(IN `email` VARCHAR(255)) NO SQL SELECT EmailId FROM tblregistration WHERE EmailId=email$ DELIMITER ;
ახლა შექმენით მაღაზიის პროცედურა მომხმარებლის რეგისტრაციისთვის.
შენახვის პროცედურა მომხმარებლის რეგისტრაციისთვის
DELIMITER $ CREATE DEFINER=`root`@`localhost` პროცედურა `რეგისტრაცია`( `fname` VARCHAR(200), IN `emailid` VARCHAR(200), IN `პაროლში` VARCHAR(255)) არ არის SQL ჩასმა tblregistration( სრული სახელი, ელ.ფოსტის ID, პაროლი) VALUES(fname,emailid,პაროლი)$ DELIMITER ;
მაღაზიის პროცედურის შექმნის შემდეგ შეასრულეთ მაღაზიის პროცედურა.
აქ არის სრული კოდი, რომელიც ჩვენ დავწერეთ რეგისტრაციისთვის (index.php):
რეგისტრაცია Store Procedure ფუნქციის გამოყენებით checkAvailability() ( $("#loaderIcon").show(); jQuery.ajax(( url: "check_availability.php", data:"emailid="+$("#email").val (), ტიპი: "POST", success:function(data)( $("#user-availability-status").html(data); $("#loaderIcon"). hide(); ), შეცდომა:function ()() )); ) რეგისტრაცია სრული სახელი ელ.ფოსტა პაროლი
უკვე დარეგისტრირებულია. შედით აქ
login.phpშექმენით შესვლის ფორმა მომხმარებლის შესვლა.
შესვლა
არ არის დარეგისტრირებული? Შექმენით ანგარიში
ახლა შექმენით მაღაზიის პროცედურა შესვლისთვის სახელით შესვლა.
შესვლის პროცედურა მაღაზიაში:
DELIMITER $ CREATE DEFINER=`root`@`localhost` PROCEDURE `login`(IN `useremail` VARCHAR(255), IN `password` VARCHAR(255)) NO SQL აირჩიეთ EmailId,პაროლი tblრეგისტრაციიდან, სადაც EmailIdsword=usere პაროლი$ DELIMITER ;
ახლა შეასრულეთ შესვლის მაღაზიის პროცედურა
