Õpetus: kuidas luua Web Auth koos sessiooniga

Ohw, see on väike samm kodeerimisel, kuid tohutu samm meie oskuste jaoks! Selle õpetuse lõpus on teil registrivaade, sisselogimisvaade ja profiilivaade ning saate teada, kuidas autentimist luua, kuidas kasutada sisse logitud kasutaja mäletamiseks sessiooni ja kuidas kaitsta ainult sisselogitud vaadet kasutaja saab sellele juurde pääseda

Selle õpetuse tulemuse leiate githubist siit

See õpetus on juhendi Kuidas kirjutada kontrollereid loomulik jätk. Võite minna selle õppematerjali juurde kõigepealt ja tulla hiljem tagasi või olla mässaja, jätta see vahele ja lugeda

Indeks

1. Looge uus projekt
2. Genereerige projekt Xcode
3. Reguleerige mudel: kasutaja
4. Loo vaade: registreeruge
5. Reguleerige UserController: lisage register-marsruudid
6. Loo vaade: Logi sisse
7. Reguleerige UserController: lisage sisselogimise marsruudid
8. Loo vaade: profiil
9. Reguleerige UserController: lisage profiil-marsruut
10. Reguleerige UserController: lisage väljalogimise marsruut
11. Kuhu siit edasi minna

1. Looge ja genereerige uus projekt

Uue projekti loomisel kasutame mallina eelnimetatud õpetuse tulemusi:

aur new projectName --template = vaporberlin / minu esimene kontroller

2. Genereerige projekt Xcode

Enne Xcode-projekti genereerimist peaksime muutma paketi nime Package.swiftis ja eemaldama ühe sõltuvuse, mida meil pole vaja:

// swift-tools-version: 4.0
impordi pakettkirjeldus
lase pack = pakett (
    nimi: "projectName", // muudetud
    sõltuvused: [
        .pakend (URL: "https://github.com/vapor/vapor.git", alates: "3.0.0-rc"),
        .pakend (URL: "https://github.com/vapor/leaf.git", alates: "3.0.0-rc"),
        .pakend (URL: "https://github.com/vapor/fluent-sqlite.git", pärit: "3.0.0-rc"),
        .pakk (URL: "https://github.com/vapor/auth.git", pärit: "2.0.0-rc"), // lisatud
        .pakk (URL: "https://github.com/vapor/crypto.git", alates: "3.0.0") // lisatud
    ],
    eesmärgid: [
        .target (nimi: "App", sõltuvused: ["Vapor", "Leaf", "FluentSQLite", "Autentimine", "Krüpto"]), // lisatud
        .target (nimi: "Run", sõltuvused: ["App"]),
        .testTarget (nimi: "AppTests", sõltuvused: ["App"]),
    ]
)

Nüüd terminalis juurkataloogi projektiNimi / käivitage:

aurude värskendus - ei

Sõltuvuse hankimine võib natuke aega võtta, kuid kui see tehtud, peaks teil olema selline projekti ülesehitus:

projektiNimi /
├── Pakett.swift
├── Allikad /
│ ├── Rakendus /
│ │ ├── Kontrollerid /
│ │. └── UserController.swift
│ │ ├── mudelid /
│ │ │ └── Kasutaja.swift
├── │ ├── rakendus.swift
├── │ ├── boot.swift
├── │ ├── konfigureerimine.swift
└── │ └── marsruudid
│ └── Käivita /
│ └── main.swift
├── Testid /
├── Ressursid /
│ └── Vaated /
│ └── kasutajavaade.leht
├── avalik /
├── Sõltuvused /
└── Tooted /

3. Reguleerige mudel: kasutaja

Kuna autentimiskogu teeme kogu autentimisega seotud töö ära, siis peame vaid teatama, millised on autentimise volitused. Ja nii laiendame oma Models / User.swiftis oma kasutajat PasswordAuthenticatable abil ja selle eest, et saaksime teda SessionAuthenticatable'is sessioonil talletada:

