Precīza indeksa php lietotāja reģistrācija. Vienkārša lietotāju reģistrācijas sistēma

Reģistrācijas sistēmas izveides process ir diezgan liels darbs. Jums ir jāieraksta kods, kas vēlreiz pārbauda e-pasta adrešu derīgumu, nosūta apstiprinājuma e-pastus, piedāvā iespēju atgūt paroles, glabā paroles drošā vietā, apstiprina ievades veidlapas un daudz ko citu. Pat tad, kad jūs to visu darīsit, lietotāji nelabprāt reģistrēsies, jo pat minimālai reģistrācijai ir nepieciešama viņu darbība.

Šodienas apmācībā mēs izstrādāsim vienkāršu reģistrācijas sistēmu, kurai nebūs vajadzīgas nekādas paroles! Rezultātā tiks izveidota sistēma, kuru var viegli pārveidot vai integrēt esošajā PHP vietnē. Ja jūs interesē, turpiniet lasīt.

PHP

Tagad mēs esam gatavi sākt ar PHP kodu. Reģistrācijas sistēmas galveno funkcionalitāti nodrošina Lietotāju klase, kuru varat redzēt zemāk. Klase izmanto (), kas ir minimālisma datu bāzes bibliotēka. Lietotāju klase ir atbildīga par piekļuvi datu bāzēm, pieteikšanās marķieru ģenerēšanu un to apstiprināšanu. Tas piedāvā vienkāršu interfeisu, ko var viegli iekļaut jūsu PHP vietņu reģistrācijas sistēmā.

User.class.php

// Privāts ORM gadījums
privāts $orm;

/**
* Atrodiet lietotāju pēc marķiera virknes. Tiek ņemti vērā tikai derīgi žetoni
* apsvēršana. Tokens ir derīgs 10 minūtes pēc tā ģenerēšanas.
* @param string $token Marķieris, kas jāmeklē
* @atgriezties lietotājs
*/

Publiskā statiskā funkcija findByToken($token)(

// atrodiet to datu bāzē un pārliecinieties, vai laikspiedols ir pareizs

->kur("token", $token)
->kur_raw("token_validity > NOW()")
->atrast_vienu();

Ja(!$rezultāts)(
return false;
}

Atgriezt jaunu lietotāju($rezultāts);
}

/**
* Piesakieties vai reģistrējiet lietotāju.
* @atgriezties lietotājs
*/

Publiskā statiskā funkcija loginOrRegister($email)(

// Ja šāds lietotājs jau pastāv, atgrieziet to

Ja(lietotājs::eksistē($email))(
atgriezt jaunu lietotāju($email);
}

// Pretējā gadījumā izveidojiet to un atgrieziet to

Atgriezties lietotājs::create($email);
}

/**
* Izveidojiet jaunu lietotāju un saglabājiet to datu bāzē
* @param string $email Lietotāja e-pasta adrese
* @atgriezties lietotājs
*/

Privāta statiskā funkcija izveidot($email)(

// Ierakstiet jaunu lietotāju datu bāzē un atgrieziet to

$rezultāts = ORM::for_table("reg_users")->izveidot();
$rezultāts->e-pasts = $e-pasts;
$rezultāts->saglabāt();

Atgriezt jaunu lietotāju($rezultāts);
}

/**
* Pārbaudiet, vai šāds lietotājs pastāv datu bāzē, un atgrieziet Būla vērtību.
* @param string $email Lietotāja e-pasta adrese
* @return Būla vērtība
*/

Pastāv publiska statiskā funkcija($email)(

// Vai lietotājs pastāv datu bāzē?
$rezultāts = ORM::for_table("reg_users")
->kur("e-pasts", $e-pasts)
->count();

Atgriezt $rezultāts == 1;
}

/**
* Izveidojiet jaunu lietotāja objektu
* @param $param ORM gadījums, ID, e-pasts vai null
* @atgriezties lietotājs
*/

