Instruktion
Börja skapa ett registreringsformulär med en tagg
, mellan vilka du måste placera ytterligare taggar som tillåter användare att gå in i form egna uppgifter.Öppna html-filen och börja skriva in koden. Taggen som ansvarar för att skapa formuläret är "form". Vi skriver taggen tillsammans med attributen "form action=”obrabotka.php” method=”post” name”forma1””. Låt oss börja skapa formulärelement. Nästan alla element är gjorda med taggen , och dess "type"-attribut, som ansvarar för typen av data, till exempel text, lösenord och mer. Vi ger alltid namnet "namn" till något av attributen.
Vi skriver: "br"Ange namn: "br"
"input type="text" name="fio""
"br" Ange lösenord: "br"
"input type="lösenord" namn="pass""
"br"Ange E-mai:l"br"
"input type="text" name="e-post"".
Därefter skapar vi alternativknappsväljarelementet. En alternativknapp är ett formulärelement som, när det klickas med markören och andra alternativknappar, stängs av. Låt oss förklara med ett exempel på vår form. När du beställer en kurs kommer valet att bestå av antingen CD eller DVD, så du behöver välja en. Attributelementet "type" - "radio" är ansvarigt för att skapa en sådan knapp. Vi kommer att skriva samma namn för mediatypen, så vi kommer att specificera attributet "värde" så att hanteraren kan exakt bestämma värdet på variabeln. Vi skriver koden: "br"Välj mediaalternativet:"br"
"input type="radio" name="skiva" värde="(!LANG:cd"" CD "br"!}
"input type="radio" name="skiva" värde="(!LANG:dvd"" DVD "br"!}
Om attributet "värde" är inställt på texten kommer formuläret omedelbart att visa värdet som vi tilldelade detta attribut. Till exempel så att det i form av ett fullständigt namn redan finns något slags namn (värde = "namn").
Ange ett annat element och ställ in typ till "kryssruta" för att tillåta användare att markera mer än ett alternativ i formuläret. Till exempel:
(Kontakta mig vid leverans)
(Prenumerera på )
Skapa en skicka-knapp genom att skriva taggen och skriv lika med "submit", värdet satt till "Submit". Också i en annan tagg gör en "Återställ"-knapp genom att ställa in typ till "återställ" respektive värde till "Återställ". Till exempel, så här:
Knappen Skicka är till för att skicka in data och knappen Återställ är till för att rensa formuläret om det behövs.
Ange en avslutande tagg att avsluta form. Spara sidan.
Källor:
- W3C:s webbplats
- beställningsformulär på webbplatsen
Formuläret registreringär en inbyggd Joomla panelmodul. Du behöver inte vara expert på webbprogrammering för att lägga till det. Men om du bestämmer dig för att ändra det kan du implementera det med hjälp av Community Builder-komponenten eller manuellt. Du behöver bara redigera de nödvändiga elementen efter att ha studerat grunderna för att bygga webbplatser.
Instruktion
Gå till Joomlas adminpanel och öppna inställningarna för de inbyggda modulerna. Gå till fliken "Avancerat" och klicka på knappen "Skapa". Fönstret "Modulhanteraren" kommer upp, där du måste välja och aktivera form registrering. Ange önskad titel för titeln, markera rutan bredvid raden "Visa titel".
Öppna avsnittet "Initial text" i formulärmodulen registrering och redigera standardtexten för besökare om det inte passar dig. I posten "Logga in" kan du välja hur användaren ska bli anropad på webbplatsen: under hans namn eller inloggning. Klicka på knappen "Spara" för att ändringarna ska träda i kraft.
Ladda upp Community Builder till din webbplats. För att göra detta, gå till avsnittet "Ladda upp paketfil" och klicka på knappen "Bläddra". När du har valt de nödvändiga dokumenten klickar du på knappen "Ladda ner och installera". Gå till adminpanelen och kör den installerade komponenten.
Öppna fliken "Registrering" och gör nödvändiga ändringar i form registrering. Denna applikation är väldigt lätt att använda, men om du bara vill ändra ett eller två fält är det bekvämare att redigera manuellt.
Skapa en säkerhetskopia av filerna du kommer att ändra för att göra justeringar i form registrering. Detta gör att du kan återställa alla åtgärder och återställa webbplatsen i händelse av fel. Bestäm vilket fält du vill redigera eller lägga till. Till exempel vill du lägga till form registrering Stadsfält.
Öppna filen default.php som finns på komponenter/com_user/views/register/tmpl. Lägg till en "City"-skärm genom att klistra in form registrering motsvarande HTML-kod. För att göra detta kan du kopiera vilket annat objekt som helst och redigera det för staden (staden). Gör dessa ändringar i tabellen jos_users. Öppna filen user.php som finns på länken libraries/joomla/database/table. Lägg till en ny variabel till den. Spara dina inställningar och starta om webbplatsen.
Källor:
- hur man byter modul i joomla
Tips 7: Hur man gör en tillfällig registrering utan ägare
Det är långt ifrån alltid som glada nyanlända lyckas uppfylla lagens krav på registrering på bostadsorten (gör tillfällig registrering) inom den fastställda tidsramen - 90 dagar. Ibland kan orsaken till detta vara lägenhetsägarens ovilja eller oförmåga att komma till lämplig organisation för att utföra registreringsåtgärder.
Naturligtvis, om ägaren inte har uttryckt en önskan om att legalisera din tillfälliga vistelse i sitt boende, kommer du inte att kunna registrera dig. Undantaget är när du registrerar ditt minderåriga barn på platsen för din registrering. I detta fall krävs inte ägarens samtycke.
Men om problemet med tillfällig registrering bara är ägarens brist på önskan att besöka de anställda som är ansvariga för att ta emot dokument för registrering, ger bestämmelserna möjlighet att erhålla tillfällig registrering utan närvaro av ägaren.
Om grunden för att flytta in är ett anställningsavtal, kan du skicka ett notariekontrakt med post med bifogad fil till andra dokument (en kopia av ditt pass, en ifylld ansökan). I en sådan situation har de personer som är ansvariga för att ta emot handlingarna inte skyldigheten att bestyrka en kopia av detta avtal, och ägaren av lokalen sätter inte sin underskrift på ansökan.
Om det är möjligt att endast lämna in kontraktet i en enkel skriftlig form, är de ansvariga personerna skyldiga att intyga ägarens och registrantens underskrift i ansökan. I denna situation är närvaron av ägaren oumbärlig.
Ett registreringsbevis på bostadsorten kan också erhållas per post.
Även om ägaren inte är skyldig att vara närvarande när han skaffar tillfällig registrering, är det inte värt att hoppas att han inte får reda på nya hyresgäster. Efter genomförda registreringsåtgärder kommer FMS-myndigheterna att skicka honom ett meddelande om den person som är registrerad på hans bostadsyta.
Tips 8: Hur man fyller i ett 3-personligt inkomstskatteformulär för att sälja en bil
Om du har sålt en bil som du har ägt i mer än tre år, läs inte längre: Från och med 2011 har du automatiskt rätt till fastighetsskatteavdrag. Det innebär att du inte behöver lämna in en deklaration. Men om du har ägt den kortare tid måste du upprätta de nödvändiga papper. Det enklaste sättet att göra detta är med deklarationsprogrammet.
Du kommer behöva
- - en dator;
- - tillgång till Internet;
- - programmet "Deklaration" från SNIVS från Ryska federationens federala skattetjänst;
- - avtal om försäljning av en bil;
- - dokument som bekräftar din övriga inkomst och betalning av personlig inkomstskatt från dem för det senaste året.
Instruktion
Du kan ladda ner den senaste versionen av programmet på webbplatsen för huvudforskningscentret för Federal Tax Service (GNIVTS FTS) i Ryssland. Det sprider sig
Hallå! Nu ska vi försöka implementera den enklaste registreringen på webbplatsen med PHP + MySQL. För att göra detta måste Apache vara installerat på din dator. Hur vårt manus fungerar visas nedan.
1. Låt oss börja med att skapa användartabellen i databasen. Den kommer att innehålla användardata (inloggning och lösenord). Låt oss gå till phpmyadmin (om du skapar en databas på din PC http://localhost/phpmyadmin/). Skapa en tabell användare, kommer den att ha 3 fält.
Jag skapar den i mysql-databas, du kan skapa den i en annan databas. Ställ sedan in värdena, som i figuren:
2. En anslutning till denna tabell krävs. Låt oss skapa en fil bd.php. Dess innehåll:
$db = mysql_connect("din MySQL-server","logga in på denna server","lösenord till denna server");
mysql_select_db ("namnet på databasen att ansluta till", $db);
?>
I mitt fall ser det ut så här:
$db = mysql_connect("localhost","användare","1234");
mysql_select_db("mysql",$db);
?>
Vi sparar bd.php.
Bra! Vi har en tabell i databasen, en koppling till den. Nu kan du börja skapa en sida där användare kommer att lämna sin data.
3. Skapa en reg.php-fil med innehåll (alla kommentarer inuti):
registrering
4. Skapa en fil, som kommer att mata in data i databasen och spara användaren. save_user.php(kommentarer inuti):
{
}
//om login och lösenord skrivs in så bearbetar vi dem så att taggar och skript inte fungerar, man vet aldrig vad folk kan ange
// ta bort extra mellanslag
$login = trim($login);
$password = trim($password);
// ansluta till databasen
// kontrollera om det finns en användare med samma inloggning
$result = mysql_query("VÄLJ ID FRÅN användare WHERE login="$login",$db);
if (!empty($myrow["id"])) (
exit("Tyvärr, användarnamnet du angav är redan registrerat. Vänligen ange ett annat användarnamn.");
}
// om det inte finns några, spara sedan data
$result2 = mysql_query ("INSERT INTO användare (inloggning, lösenord) VÄRDEN("$login","$password")");
// Kontrollera om det finns fel
if ($result2=="TRUE")
{
echo "Du har registrerat dig! Nu kan du komma in på webbplatsen. Huvudsida";
}
annan(
echo "Fel! Du är inte inloggad.";
}
?>
5. Nu kan våra användare registrera sig! Därefter måste du skapa en "dörr" för att komma in på webbplatsen för redan registrerade användare. index.php(kommentarer inuti):
// hela proceduren fungerar på sessioner. Det är i den som användarens data lagras medan han är på sajten. Det är väldigt viktigt att lansera dem i början av sidan!!!
session_start();
?>
Huvudsida
// Kontrollera om variablerna för inloggning och användar-id är tomma
if (tom($_SESSION["login") eller tom($_SESSION["id"]))
{
// Om den är tom visar vi inte länken
echo "Du är inloggad som gäst
Denna länk är endast tillgänglig för registrerade användare";
}
annan
{
I fil index.php vi kommer att visa en länk som endast är öppen för registrerade användare. Detta är hela poängen med skriptet - att begränsa åtkomsten till all data.
6. Det finns en fil med verifiering av angivna inloggningsuppgifter och lösenord. testreg.php (kommentarer inuti):
session_start();// hela proceduren fungerar på sessioner. Det är i den som användarens data lagras medan han är på sajten. Det är väldigt viktigt att lansera dem i början av sidan!!!
if (isset($_POST["login"])) ( $login = $_POST["login"]; if ($login == "") ( unset($login);) ) //lägg in inloggningen som anges av användaren till variabeln $login, om den är tom, förstör vi variabeln
if (isset($_POST["lösenord"])) ( $password=$_POST["lösenord"]; if ($password =="") ( unset($password);) )
//lägg in lösenordet som användaren skrivit in i variabeln $password, om det är tomt, förstör sedan variabeln
if (empty($login) eller tom($password)) //om användaren inte har angett ett inloggningsnamn eller lösenord, då utfärdar vi ett felmeddelande och stoppar skriptet
{
exit("Du skrev inte in all information, gå tillbaka och fyll i alla fält!");
}
//om login och lösenord skrivs in så bearbetar vi dem så att taggar och skript inte fungerar, man vet aldrig vad folk kan ange
$login = stripslashes($login);
$login = htmlspecialchars($login);
$password = stripslashes($password);
$password = htmlspecialchars($password);
// ta bort extra mellanslag
$login = trim($login);
$password = trim($password);
// ansluta till databasen
include("bd.php");// bd.php-filen ska finnas i samma mapp som alla andra, om den inte är det är det bara att byta sökväg
$result = mysql_query("SELECT * FROM users WHERE login="$login",$db); //hämta all data om användaren med den angivna inloggningen från databasen
$myrow = mysql_fetch_array($result);
if (tom($myrow["lösenord"]))
{
//om användaren med den angivna inloggningen inte existerar
}
annan(
//om det finns, kontrollera lösenord
if ($myrow["lösenord"]==$lösenord) (
//om lösenorden matchar, så startar vi sessionen för användaren! Du kan gratulera honom, han gick in!
$_SESSION["login"]=$myrow["login"];
$_SESSION["id"]=$myrow["id"];//dessa data används väldigt ofta, så den inloggade användaren kommer att "bära" dem
echo "Du har lyckats logga in på sidan! Huvudsida";
}
annan(
//om lösenorden inte matchar
Exit("Tyvärr, inloggningen eller lösenordet du angav är felaktigt.");
}
}
?>
Det var allt! Kanske är lektionen tråkig, men väldigt användbar. Endast idén med registrering visas här, ytterligare kan du förbättra den: lägg till skydd, design, datafält, ladda upp avatarer, logga ut från kontot (för detta, förstör helt enkelt variablerna från sessionen med funktionen avstängd) etc. Lycka till!
Kollade allt, det funkar bra!
Jag uppmärksammar dig på en mycket enkel och funktionell skript för registrering och auktorisering på webbplatsen, som består av 3 PHP-filer med anslutning av 2 java-skript, med hjälp av vilka fel visas i själva formuläret utan att ladda om sidan.
Skriptet har testats framgångsrikt på PHP 5.3.3 och PHP 5.6.3.
Vad kan och har ett manus
- Registrera nya användare;
- Auktorisera användare och spara cookies under en viss period (det finns ingen anledning att logga in varje gång);
- Visa och dölj viss information för auktoriserad respektive ej auktoriserad;
- Den har en ADMIN-PANEL, där du kan redigera all data och ta bort användare.
Ibid DEMO och adminpanel
1 STEG .Om du använder ett lokalt registrerings- och auktoriseringsskript med DENWER behöver du inte göra ändringar i filerna för att ansluta till databasen.
Annars öppnar du filerna: stayt.php , classes/Auth.class.php och adminka/connect.php , och längst upp, ersätt data för att ansluta till databasen med din egen.
2 STEG.
Gå (om du använder DENWER) till adressen: http://localhost/Tools/phpmyadmin/ , om den är värd, klicka sedan på Databaser och skapa en ny databas med namnet: registr and comparison: utf8_general_ci .
Naturligtvis kan du ange ditt eget namn, men då måste du ersätta det i filerna för att ansluta till databasen (se steg 1).
3 STEG.
Klicka på det skapade databasregistret och sedan på den översta fliken SQL och i det visade fönstret för inmatning, klistra in den här koden och klicka på OK. SKAPA TABELL OM INTE FINNS `my_users` (`id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) NOT NULL, `names` varchar(15) NOT NULL, `password` varchar(255) NOT NULL, `salt` varchar(100) INTE NULL, PRIMÄRNYCKEL (`id`)) ENGINE=MyISAM DEFAULT CHARSET=utf8; Allt! Gå till webbläsaren till din adress, försök och experimentera.
Adminpanel
Efter att du har gjort minst en registrering kan du gå till ADMINKU.
Logga in på ADMIN PANEL:
http://Your_site.ru/adminka/
Glöm inte att lösenordsskydda den här mappen och du kan även byta namn på den.
När du öppnar adminpanelen, tryck på SÖK-knappen så ser du alla registrerade användare, där när du klickar på ett specifikt ID-nummer kommer du att öppna användardata för redigering.
Du kan också snabbt hitta en användare via hans e-post, skriv bara in en känd e-post i SÖK-fältet och klicka på knappen.
Jag rekommenderar inte att du använder ADD-knappen, eftersom användaren läggs till i systemet utan lösenord. Och jag har ingen aning om varför de gjorde det överhuvudtaget.
Det är allt som inte fungerar eller är oklart – ställ frågor.
Längs vägen kan du prova
Att skapa en medlemskapsbaserad webbplats verkar till en början vara en skrämmande uppgift. Om du någonsin velat göra detta själv, då bara gav upp när du började fundera på hur du ska sätta ihop det med dina PHP-kunskaper, då är den här artikeln för dig. Vi kommer att gå igenom alla aspekter av att skapa en medlemskapsbaserad webbplats, med ett säkert medlemsområde skyddat med lösenord.
Hela processen består av två stora delar: användarregistrering och användarautentisering. I den första delen kommer vi att täcka skapandet av registreringsformuläret och lagring av data i en MySQL-databas. I den andra delen kommer vi att skapa inloggningsformuläret och använda det för att ge användare åtkomst i det säkra området.
Ladda ner koden
Du kan ladda ner hela källkoden för registrerings-/inloggningssystemet från länken nedan:
Konfiguration och uppladdning
ReadMe-filen innehåller detaljerade instruktioner.
Öppna source\include\membersite_config.php fil i en textredigerare och uppdatera konfigurationen. (Databasinloggning, din webbplats namn, din e-postadress etc).
Ladda upp hela katalogens innehåll. Testa register.php genom att skicka in formuläret.
Anmälningsformuläret
För att skapa ett användarkonto behöver vi samla in en minimal mängd information från användaren. Vi behöver hans namn, hans e-postadress och hans önskade användarnamn och lösenord. Naturligtvis kan vi be om mer information vid det här laget, men en lång blankett är alltid en avstängning. Så låt oss begränsa oss till just dessa områden.
Här är anmälningsformuläret:
Så vi har textfält för namn, e-post och lösenord. Observera att vi använder för bättre användbarhet.
Form validering
Vid det här laget är det en bra idé att sätta någon form av valideringskod på plats, så att vi ser till att vi har all data som krävs för att skapa användarkontot. Vi måste kontrollera om namn och e-postadress samt lösenord är ifyllda och att e-postmeddelandet är i rätt format.
Hantera formulärinlämningen
Nu måste vi hantera formulärdata som lämnas in.
Här är sekvensen (se filen fg_membersite.php i den nedladdade källan):
funktion RegisterUser() ( if(!isset($_POST["submitted")) (retur false; ) $formvars = array(); if(!$this->ValidateRegistrationSubmission()) (retur false; ) $this- >CollectRegistrationSubmission($formvars); if(!$this->SaveToDatabase($formvars)) ( return false; ) if(!$this->SendUserConfirmationEmail($formvars)) ( return false; ) $this->SendAdminIntimationEmail($ formvars); return true;)
Först validerar vi inlämningen av formuläret. Sedan samlar vi in och "sanerar" formulärinlämningsdata (gör alltid detta innan du skickar e-post, sparar i databasen etc). Forminlämningen sparas sedan i databastabellen. Vi skickar ett e-postmeddelande till användaren och begär bekräftelse. Sedan informerar vi administratören om att en användare har registrerat sig.
Spara data i databasen
Nu när vi samlat in all data måste vi lagra den i databasen.
Så här sparar vi formulärinlämningen i databasen.
funktion SaveToDatabase(&$formvars) ( if(!$this->DBLogin()) ( $this->HandleError("Databasinloggning misslyckades!"); return false; ) if(!$this->Ensuretable()) ( return false; ) if(!$this->IsFieldUnique($formvars,"email")) ( $this->HandleError("Detta e-postmeddelande är redan registrerat"); return false; ) if(!$this->IsFieldUnique( $formvars,"användarnamn")) ( $this->HandleError("Detta användarnamn används redan. Försök med ett annat användarnamn"); return false; ) if(!$this->InsertIntoDB($formvars)) ( $this- >HandleError("Infogning i databasen misslyckades!"); return false; ) return true; )
Observera att du har konfigurerat databasinloggningsdetaljerna i filen memberite_config.php. I de flesta fall kan du använda "localhost" för databasvärd.
Efter att ha loggat in ser vi till att tabellen finns.(Om inte kommer skriptet att skapa den önskade tabellen).
Då ser vi till att användarnamnet och e-postadressen är unika. Om det inte är unikt returnerar vi felet tillbaka till användaren.
Databastabellstrukturen
Detta är tabellstrukturen. Funktionen CreateTable() i filen fg_membersite.php skapar tabellen. Här är koden:
function CreateTable() ( $qry = "Skapa tabell $this->tablename (". "id_user INT NOT NULL AUTO_INCREMENT ,". "namn VARCHAR(128) NOT NULL ,". "e-posta VARCHAR(64) NOT NULL ,". "phone_number VARCHAR(16) NOT NULL ,". "användarnamn VARCHAR(16) NOT NULL ,". "lösenord VARCHAR(32) NOT NULL ,". "bekräftakod VARCHAR(32) ,". "PRIMÄRNYCKEL (id_user)". ")"; if(!mysql_query($qry,$this->connection)) ( $this->HandleDBError("Fel vid skapande av tabellen \nfrågan var\n $qry"); return false; ) return true; )
Fältet id_user kommer att innehålla användarens unika ID och är också den primära nyckeln i tabellen. Observera att vi tillåter 32 tecken för lösenordsfältet. Vi gör detta eftersom vi, som en extra säkerhetsåtgärd, kommer att lagra lösenordet i databasen krypterat med MD5. Observera att eftersom MD5 är en enkelriktad krypteringsmetod kommer vi inte att kunna återställa lösenordet om användaren glömmer det.
Infoga registreringen i tabellen
Här är koden som vi använder för att infoga data i databasen. Vi kommer att ha all vår data tillgänglig i $formvars-arrayen.
function InsertIntoDB(&$formvars) ( $confirmcode = $this->MakeConfirmationMd5($formvars["email"]); $insert_query = "infoga i ".$this->tabellnamn."(namn, e-post, användarnamn, lösenord, confirmcode) values ("" . $this->SanitizeForSQL($formvars["namn"]) . "", "" . $this->SanitizeForSQL($formvars["email"]) . "", "" . $ this->SanitizeForSQL($formvars["användarnamn"]) . "", "" . md5($formvars["lösenord"]) . "", "" . $confirmcode . "")"; if(! mysql_query( $insert_query ,$this->connection)) ( $this->HandleDBError("Fel vid infogning av data i tabellen\nquery:$insert_query"); return false; ) return true; )
Observera att vi använder PHP-funktionen md5() för att kryptera lösenordet innan vi infogar det i databasen.
Dessutom skapar vi den unika bekräftelsekoden från användarens e-postadress.
Skickar mejl
Nu när vi har registreringen i vår databas kommer vi att skicka ett bekräftelsemail till användaren. Användaren måste klicka på en länk i bekräftelsemailet för att slutföra registreringsprocessen.
function SendUserConfirmationEmail(&$formvars) ( $mailer = new PHPMailer(); $mailer->CharSet = "utf-8"; $mailer->AddAddress($formvars["email"],$formvars["name"]) ; $mailer->Subject = "Din registrering med ".$this->sitename; $mailer->From = $this->GetFromAddress(); $confirmcode = urlencode($this->MakeConfirmationMd5($formvars["e-post" ])); $confirm_url = $this->GetAbsoluteURLFolder()."/confirmreg.php?code=".$confirmcode; $mailer->Body ="Hej ".$formvars["namn"]."\r\ n\r\n". "Tack för din registrering med ".$this->sitename."\r\n". "Klicka på länken nedan för att bekräfta din registrering.\r\n". "$confirm_url\r \n". "\r\n". "Hälsningar,\r\n". "Webbmaster\r\n". $this->webbplatsnamn; if(!$mailer->Send()) ( $this-> HandleError("Det gick inte att skicka registreringsbekräftelsemail."); return false; ) return true; )
uppdateringar
9 januari 2012
Funktionerna Återställ lösenord/Ändra lösenord läggs till
Koden delas nu på GitHub .
Välkommen tillbakaUserFullName(); ?>!
Licens
Koden delas under LGPL-licensen. Du kan fritt använda den på kommersiella eller icke-kommersiella webbplatser.
Inga relaterade inlägg.
Kommentarer till detta inlägg är stängda.
Processen att skapa ett registreringssystem är ganska mycket arbete. Du måste skriva kod som kontrollerar giltigheten av e-postadresser, skickar bekräftelsemail, erbjuder lösenordsåterställning, lagrar lösenord på ett säkert ställe, validerar inmatningsformulär och mer. Även när du gör allt detta kommer användare att vara ovilliga att registrera sig, eftersom även den minimala registreringen kräver deras aktivitet.
I dagens handledning ska vi utveckla ett enkelt inloggningssystem där du inte behöver några lösenord! Som ett resultat kommer vi att få ett system som enkelt kan modifieras eller integreras i en befintlig PHP-sajt. Om du är intresserad, fortsätt läsa.
PHP
Nu är vi redo att komma till PHP-koden. Huvudfunktionaliteten i registreringssystemet tillhandahålls av användarklassen, som du kan se nedan. Klassen använder (), som är ett minimalistiskt databasbibliotek. Användarklassen ansvarar för att komma åt databaser, generera tokens för inloggning och validera dem. Det ger oss ett enkelt gränssnitt som enkelt kan integreras i registreringssystemet på dina PHP-baserade webbplatser.
user.class.php
// Privat ORM-instans
privat $orm;
/**
* Hitta en användare med en tokensträng. Endast giltiga tokens tas med
* hänsyn. En token är giltig i 10 minuter efter att den har genererats.
* @param string $token Token att söka efter
* @returnUser
*/
offentlig statisk funktion findByToken($token)(
// hitta den i databasen och se till att tidsstämpeln är korrekt
->where("token", $token)
->where_raw("token_validity > NOW()")
->hitta_ett();
If(!$result)(
returnera falskt;
}
Returnera ny användare($result);
}
/**
* Antingen logga in eller registrera en användare.
* @returnUser
*/
Offentlig statisk funktion loginEllerRegister($email)(
// Om en sådan användare redan finns, returnera den
If(Användare::exists($email))(
returnera ny användare($email);
}
// Annars skapar du den och returnerar den
Returnera användare::create($email);
}
/**
* Skapa en ny användare och spara den i databasen
* @param string $email Användarens e-postadress
* @returnUser
*/
Privat statisk funktion skapa($email)(
// Skriv en ny användare till databasen och returnera den
$result = ORM::for_table("reg_users")->create();
$result->email = $email;
$result->save();
Returnera ny användare($result);
}
/**
* Kontrollera om en sådan användare finns i databasen och returnera en boolean.
* @param string $email Användarens e-postadress
* @return boolean
*/
Offentlig statisk funktion finns($email)(
// Finns användaren i databasen?
$result = ORM::for_table("reg_users")
->where("email", $email)
->count();
returnera $result == 1;
}
/**
* Skapa ett nytt användarobjekt
* @param $param ORM-instans, id, e-post eller null
* @returnUser
*/
Offentlig funktion __construct($param = null)(
If($param-instans av ORM)(
// En ORM-instans skickades
$this->orm = $param;
}
else if(is_string($param))(
// Ett mejl skickades
$this->
->where("e-post", $param)
->hitta_ett();
}
annan(
If(är_numerisk($param))(
// Ett användar-ID skickades som en parameter
$id = $param;
}
annars if(isset($_SESSION["loginid"]))(
// Inget användar-ID skickades, titta in i sessionen
$id = $_SESSION["loginid"];
}
$this->orm = ORM::for_table("reg_users")
->where("id", $id)
->hitta_ett();
}
/**
* Genererar en ny SHA1-inloggningstoken, skriver den till databasen och returnerar den.
* @retur sträng
*/
Offentlig funktion genereraToken()(
// generera en token för den inloggade användaren. Spara den i databasen.
$token = sha1($this->email.time().rand(0, 1000000));
// Spara token till databasen,
// och markera den som giltig endast under de kommande 10 minuterna
$this->orm->set("token", $token);
$this->orm->set_expr("token_validity", "ADDTIME(NU(),"0:10")");
$this->orm->save();
Returnera $token;
}
/**
* Logga in denna användare
* @retur ogiltig
*/
public function login()(
// Markera användaren som inloggad
$_SESSION["loginid"] = $this->orm->id;
// Uppdatera last_login db-fältet
$this->orm->set_expr("sista_inloggning", "NU()");
$this->orm->save();
}
/**
* Förstör sessionen och logga ut användaren.
* @retur ogiltig
*/
public function logout()(
$_SESSION = array();
unset($_SESSION);
}
/**
* Kontrollera om användaren är inloggad.
* @return boolean
*/
Offentlig funktion logdIn()(
return isset($this->orm->id) && $_SESSION["loginid"] == $this->orm->id;
}
/**
* Kontrollera om användaren är administratör
* @return boolean
*/
Offentlig funktion är Admin()(
return $this->rank() == "administratör";
}
/**
* Hitta typen av användare. Det kan vara antingen admin eller vanlig.
* @retur sträng
*/
public function rank()(
if($this->orm->rank == 1)(
returnera "administratör";
}
Returnera "vanlig";
}
/**
* Magisk metod för att komma åt elementen i det privata
* $orm-instans som egenskaper för användarobjektet
* @param sträng $key Namnet på den åtkomliga egenskapen
* @retur blandat
*/
Offentlig funktion __get($key)(
if(isset($this->orm->$key))(
returnera $this->orm->$nyckel;
}
returnera null;
}
}
Tokens genereras med hjälp av algoritmen och lagras i databasen. Vi använder från MySQL för att ställa in värdet i kolumnen token_validity till 10 minuter. När vi validerar en token säger vi till motorn att vi behöver en token, token_validity-fältet har ännu inte gått ut. Därför begränsar vi den tid under vilken token kommer att vara giltig.
Observera att vi använder den magiska metoden __get() i slutet av dokumentet för att komma åt egenskaperna för användarobjektet. Detta tillåter oss att komma åt data som lagras i databasen som egenskaper: $user->email, $user->token. Som ett exempel, låt oss se hur vi kan använda den här klassen i följande kodavsnitt:
En annan fil som lagrar nödvändig funktionalitet är functions.php. Där har vi några hjälpfunktioner som gör att vi kan hålla resten av koden snyggare.
Functions.php
Funktion send_email($from, $to, $subject, $meddelande)(
// Hjälpfunktion för att skicka e-post
$headers = "MIME-version: 1.0" . "\r\n";
$headers .= "Innehållstyp: text/plain; charset=utf-8" . "\r\n";
$headers .= "Från: ".$från . "\r\n";
return mail($to, $subject, $meddelande, $headers);
}
funktion get_page_url()(
// Ta reda på URL:en till en PHP-fil
$url = "http".(tom($_SERVER["HTTPS"])?"":"s")."://".$_SERVER["SERVER_NAME"];
If(isset($_SERVER["REQUEST_URI"]) && $_SERVER["REQUEST_URI"] != "")(
$url.= $_SERVER["REQUEST_URI"];
}
annan(
$url.= $_SERVER["PATH_INFO"];
}
Returnera $url;
}
function rate_limit($ip, $limit_hour = 20, $limit_10_min = 10)(
// Antalet inloggningsförsök den senaste timmen med denna IP-adress
$count_hour = ORM::for_table("reg_login_attempt")
->
->where_raw("ts > SUBTIME(NU(),"1:00")")
->count();
// Antalet inloggningsförsök under de senaste 10 minuterna med denna IP-adress
$count_10_min = ORM::for_table("reg_login_attempt")
->where("ip", sprintf("%u", ip2long($ip)))
->where_raw("ts > SUBTIME(NU(),"0:10")")
->count();
If($count_hour > $limit_hour || $count_10_min > $limit_10_min)(
throw new Exception("För många inloggningsförsök!");
}
}
function rate_limit_tick($ip, $email)(
// Skapa en ny post i tabellen för inloggningsförsök
$login_attempt = ORM::for_table("reg_login_attempt")->create();
$login_attempt->email = $email;
$login_attempt->ip = sprintf("%u", ip2long($ip));
$login_attempt->save();
}
function redirect($url)(
header("Plats: $url");
utgång;
}
Funktionerna rate_limit och rate_limit_tick tillåter oss att begränsa antalet auktoriseringsförsök under en viss tidsperiod. Auktoriseringsförsök registreras i databasen reg_login_attempt. Dessa funktioner körs när inloggningsformuläret skickas, som du kan se i följande kodavsnitt.
Koden nedan är hämtad från index.php och den ansvarar för att validera inloggningsformuläret. Det returnerar ett JSON-svar som drivs av jQuery-koden vi såg i assets/js/script.js.
index.php
If(!empty($_POST) && isset($_SERVER["HTTP_X_REQUESTED_WITH"]))(
// Mata ut ett JSON-huvud
Header("Innehållstyp: application/json");
// Är e-postadressen giltig?
If(!isset($_POST["email"]) || !filter_var($_POST["email"], FILTER_VALIDATE_EMAIL))(
throw new Exception("Ange en giltig e-postadress.");
}
// Detta kommer att skapa ett undantag om personen är ovan
// gränserna för tillåtna inloggningsförsök (se functions.php för mer):
rate_limit($_SERVER["REMOTE_ADDR"]);
// Spela in detta inloggningsförsök
rate_limit_tick($_SERVER["REMOTE_ADDR"], $_POST["e-post"]);
// Skicka meddelandet till användaren
$message = "";
$email = $_POST["e-post"];
$subject = "Din inloggningslänk";
Om(!Användare::exists($email))(
$subject = "Tack för att du registrerade dig!";
$message = "Tack för att du registrerade dig på vår sida!\n\n";
}
// Försök att logga in eller registrera personen
$user = Användare::loginEllerRegister($_POST["e-post"]);
$message.= "Du kan logga in från denna URL:\n";
$message.= get_page_url()."?tkn=".$user->generateToken()."\n\n";
$message.= "Länken kommer att upphöra automatiskt efter 10 minuter.";
$result = send_email($fromEmail, $_POST["email"], $subject, $message);
If(!$result)(
throw new Exception("Det uppstod ett fel när din e-post skickades. Försök igen.");
}
Die(json_encode(array(
"message" => "Tack! Vi har skickat en länk till din inkorg. Kontrollera din skräppostmapp också."
)));
}
}
catch(Undantag $e)(
Die(json_encode(array(
"error"=>1,
"meddelande" => $e->getMessage()
)));
}
Efter framgångsrik auktorisering eller registrering skickar ovanstående kod ett e-postmeddelande till en person med en länk för auktorisering. Token (token) blir tillgänglig som $_GET "tkn"-variabeln på grund av den genererade URL:en.
index.php
If(isset($_GET["tkn"]))(
// Är detta en giltig inloggningstoken?
$user = Användare::findByToken($_GET["tkn"]);
//Ja! Logga in användaren och omdirigera till den skyddade sidan.
$user->login();
redirect("protected.php");
}
// Ogiltig token. Omdirigera tillbaka till inloggningsformuläret.
redirect("index.php");
}
Att köra $user->login() kommer att skapa de nödvändiga variablerna för sessionen, vilket gör att användaren kan förbli inloggad vid efterföljande inloggningar.
Utloggning ur systemet genomförs på ungefär samma sätt:
Index.php
If(isset($_GET["logga ut"]))(
$användare = ny användare();
If($user->loggedIn())(
$user->logout();
}
redirect("index.php");
}
I slutet av koden omdirigerar vi användaren till index.php igen, så parametern ?logout=1 i URL:en exkluderas.
Vår index.php-fil kommer också att behöva skydd - vi vill inte att redan inloggade användare ska se formuläret. För att göra detta använder vi metoden $user->loggedIn():
Index.php
$användare = ny användare();
if($user->loggedIn())(
redirect("protected.php");
}
Slutligen, låt oss se hur du kan säkra en sida på din webbplats och göra den tillgänglig först efter att du har loggat in:
skyddad.php
// För att skydda alla php-sidor på din webbplats, inkludera main.php
// och skapa ett nytt användarobjekt. Det är så enkelt!
require_once "includes/main.php";
$användare = ny användare();
if(!$user->loggedIn())(
redirect("index.php");
}
Efter denna kontroll kan du vara säker på att användaren har loggat in. Du kommer också att ha tillgång till data lagrad i databasen som egenskaper för $user-objektet. Använd följande kod för att visa användarens e-postadress och deras rankning:
echo "Din e-post: ".$user->e-post;
echo "Din ranking: ".$user->rank();
Här är rank() en metod eftersom rangkolumnen i en databas vanligtvis innehåller siffror (0 för normala användare och 1 för administratörer), och vi måste konvertera allt detta till rangnamn, vilket implementeras med denna metod. För att konvertera en normal användare till en administratör, redigera helt enkelt användarposten i phpmyadmin (eller något annat databasprogram). Som administratör kommer användaren inte att ha några speciella förmågor. Du har själv rätt att välja vilka rättigheter du ska ge handläggare.
Redo!
På detta är vårt enkla registreringssystem redo! Du kan använda den på en befintlig PHP-webbplats, eller så kan du uppgradera den till dina egna behov.