importige FluentSQLite
import aur
impordi autentimine // lisatud
lõpuklassi kasutaja: SQLiteModel {
  var id: Int?
  var email: String // lisatud
  var parool: String // lisatud
  init (id: Int? = null, e-post: string, parool: string) {
    self.id = id
    ise.post = e-post
    ise.parool = parool
  }
}
laiend Kasutaja: sisu {}
laiendi kasutaja: migratsioon {}
laiend Kasutaja: PasswordAuthenticatable {
  staatiline kasutajanimiKey: WritableKeyPath  {
    return \ Kasutaja.post
  }
  staatiline var passwordKey: WritableKeyPath  {
    return \ Kasutaja.parool
  }
}
laiend Kasutaja: SessionAuthenticatable {}

Eemaldasime kasutajanime atribuudi ja tutvustasime e-posti aadressi. Protokollile PasswordAuthenticatable vastavus palub meil öelda, kust leida kasutajanimiKey ja kust leida passwordKey ning päriselt kasutajanimiKey võib olla e-kiri, tegelik kasutajanimi või isegi telefoninumber, kui soovite, et teie kasutaja registreeruks selle asemel

4. Loo vaade: registreeruge

Tore! Rakendame vaate vormiga, milles on sisestatud e-kirjad ja üks parool! Esmalt nimetame oma kasutajavaate.lehe ümber registreerimiseks.leheks jaotises Ressursid / Vaated / ja kohandame seejärel sisu järgmiselt:



  
     veebi autentimine 
    
  
  
    
    
      
        
          
            

Registreeri

            
              
                 e-post                                
              
                 parool                                
              
                               
            
          
        
      
    
  
MÄRKUS. Nimi atribuut meie sisestussiltides on võtmed, mis on kaardistatud sisendi väärtusega ja mille nimi peab olema sama, mis meie kasutajaklassi omadusel, mida me oma kontrolleri funktsioonis kasutame. Nii saame kasutada kodeeritavat, et luua kasutajale nende väärtuste eksemplar. Veel sekundis

5. Reguleerige UserController: lisage register-marsruudid

Järgmisena peame rakendama marsruudi, mis tagastaks meie registrivaate. Kõigepealt eemaldage kõik funktsioonid meie kontrolleritest / UserController.swift:

import aur
lõpuklassi kasutajakontroller {
  // siin pole enam koodi
}

Nüüd on meil hea minna kasutama marsruuti, mis tagastab meie registrivaate:

import aur
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    tagasi proovida req.view (). render ("register")
  }
}

Ärgem unustage meie marsruute eemaldada / lisada saidil maps.swift:

import aur
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
}

Kui teete nüüd cmd + r või käivitate kõik, peaks see tõrgeteta olema ehitatud ja brauseris avamisel / registreerimisel peaksime nägema meie toredat registreerimisvormi !

Märkus. Enne rakenduse käivitamist valige kindlasti nupu kõrval skeem

Registreerimise lõpetamiseks on meie allesjäänud vorm marsruut, mis töötleb meie registreerimisvormi. Nii lisage meie kontrollerite / UserController.swift juurde:

import aur
import FluentSQL // lisatud
impordi krüpto // lisatud
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    ...
  }
  func register (_ req: Request) viskab -> Future  {
    tagasi proovida req.content.decode (Kasutaja ise) .flatMap {kasutaja
      naaske proovige User.query (sisse: req) .filter (\ User.email == user.email) .first (). flatMap {tulemus
        kui las _ = tulemus {
          tagasi Future.map (sisse: req) {_ sisse
            return req.redirect (aadressile "/ register")
          }
        }
        kasutaja.parool = proovige BCryptDigest (). räsi (kasutaja.parool)
        return user.save (sisse: req) .map {_ sisse
          tagasta req.redirect (aadressile: "/ login")
        }
      }
    }
  }
}