Publiskā funkcija __construct($param = null)(

If($param instanceof ORM)(

// Tika nodota ORM instance
$this->orm = $param;
}
cits if(ir_string($param))(

// E-pasts tika nosūtīts
$this->
->kur("e-pasts", $param)
->atrast_vienu();
}
cits(

If(ir_ciparu($param))(
// Kā parametrs tika nodots lietotāja ID
$id = $param;
}
else if(isset($_SESSION["loginid"]))(

// Netika nodots neviens lietotāja ID, skatiet sesiju
$id = $_SESSION["loginid"];
}

$this->orm = ORM::for_table("reg_users")
->kur("id", $id)
->atrast_vienu();
}

/**
* Ģenerē jaunu SHA1 pieteikšanās pilnvaru, ieraksta to datu bāzē un atgriež.
* @atgriešanas virkne
*/

Publiskā funkcija generateToken())(
// ģenerē marķieri reģistrētajam lietotājam. Saglabājiet to datu bāzē.

$token = sha1($this->email.time().rand(0, 1000000));

// Saglabājiet marķieri datu bāzē,
// un atzīmējiet to kā derīgu tikai nākamās 10 minūtes

$this->orm->set("token", $token);
$this->orm->set_expr("token_validity", "ADDTIME(NOW(),"0:10")");
$this->orm->save();

Atgriezt $ marķieri;
}

/**
*Pieteikties šim lietotājam
* @atgriezties spēkā neesošs
*/

Publiskās funkcijas pieteikšanās()

// Atzīmēt lietotāju kā pieteicies
$_SESSION["loginid"] = $this->orm->id;

// Atjauniniet last_login db lauku
$this->orm->set_expr("pēdējais_pieteikšanās", "TAGAD()");
$this->orm->save();
}

/**
* Iznīciniet sesiju un atsakieties no lietotāja.
* @atgriezties spēkā neesošs
*/

Publiskās funkcijas atteikšanās()
$_SESIJA = masīvs();
unset($_SESSION);
}

/**
* Pārbaudiet, vai lietotājs ir pieteicies.
* @return Būla vērtība
*/

Publiskā funkcija loggedIn())(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}

/**
* Pārbaudiet, vai lietotājs ir administrators
* @return Būla vērtība
*/

Publiskā funkcija irAdmin())(
return $this->rank() == "administrators";
}

/**
* Atrodiet lietotāja veidu. Tas var būt gan administrators, gan parasts.
* @atgriešanas virkne
*/

Publiskās funkcijas rangs())(
if($this->orm->rank == 1)(
atgriezt "administrators";
}

Atgriezt "parasti";
}

/**
* Burvju metode, lai piekļūtu privātajiem elementiem
* $orm instance kā lietotāja objekta rekvizīti
* @param string $key Piekļuve rekvizīta nosaukums
* @return sajaukts
*/

Publiskā funkcija __get($key)(
if(isset($this->orm->$key))(
atgriezt $this->orm->$key;
}

Atgriezt nulli;
}
}
Tokeni tiek ģenerēti, izmantojot algoritmu, un tiek saglabāti datu bāzē. Mēs izmantojam MySQL, lai kolonnā token_validity iestatītu 10 minūtes. Validējot marķieri, mēs sakām dzinējam, ka mums ir nepieciešams marķieris, laukam token_validity derīguma termiņš vēl nav beidzies. Tādā veidā mēs ierobežojam laiku, kurā marķieris būs derīgs.

Ievērojiet, ka mēs izmantojam burvju metodi __get() dokumenta beigās, lai piekļūtu lietotāja objekta rekvizītiem. Tas ļauj mums piekļūt datiem, kas tiek glabāti datu bāzē kā rekvizīti: $user->email, $user->token. Piemēram, apskatīsim, kā mēs varam izmantot šo klasi šajā koda fragmentā:

