Session Class Reference

#include <Session.h>

Public Member Functions
	Session ()
Wt::Auth::AbstractUserDatabase &	users ()
Wt::Auth::Login &	login ()
std::vector< User >	topUsers (int limit)
std::string	userName () const
int	findRanking ()
void	addToScore (int s)

Static Public Member Functions
static void	configureAuth ()
static const Wt::Auth::AuthService &	auth ()
static const Wt::Auth::AbstractPasswordService &	passwordAuth ()
static std::vector< const Wt::Auth::OAuthService * >	oAuth ()

Private Member Functions
Wt::Dbo::ptr< User >	user () const

Private Attributes
Wt::Dbo::Session	session_
std::unique_ptr< UserDatabase >	users_
Wt::Auth::Login	login_

Detailed Description

Definition at line 24 of file Session.h.

Constructor & Destructor Documentation

Session()

Session::Session

(

)

Definition at line 88 of file Session.C.

{
  auto sqlite3 = std::make_unique<Dbo::backend::Sqlite3>(WApplication::instance()->appRoot() + "hangman.db");
  sqlite3->setProperty("show-queries", "true");
  session_.setConnection(std::move(sqlite3));
 
  session_.mapClass<User>("user");
  session_.mapClass<AuthInfo>("auth_info");
  session_.mapClass<AuthInfo::AuthIdentityType>("auth_identity");
  session_.mapClass<AuthInfo::AuthTokenType>("auth_token");
 
  users_ = std::make_unique<UserDatabase>(session_);
 
  dbo::Transaction transaction(session_);
  try {
    session_.createTables();
 
    /*
     * Add a default guest/guest account
     */
    Auth::User guestUser = users_->registerNew();
    guestUser.addIdentity(Auth::Identity::LoginName, "guest");
    myPasswordService.updatePassword(guestUser, "guest");
 
    log("info") << "Database created";
  } catch (...) {
    log("info") << "Using existing database";
  }
 
  transaction.commit();
}

Member Function Documentation

addToScore()

void Session::addToScore

(

int

s

)

Definition at line 144 of file Session.C.

{
  dbo::Transaction transaction(session_);
 
  dbo::ptr<User> u = user();
  if (u) {
    u.modify()->score += s;
    ++u.modify()->gamesPlayed;
    u.modify()->lastGame = WDateTime::currentDateTime();
  }
 
  transaction.commit();
}

auth()

const Auth::AuthService & Session::auth ( )

static

Definition at line 201 of file Session.C.

{
  return myAuthService;
}

configureAuth()

void Session::configureAuth ( )

static

Definition at line 65 of file Session.C.

{
  myAuthService.setAuthTokensEnabled(true, "hangmancookie");
  myAuthService.setEmailVerificationEnabled(true);
 
  auto verifier = std::make_unique<Auth::PasswordVerifier>();
  verifier->addHashFunction(std::make_unique<Auth::BCryptHashFunction>(7));
 
#ifdef HAVE_CRYPT
  // We want to still support users registered in the pre - Wt::Auth
  // version of the hangman example
  verifier->addHashFunction(std::make_unique<UnixCryptHashFunction>());
#endif
 
  myPasswordService.setVerifier(std::move(verifier));
  myPasswordService.setStrengthValidator(std::make_unique<Auth::PasswordStrengthValidator>());
  myPasswordService.setAttemptThrottlingEnabled(true);
 
  if (Auth::GoogleService::configured()) {
    myOAuthServices.push_back(std::make_unique<Auth::GoogleService>(myAuthService));
  }
}

findRanking()

int Session::findRanking

(

)

Definition at line 180 of file Session.C.

{
  dbo::Transaction transaction(session_);
 
  dbo::ptr<User> u = user();
  int ranking = -1;
 
  if (u)
    ranking = session_.query<int>("select distinct count(score) from user")
      .where("score > ?").bind(u->score);
 
  transaction.commit();
 
  return ranking + 1;
}

login()

Wt::Auth::Login& Session::login ( )

inline

Definition at line 32 of file Session.h.

{ return login_; }

oAuth()

std::vector< const Auth::OAuthService * > Session::oAuth ( )

static

Definition at line 211 of file Session.C.

{
  std::vector<const Auth::OAuthService *> result;
  result.reserve(myOAuthServices.size());
  for (const auto& service : myOAuthServices) {
    result.push_back(service.get());
  }
  return result;
}

passwordAuth()

const Auth::AbstractPasswordService & Session::passwordAuth ( )

static

Definition at line 206 of file Session.C.

{
  return myPasswordService;
}

topUsers()

std::vector< User > Session::topUsers

(

int

limit

)

Definition at line 158 of file Session.C.

{
  dbo::Transaction transaction(session_);
 
  Users top = session_.find<User>().orderBy("score desc").limit(limit);
 
  std::vector<User> result;
  for (Users::const_iterator i = top.begin(); i != top.end(); ++i) {
    dbo::ptr<User> user = *i;
    result.push_back(*user);
 
    dbo::ptr<AuthInfo> auth = user->authInfo;
    std::string name = auth->identity(Auth::Identity::LoginName).toUTF8();
 
    result.back().name = name;
  }
 
  transaction.commit();
 
  return result;
}

user()

dbo::ptr< User > Session::user ( ) const

private

Definition at line 120 of file Session.C.

{
  if (login_.loggedIn()) {
    dbo::ptr<AuthInfo> authInfo = users_->find(login_.user());
    dbo::ptr<User> user = authInfo->user();
 
    if (!user) {
      user = session_.add(std::make_unique<User>());
      authInfo.modify()->setUser(user);
    }
 
    return user;
  } else
    return dbo::ptr<User>();
}

userName()

std::string Session::userName

(

)

const

Definition at line 136 of file Session.C.

{
  if (login_.loggedIn())
    return login_.user().identity(Auth::Identity::LoginName).toUTF8();
  else
    return std::string();
}

users()

Auth::AbstractUserDatabase & Session::users

(

)

Definition at line 196 of file Session.C.

{
  return *users_;
}

Member Data Documentation

login_

Wt::Auth::Login Session::login_

private

Definition at line 50 of file Session.h.

session_

Wt::Dbo::Session Session::session_

mutableprivate

Definition at line 48 of file Session.h.

users_

std::unique_ptr<UserDatabase> Session::users_

private

Definition at line 49 of file Session.h.

---

The documentation for this class was generated from the following files:

• hangman/Session.h
• hangman/Session.C