Olgu, nii et kasutame kodeeritavat, et luua kasutaja eksemplar andmetega, mida saadame koos vormiga. Järgmine on see, et veenduksime, et e-post on ainulaadne, otsides kasutaja, kellel on sama e-post. Kui meil on tulemus, siis teame, et e-post pole ainulaadne, nii et suuname tagasi registreerimiskuvale. Vastasel juhul jätkame ja alistame parooliga parooli, kuid räsime ja proovime siis kasutaja salvestada ning naasta sisselogimiskuvale.

Lõpuks lisage meie marsruutidele marsruutide piires.swift:

import aur
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
  router.post ("register", kasutage: userController.register)
}

Nüüd võiksite cmd + r projekti käivitada, minna / registreeruda ja proovida ennast e-kirjaga registreerida. See peaks teid suunama / sisselogimisele, mida veel pole. Lihtsalt minge tagasi / registreeruge ja proovige uuesti sama meiliga registreeruda, see suunab teid tagasi registrivaatesse! Tähendab, kõik töötab ideaalselt

6. Loo vaade: Logi sisse

Olgu, et sisselogimiseks vajame vormivaadet, millel on sisestatud e-kirjad ja teine ​​parool. Nii et jaotises Ressursid / Vaated / looge uus fail ja pange sellele nimi login.leaf ning lisage:



  
     veebi autentimine 
    
  
  
    
    
      
                 
          
            

Logi sisse

                         
              
                 e-post                                
              
                 parool                                
              
                               
                       
        
      
    
  
MÄRKUS. Valige fail login.leaf ja minge jaotisse Redaktor> Süntaksi värvimine> HTML

7. Reguleerige UserController: lisage sisselogimise marsruudid

Esimene sisselogimisvaate tagastamise tee on peaaegu liiga lihtne. Lisage meie kontrollerite / UserController.swift alla järgmine:

import aur
impordi FluentSQL
impordi krüpto
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    ...
  }
  func register (_ req: Request) viskab -> Future  {
    ...
  }
  func renderLogin (_ req: Request) viskab -> Future  {
    tagasi proovida req.view (). render ("login")
  }
}

Ja siis minge meie marsruutidele.swift ja lisage meie uus marsruut:

import aur
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
  router.post ("register", kasutage: userController.register)
  router.get ("sisselogimine", kasutage: userController.renderLogin)
}

Kui teeksite cmd + r ja registreeruksite end all / registreeru, suunatakse teid edukalt meie uude läikivasse sisselogimisvaatesse !

Järgmine marsruut võtab natuke rohkem. Vajame marsruuti, mis käsitleks sisselogimisvorme meie sisselogimisväärtustega. Käepidemega mõtlen kasutaja sessioonis vastuvõtmist, autentimist ja püsimist. Nii et lisage marsruutides kõigepealt:

import aur
impordi autentimine // lisatud
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
  router.post ("register", kasutage: userController.register)
  router.get ("sisselogimine", kasutage: userController.renderLogin)
  lase authSessionRouter = ruuter.grupitud (User.authSessionsMiddleware ())
  authSessionRouter.post ("login", kasutage: userController.login)
}

Teiseks minge meie configure.swift ja lisage järgmine teave:

import aur
importleht
importige FluentSQLite
impordi autentimine // lisatud
avaliku funktsiooni seadistamine (
  _ config: inout Config,
  _ env: inout Environment,
  _ teenused: inout teenused
) viskab {
  ...
  proovige teenuseid.register (AuthenticationProvider ())
  var middlewares = MiddlewareConfig.default ()
  middlewares.use (SessionsMiddleware.self)
  teenused.register (keskvaratooted)
  config.prefer (MemoryKeyedCache.self, jaoks: KeyedCache.self)
}