Vēl viens fails, kurā tiek saglabāta nepieciešamā funkcionalitāte, ir functions.php. Tur mums ir dažas palīgfunkcijas, kas ļauj mums saglabāt pārējo kodu tīrāku.

Functions.php

Funkcija send_email($from, $kam, $subject, $message)(

// Palīdzības funkcija e-pasta sūtīšanai

$headers = "MIME versija: 1.0" . "\r\n";
$headers .= "Satura veids: teksts/vienkāršs; charset=utf-8" . "\r\n";
$headers .= "No: ".$from . "\r\n";

Atgriezt pastu ($kam, $tēma, $ziņa, $galvenes);
}

funkcija get_page_url())(

// Uzziniet PHP faila URL

$url = "http".(tukšs($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVERA_NAME"];

If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
cits(
$url.= $_SERVER["PATH_INFO"];
}

Atgriezt $url;
}

funkcija rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)(

// Pieteikšanās mēģinājumu skaits pēdējā stundā, izmantojot šo IP adresi

$count_hour = ORM::for_table("reg_login_attempt")
->
->kur_raw("ts > SUBTIME(NOW(),"1:00")")
->count();

// Pieteikšanās mēģinājumu skaits pēdējās 10 minūtēs, izmantojot šo IP adresi

$count_10_min = ORM::for_table("reg_login_attempt")
->kur("ip", sprintf("%u", ip2long($ip)))
->kur_raw("ts > SUBTIME(NOW(),"0:10")")
->count();

If($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
throw new Exception("Pārāk daudz pieteikšanās mēģinājumu!");
}
}

funkcija rate_limit_tick($ip, $email)(

// Izveidojiet jaunu ierakstu pieteikšanās mēģinājumu tabulā

$login_attempt = ORM::for_table("reg_login_attempt")->create();

$login_attempt->email = $e-pasts;
$login_attempt->ip = sprintf("%u", ip2long($ip));

$login_attempt->save();
}

funkcija novirzīt($url)(
header("Atrašanās vieta: $url");
Izeja;
}
Funkcijas rate_limit un rate_limit_tick ļauj ierobežot autorizācijas mēģinājumu skaitu noteiktā laika periodā. Autorizācijas mēģinājumi tiek reģistrēti reg_login_attempt datu bāzē. Šīs funkcijas tiek aktivizētas, kad tiek pārbaudīta pieteikšanās forma, kā redzams nākamajā koda fragmentā.

Tālāk norādītais kods tika ņemts no index.php un ir atbildīgs par pieteikšanās veidlapas apstiprināšanu. Tas atgriež JSON atbildi, ko virza jQuery kods, ko redzējām failā aktīvi/js/script.js.

indekss.php

If(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))(

// Izvadiet JSON galveni

Header ("Satura veids: lietojumprogramma/json");

// Vai e-pasta adrese ir derīga?

If(!isset($_POST["e-pasts"]) || !filter_var($_POST["e-pasts"], FILTER_VALIDATE_EMAIL))(
throw new Exception("Lūdzu, ievadiet derīgu e-pastu.");
}

// Tas radīs izņēmumu, ja persona atrodas augstāk
// atļautie pieteikšanās mēģinājumu ierobežojumi (vairāk skatiet functions.php):
likmes_limits($_SERVER["ATTĀLĀ_ADDR"]);

// Ierakstiet šo pieteikšanās mēģinājumu
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["e-pasts"]);

// Nosūtiet ziņojumu lietotājam

$ziņojums = "";
$e-pasts = $_POST["e-pasts"];
$subject = "Jūsu pieteikšanās saite";

Ja(!Lietotājs::eksistē($email))(
$subject = "Paldies, ka reģistrējāties!";
$message = "Paldies, ka reģistrējāties mūsu vietnē!\n\n";
}

// Mēģinājums pieteikties vai reģistrēt personu
$lietotājs = User::loginOrRegister($_POST["e-pasts"]);

$message.= "Jūs varat pieteikties no šī URL:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n";

$message.= "Saite automātiski beigsies pēc 10 minūtēm.";

$rezultāts = send_email($fromEmail, $_POST["e-pasts"], $tēma, $ziņa);

Ja(!$rezultāts)(
throw new Exception("Sūtot jūsu e-pasta ziņojumu, radās kļūda. Lūdzu, mēģiniet vēlreiz.");
}

Die(json_encode(masīvs(
"message" => "Paldies! Mēs esam nosūtījuši saiti uz jūsu iesūtni. Pārbaudiet arī savu surogātpasta mapi."
)));
}
}
noķert(izņēmums $e)(

Die(json_encode(masīvs(
"error"=>1,
"message" => $e->getMessage()
)));
}
Pēc veiksmīgas autorizācijas vai reģistrācijas iepriekš minētais kods nosūta personai e-pasta ziņojumu ar saiti autorizācijai. Tokens ir pieejams kā $_GET mainīgais "tkn" ģenerētā URL dēļ.

indekss.php

If(isset($_GET["tkn"]))(

// Vai šī ir derīga pieteikšanās pilnvara?
$lietotājs = Lietotājs::findByToken($_GET["tkn"]);

//Jā! Piesakieties lietotājam un novirziet uz aizsargāto lapu.

$lietotājs->pieteikšanās();
redirect("protected.php");
}

// Nederīgs marķieris. Pārvirzīt atpakaļ uz pieteikšanās veidlapu.
novirzīt("indekss.php");
}
Palaižot $user->login(), tiks izveidoti nepieciešamie sesijas mainīgie, ļaujot lietotājam turpmākajos pieteikšanās reizēs palikt reģistrētam.

Atteikšanās no sistēmas tiek īstenota aptuveni tādā pašā veidā:

Indekss.php

If(isset($_GET["atteikties"]))(

$lietotājs = jauns lietotājs();

If($user->loggedIn())(
$lietotājs->atteikties();
}

Redirect ("index.php");
}
Koda beigās mēs atkal novirzām lietotāju uz index.php, tādējādi URL parametrs ?logout=1 tiek izslēgts.

Arī mūsu index.php failam būs nepieciešama aizsardzība — mēs nevēlamies, lai lietotāji, kuri jau ir pieteikušies, redzētu veidlapu. Lai to izdarītu, mēs izmantojam $user->loggedIn() metodi:

Indekss.php

$lietotājs = jauns lietotājs();

if($user->loggedIn())(
redirect("protected.php");
}
Visbeidzot, apskatīsim, kā jūs varat aizsargāt savas vietnes lapu un padarīt to pieejamu tikai pēc autorizācijas:

Protected.php

// Lai aizsargātu jebkuru php lapu savā vietnē, iekļaujiet main.php
// un izveidojiet jaunu lietotāja objektu. Tas ir tik vienkārši!

request_once "includes/main.php";

$lietotājs = jauns lietotājs();

if(!$user->loggedIn())(
novirzīt("indekss.php");
}
Pēc šīs pārbaudes varat būt pārliecināts, ka lietotājs ir veiksmīgi pieteicies. Jums būs arī piekļuve datiem, kas tiek glabāti datu bāzē kā $user objekta rekvizīti. Lai parādītu lietotāja e-pastu un viņa rangu, izmantojiet šādu kodu:

Echo "Jūsu e-pasts: ".$user->email;
echo "Jūsu rangs: ".$user->rank();
Šeit rank() ir metode, jo datu bāzes rangu kolonnā parasti ir skaitļi (0 parastajiem lietotājiem un 1 administratoriem), un mums tie visi ir jāpārvērš rangu nosaukumos, kas tiek ieviests, izmantojot šo metodi. Lai standarta lietotāju pārvērstu par administratoru, vienkārši rediģējiet lietotāja ierakstu phpmyadmin (vai jebkurā citā datu bāzes programmā). Kā administratoram lietotājam nekādas īpašas iespējas netiks piešķirtas. Jums pašam ir tiesības izvēlēties, kādas tiesības piešķirt administratoriem.