Lubage mul lühidalt selgitada, mida me siin tegime. Nagu mainitud, tahame, et saaksime oma kasutajat seansi jooksul säilitada. On ülimalt tore, et meil on vahetarkvara, mis teeb meie heaks töö. Püsivuse toimimiseks vajame vaid mõnda asja. Esiteks: me peame oma kasutaja kohandama seadmega SessionAuthenticatable, mille tegime selle õppematerjali 3. etapis. Teiseks: lähtestame ja loome ruuteri authSessionsMiddleware abil. Seejärel määratleme marsruudi, millel peaksid olema kõik sellega töötava vahetarkvara funktsioonid. Programmis configure.swift registreerime oma AuthenticationProvideri, SessionMiddleware ja konfigureerime lõpuks, kus seanssi jätkata: meie mällu (see tähendab ka, et kõik seansi andmed puhastatakse pärast rakenduse taaskäivitamist).

Seetõttu on meie veel rakendamata sisselogimisfunktsiooni sees kindel öelda, et suudame kasutajat autentida ja püsima jääda. Teeme seda!

Lisage meie kontrolleritele / UserController.swift järgmisele:

import aur
impordi FluentSQL
impordi krüpto
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    ...
  }
  func register (_ req: Request) viskab -> Future  {
    ...
  }
  func renderLogin (_ req: Request) viskab -> Future  {
    ...
  }
  func login (_ req: Request) viskab -> Future  {
    tagasi proovida req.content.decode (Kasutaja ise) .flatMap {kasutaja
      tagasta kasutaja autentimine (
        kasutajanimi: user.email,
        parool: kasutaja parool,
        kasutades: BCryptDigest (),
        sisse: req
      ) .map {kasutaja
        valvur lase kasutajal = kasutajal veel {
          tagasta req.redirect (aadressile: "/ login")
        }
        proovige req.authenticateSession (kasutaja)
        tagastama req.redirect (aadressile "/ profile")
      }
    }
  }
}

Oh, ma armastan, kui lihtne see tegelikult on! Seega kasutame staatilist funktsiooni, et kontrollida, kas saatmismandaadid on õiged. Kuna oleme funktsioonis registerryryDigest kasutaja parooli räsinud, edastame selle autentimiseks, et ta saaks parooli kontrollida. Kui kasutaja valvurit ei möödu, suuname ta uuesti sisselogimisvaatesse. Vastasel juhul autentime (see on osa, mille kaudu me kasutame kasutajat seansi juurde), kasutaja seansi juurde ja suuname siis veel eksisteerimata marsruudile / profiilile.

Loome profiili, millele pääseb juurde ainult sisse loginud kasutaja!

8. Loo vaade: profiil

Esmalt looge uus fail jaotises Resources / Views / ja nimetage see profiil.leaf:



  
     veebi autentimine 
    
  
  
    
    
      
        
          
            

profiil

            

E-post: # (kasutaja.email)

          
        
      
    
  

9. Reguleerige UserController: lisage profiil-marsruut

Profiilvaate muudame juurdepääsetavaks ainult autenditud kasutajatele. Selle jaoks lisage meie marsruutides.swift järgmised andmed:

import aur
impordi autentimine
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
  router.post ("register", kasutage: userController.register)
  router.get ("sisselogimine", kasutage: userController.renderLogin)
  lase authSessionRouter = ruuter.grupitud (User.authSessionsMiddleware ())
  authSessionRouter.post ("login", kasutage: userController.login)
  lase protectedRouter = authSessionRouter.grouped (RedirectMiddleware  (tee: "/ login"))
  kaitstudoutout.get ("profiil", kasutage: userController.renderProfile)
}

Jälle on meil vinge vahetarkvara, mis teeb autentimise meie heaks. RedirectMiddleware'i uurimisel öeldakse seal “Põhiline vahetarkvara autentimata taotluste suunamiseks tarnitud teele”. Noh, see on täpselt see, mida me tahame! Nii et kõik, mida ta peab teadma, on klass, mida me tahame, et ta kontrolliks autentimist ja läbiks ka marsruudi, et suunata see uuesti autendimata.

Kõik selle ruuteriga loodud marsruudid on nüüd turvalised ja neile pääsevad ligi ainult varem sisse loginud kasutajad. Lõpetagem profiilivaade ja saime sisse meie Controllers / UserController.swift ja lisage:

import aur
impordi FluentSQL
impordi krüpto
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    ...
  }
  func register (_ req: Request) viskab -> Future  {
    ...
  }
  func renderLogin (_ req: Request) viskab -> Future  {
    ...
  }
  func login (_ req: Request) viskab -> Future  {
    ...
  }
  func renderProfile (_ req: Request) viskab -> Future  {
    lase kasutajal = proovida req.requireAuthenticated (Kasutaja ise)
    tagasi proovida req.view (). render ("profiil", ["kasutaja": kasutaja])
  }
}

Mis siis, kui ma ütlen teile, et kui lähete cmd + r-ga oma projekti nüüd käivitama ja proovite juurde pääseda / profiili pääseda, suunatakse teid sisselogimisvaatesse? Ja et kui lähete ja registreerite end ning logite siis sisse, et teid suunatakse ümber / profiili ja siis pääseb sellele turvatud vaatele juurde? Jah, see on meeletult lihtne!

10. Reguleerige UserController: lisage väljalogimise marsruut

Kas olete kahe vooderdise jaoks valmis? Kontrollerites / UserController.swift lisage:

import aur
impordi FluentSQL
impordi krüpto
lõpuklassi kasutajakontroller {
  func renderRegister (_ req: Request) viskab -> Future  {
    ...
  }
  func register (_ req: Request) viskab -> Future  {
    ...
  }
  func renderLogin (_ req: Request) viskab -> Future  {
    ...
  }
  func login (_ req: Request) viskab -> Future  {
    ...
  }
  func renderProfile (_ req: Request) viskab -> Future  {
    ...
  }
  func logout (_ req: Request) viskab -> Future  {
    proovige req.unauthenticateSession (kasutaja ise)
    return Future.map (sees: req) {return req.redirect (aadressile: "/ login")}
  }
}

Järgmisena minge marsruutidele.swift ja lisage:

import aur
impordi autentimine
avalikud funktsionaalsed marsruudid (_ ruuter: ruuter) viskab {
  lase userController = UserController ()
  router.get ("register", kasutage: userController.renderRegister)
  router.post ("register", kasutage: userController.register)
  router.get ("sisselogimine", kasutage: userController.renderLogin)
  lase authSessionRouter = ruuter.grupitud (User.authSessionsMiddleware ())
  authSessionRouter.post ("login", kasutage: userController.login)
  lase protectedRouter = authSessionRouter.grouped (RedirectMiddleware  (tee: "/ login"))
  kaitstudoutout.get ("profiil", kasutage: userController.renderProfile)
  router.get ("logout", kasutage: userController.logout)
}

Ja lõpuks lisage nupp meie ressurssidele / vaadetele / profiili.lehele, mis selle käivitab:



  
     veebi autentimine 
    
  
  
    
    
      
        
          
            

profiil

            

E-post: # (kasutaja.email)

                           Logi välja                        
        
      
    
  

Meie viimane cmd + r või käivitage ja värskendage oma saiti ja see on! Võite proovida sellele juurde pääseda / seda profiiliga töötada, kuid kui registreerite end ja logite sisse, saate sellele juurde pääseda ja sealt uuesti välja logida!

See selleks! Veebi autentimine õnnestus seansi abil

11. Kuhu siit edasi minna

Kõigi Githubi näidisprojektide õpetuste loendi leiate siit:
https://github.com/vaporberlin/vaporschool

Mul on tõesti hea meel, et lugesite minu artiklit! Kui teil on mingeid ettepanekuid või parandusi, andke mulle sellest teada! Mulle meeldiks teid kuulda!

Twitter / Github / Instagram

Vaata ka

Kuidas muuta oma sisuturundus tõhusaks digitaalstrateegiaks4 ootamatut stressijat, mis võivad teid aeglaselt tappa (ja kuidas neid parandada)Kuidas suurendada nii teie veebisaidi juurdepääsetavust + SEOKuidas olla kasside toidublogijaNegatiivse mõtteviisi parandamine