Gatavs!

Ar to mūsu vienkāršā reģistrācijas sistēma ir gatava! Varat to izmantot esošā PHP vietnē vai modernizēt, lai tā atbilstu savām prasībām.

Sveiki, draugi šajā apmācībā mēs apgūsim lietotāju reģistrāciju un pieteikšanos, izmantojot PHP saglabāto procedūru.
Šīs apmācības faila struktūra
config.php
indekss.php
check_availability.php
login.php
laipni lūdzam.php
logout.php
SQL tabulas tblreģistrācijas struktūra

IZVEIDOT TABULU "tblregistration" ("id" int(11) NOT NULL, "FullName" varchar(200) NOT NULL, "EmailId" varchar(200) NOT NULL, "Password" varchar(255) NOT NULL, "RegDate" NOT NULL DEFAULT CURRENT_TIMESTAMP) ENGINE=InnoDB DEFAULT CHARSET=latin1;

config.php

Izveidojiet db konfigurācijas failu, izmantojot mysqli paplašinājumu. Norādiet akreditācijas datus atbilstoši savai konfigurācijai

indekss.php

Izveidojiet HTML veidlapu lietotāja reģistrācijai.

Reģistrēties Pilns Vārds E-pasts Parole

Jau ir reģistrēta. piesakieties šeit

Jquery/Ajax lietotāju e-pasta pieejamībai

check_availability.php

Šajā lapā mēs pārbaudīsim lietotāja e-pasta pieejamību. Izveidojiet veikala procedūru ar nosaukuma pārbaudes pieejamību
Veikala procedūras kods:

DELIMITER $ CREATE DEFINER=`root`@`localhost` PROCEDŪRA `checkkavailbilty`(IN `email` VARCHAR(255)) NO SQL SELECT EmailId FROM tblregistration WHERE EmailId=email$ DELIMITER ;

Tagad izveidojiet veikala procedūru lietotāja reģistrācijai.
Veikala lietotāja reģistrācijas procedūra

DELIMITER $ CREATE DEFINER=`root`@`localhost` PROCEDŪRA `reģistrācija`(IN `fname` VARCHAR(200), IN `emailid` VARCHAR(200), IN `parole` VARCHAR(255)) SQL neievietot tblregistration( FullName,EmailId,Password) VALUES(fname,emailid,password)$ DELIMITER ;

Pēc veikala procedūras izveides izpildiet veikala procedūru.

Šeit ir pilns kods, ko esam uzrakstījuši reģistrācijai (index.php):

Reģistrācija, izmantojot veikala procedūru funkciju checkAvailability() ( $("#loaderIcon").show(); jQuery.ajax(( url: "check_availability.php", data:"emailid="+$("#email").val (), ierakstiet: "POST", panākumi:function(data)( $("#user-availability-status").html(data); $("#loaderIcon").hide(); ), error:function ()() )); ) Reģistrēties Pilns vārds E-pasts Parole

Jau ir reģistrēta. piesakieties šeit

login.php

Izveidojiet pieteikšanās veidlapu lietotāja pieteikšanās.

Pieslēgties

Vai neesat reģistrējies? Izveidot kontu

Tagad izveidojiet veikala procedūru pieteikšanās ar vārdu pieteikšanās.
Pieteikšanās veikalā procedūra:

DELIMITER $ CREATE DEFINER=`root`@`localhost` PROCEDŪRA `pieteikšanās`(IN `lietotāja pasts` VARCHAR(255), IN `parole` VARCHAR(255)) NAV SQL SELECT EmailId,Parole no tblregistration kur EmailId=useremail un Password=useremail parole$ DELIMITER ;

Tagad izpildiet pieteikšanās krātuves procedūru