Documentation versions

Re-use: Allowing users to log in to your system

In the previous section, a web application was built into which users can log in using a password. As part of this, some model code needed to be written – to model such Users and their login credentials.

If you are sick of having to re-write this functionality for each new web application, you can opt to use such functionality that is implemented by Reahl itself. You have options too: you can choose to only use the model behind the scenes and write your own user interface, or use both the model and user interface shipped by Reahl.

Re-using a domain model

To re-use a domain model is really easy. It basically just means re-using a library of code shipped by someone. Reahl distributes such code in components that are packaged as Python Eggs. The code to allow users to log into a system is shipped in the reahl-domain component, in the module reahl.systemaccountmodel.

In there is a class, AccountManagementInterface which is session-scoped. In other words to get an AccountManagementInterface, you just call AccountManagementInterface.for_current_session(). The LoginSession class is also in this module. It is session-scoped and serves the same purpose as the LoginSession of the previous example.

An AccountManagementInterface has many Fields and Events available for use by user interface code. It allows for logging in and out, but also for registration, verification of the email addresses of new registrations, resetting forgotten passwords, etc.

The LoginSession object itself is mostly only used for finding out who is currently logged in.

Here is our simple login application, changed to use this code, instead of its own little model:




from __future__ import print_function, unicode_literals, absolute_import, division
from reahl.web.fw import UserInterface
from reahl.web.ui import HTML5Page, Form, TextInput, LabelledBlockInput, Button, Div, P, H, InputGroup, Menu, HorizontalLayout,\
                         PasswordInput, ErrorFeedbackMessage
from reahl.web.layout import PageLayout
from reahl.web.pure import ColumnLayout, UnitSize
from reahl.domain.systemaccountmodel import AccountManagementInterface, LoginSession



class MenuPage(HTML5Page):
    def __init__(self, view, main_bookmarks):
        super(MenuPage, self).__init__(view, style='basic')
        self.use_layout(PageLayout())
        contents_layout = ColumnLayout(('main', UnitSize('1/3'))).with_slots()
        self.layout.contents.use_layout(contents_layout)
        self.layout.header.add_child(Menu(view).use_layout(HorizontalLayout()).with_bookmarks(main_bookmarks))


class LoginForm(Form):
    def __init__(self, view):
        super(LoginForm, self).__init__(view, 'login')
        
        accounts = AccountManagementInterface.for_current_session()

        if self.exception:
            self.add_child(ErrorFeedbackMessage(view, self.exception.as_user_message()))

        self.add_child(LabelledBlockInput(TextInput(self, accounts.fields.email)))
        self.add_child(LabelledBlockInput(PasswordInput(self, accounts.fields.password)))

        self.define_event_handler(accounts.events.login_event)
        self.add_child(Button(self, accounts.events.login_event))


class LoginUI(UserInterface):
    def assemble(self):
        login_session = LoginSession.for_current_session()
        if login_session.account:
            logged_in_as = login_session.account.email
        else:
            logged_in_as = 'Guest'

        home = self.define_view('/', title='Home')
        home.set_slot('main', P.factory(text='Welcome %s' % logged_in_as))

        login_page = self.define_view('/login', title='Log in')
        login_page.set_slot('main', LoginForm.factory())
        
        bookmarks = [i.as_bookmark(self) for i in [home, login_page]]
        self.define_page(MenuPage, bookmarks)



To be able to use the reahl-domain component in your code as shown above, you have to show that your component needs it. This is done by listing the reahl-domain component as a dependency in the .reahlproject file of your own component. Here reahl-domain is listed in the .reahlproject of this example:

<project type="egg">
  <deps purpose="run">
    <egg name="reahl-web"/>
    <egg name="reahl-component"/>
    <egg name="reahl-sqlalchemysupport"/>
    <egg name="reahl-web-declarative"/>
    <egg name="reahl-domain"/>
  </deps>

  <deps purpose="test">
    <egg name="reahl-tofu"/>
    <egg name="reahl-stubble"/>
    <egg name="reahl-dev"/>
    <egg name="reahl-webdev"/>
  </deps>

  <alias name="unit" command="setup -- -q nosetests -s --with-id --nologcapture --tests=login1_dev -t -i '.*'"/>
  <alias name="demosetup" command="setup -- -q nosetests -F reahl.webdev.fixtures:BrowserSetup --with-setup-fixture=reahl.doc.examples.tutorial.login1.login1_dev.login1tests:DemoFixture"/>

  
</project>

Remember, each time you change a .reahlproject file, you need to run reahl setup -- develop -N, as explained in A basic model.

Code is one thing, but re-using model code like this has other implications. What about the database? Certainly some tables need to be created in the database and maintained?

The underlying component framework will take care of creating the correct database schema for all components that are listed as dependencies in your .reahlproject. Once again, refer back to A basic model if you forgot how this works.

Exercising the application

Our example application would be difficult to fire up and play with, because it has no user interface for registering new user accounts!

The tests can come to the rescue here. You can of course play with the application indirectly by running (or even using pdb to step through) the tests themselves, but it is always nice to just play with an application to see what it does.

In order to do the latter, a special fixture can be created. The Reahl extensions to nosetests let you run (and commit) the setup of a particular fixture. This creates a database for you, populated with whatever was created during the set up of that Fixture. After doing this, you can serve the application using this database and play around.

DemoFixture in the example test is provided for this purpose. To use it, execute:

nosetests --with-run-fixture=reahl.webdev.fixtures:BrowserSetup --with-setup-fixture=reahl.doc.examples.tutorial.login1.login1_dev.login1tests:DemoFixture

Here is all the code of the test itself:


from __future__ import print_function, unicode_literals, absolute_import, division
from reahl.tofu import test, set_up

from reahl.sqlalchemysupport import Session
from reahl.web_dev.fixtures import WebFixture
from reahl.webdev.tools import Browser, XPath

from reahl.doc.examples.tutorial.login1.login1 import LoginUI
from reahl.domain.systemaccountmodel import EmailAndPasswordSystemAccount


class LoginFixture(WebFixture):
    def new_browser(self):
        return Browser(self.new_wsgi_app(site_root=LoginUI))
        
    password = 'topsecret'

    def new_account(self):
        account = EmailAndPasswordSystemAccount(email='[email protected]')
        Session.add(account)
        account.set_new_password(account.email, self.password)
        account.activate()
        return account


class DemoFixture(LoginFixture):
    commit=True
    @set_up
    def do_demo_setup(self):
        self.account
        Session.commit()


@test(LoginFixture)
def logging_in(fixture):
    """A user can log in by going to the Log in page.
       The name of the currently logged in user is displayed on the home page."""

    browser = fixture.browser
    account = fixture.account

    browser.open('/')
    browser.click(XPath.link_with_text('Log in'))

    browser.type(XPath.input_labelled('Email'), '[email protected]')
    browser.type(XPath.input_labelled('Password'), 'topsecret')
    browser.click(XPath.button_labelled('Log in'))

    browser.click(XPath.link_with_text('Home'))
    assert browser.is_element_present(XPath.paragraph_containing('Welcome [email protected]'))
        

@test(LoginFixture)
def domain_exception(fixture):
    """Typing the wrong password results in an error message being shown to the user."""

    browser = fixture.browser
    account = fixture.account

    browser.open('/')
    browser.click(XPath.link_with_text('Log in'))

    browser.type(XPath.input_labelled('Email'), '[email protected]')
    browser.type(XPath.input_labelled('Password'), 'wrong password')
    browser.click(XPath.button_labelled('Log in'))

    assert browser.is_element_present(XPath.paragraph_containing('Invalid login credentials'))

Re-using the user interface as well

If you’re really lazy, you can write even less code. You can re-use the UserInterface shipped with Reahl that contains Views for logging in and other related account management.

Re-using bits of web-based user interface traditionally has been quite difficult. In part this is because each web application has a distinct look and layout. How does one re-use a complete bit of “page flow” in different web applications, each application with its own look and layout?

The concepts of a UserInterface, of a page and Slots exist to make such re-use possible. The basics of these concepts is explained in Make light work of similar-looking pages, but there’s more to it than is explained there. In examples thus far, each web application consisted of a few related Views packaged as a single UserInterface. It is possible, however, to compose your web application from multiple UserInterfaces. Hence, you can use a UserInterface that someone else has built beforehand.

In the reahl-domainui component, in the reahl.domainui.accounts module, lives a UserInterface called AccountUI. It contains Views for logging in, registering a new account, and more. In order to use it, you will need to give it its own URL in your web application – just like you’d define a View on a particular URL. The URLs of the Views of the AccountUI will then be appended to the URL you use for the UserInterface itself.

The page of your web application defines a number of Slots. The writer of AccountUI (or any other UserInterface) does not know what Slots your application will have for plugging in its bits of user interface. Hence, each UserInterface writer chooses a couple of names for Slots needed for its Views . When you use such a UserInterface, you need to specify which of the UserInterface‘s Slots plug into which of your own application’s Slots.

A UserInterface and its Slot names are analogous to a method and its arguments: the method signature contains variable names chosen by the programmer who wrote it. You can call that method from many different places, passing in different values for those arguments. Specifying the Slots when re-using a UserInterface is similar.

In this example, we used a PageLayout with a ColumnLayout to add a Slot named main to our MenuPage. The AccountUI in turn has a Slot named main_slot. Hence, it is necessary to state that main_slot of AccountUI plugs into main of our MenuPage.

AccountUI also has its own requirements: it needs a number of bookmarks. Specifically, it expects to be passed an object from which it can get a bookmark for: a page listing the terms of service of the site, the privacy policy of the site, and a disclaimer.

The code below is our entire little application, rewritten to use the AccountUI. (Note that since our application does not have Views for all the legal bookmarks linked to by the AccountUI, the home page of the application has been used for each legal bookmark in this example.)

Just to show a few more bits of the AccountUI, the example has been modified to include some more items in its Menu:




from __future__ import print_function, unicode_literals, absolute_import, division
from reahl.web.fw import UserInterface
from reahl.web.ui import HTML5Page, P, Menu, HorizontalLayout
from reahl.web.layout import PageLayout
from reahl.web.pure import ColumnLayout, UnitSize
from reahl.domain.systemaccountmodel import LoginSession
from reahl.domainui.accounts import AccountUI



class MenuPage(HTML5Page):
    def __init__(self, view, main_bookmarks):
        super(MenuPage, self).__init__(view, style='basic')
        self.use_layout(PageLayout())
        contents_layout = ColumnLayout(('main', UnitSize('1/3'))).with_slots()
        self.layout.contents.use_layout(contents_layout)
        self.layout.header.add_child(Menu(view).use_layout(HorizontalLayout()).with_bookmarks(main_bookmarks))


class LegalNotice(P):
    def __init__(self, view, text, name):
        super(LegalNotice, self).__init__(view, text=text, css_id=name)
        self.set_as_security_sensitive()


class LoginUI(UserInterface):
    def assemble(self):
        login_session = LoginSession.for_current_session()
        if login_session.account:
            logged_in_as = login_session.account.email
        else:
            logged_in_as = 'Guest'

        home = self.define_view('/', title='Home')
        home.set_slot('main', P.factory(text='Welcome %s' % logged_in_as))

        terms_of_service = self.define_view('/terms_of_service', title='Terms of service')
        terms_of_service.set_slot('main', LegalNotice.factory('The terms of services defined as ...', 'terms'))

        privacy_policy = self.define_view('/privacy_policy', title='Privacy policy')
        privacy_policy.set_slot('main', LegalNotice.factory('You have the right to remain silent ...', 'privacypolicy'))

        disclaimer = self.define_view('/disclaimer', title='Disclaimer')
        disclaimer.set_slot('main', LegalNotice.factory('Disclaim ourselves from negligence ...', 'disclaimer'))

        class LegalBookmarks(object):
            terms_bookmark = terms_of_service.as_bookmark(self)
            privacy_bookmark = privacy_policy.as_bookmark(self)
            disclaimer_bookmark = disclaimer.as_bookmark(self)

        accounts = self.define_user_interface('/accounts', AccountUI,
                                      {'main_slot': 'main'},
                                      name='accounts', bookmarks=LegalBookmarks)

        account_bookmarks = [accounts.get_bookmark(relative_path=relative_path) 
                             for relative_path in ['/login', '/register']]
        bookmarks = [home.as_bookmark(self)]+account_bookmarks
        self.define_page(MenuPage, bookmarks)



Exercising the lazier application

Warning

You have to start our test email server before running this app.

This application may try to send out email – when you register, for example. And since you do not have an email server running on your development machine that will probably break. To solve this, run the following (in a different terminal):

reahl servesmtp

This command runs a simple email server which just shows every email it receives in the terminal where it is running.

Of course, some tests are included for our lazy application. The tests once again include a Fixture for setting up the application database as before:

nosetests --with-run-fixture=reahl.webdev.fixtures:BrowserSetup --with-setup-fixture=reahl.doc.example.tutorial.login2.login2_dev.login2tests:DemoFixture

Finally, and for completeness, here is the test code:


from __future__ import print_function, unicode_literals, absolute_import, division
from reahl.tofu import test, set_up

from reahl.web_dev.fixtures import WebFixture
from reahl.webdev.tools import Browser, XPath

from reahl.sqlalchemysupport import Session
from reahl.domain.systemaccountmodel import EmailAndPasswordSystemAccount

from reahl.doc.examples.tutorial.login2.login2 import LoginUI


class LoginFixture(WebFixture):
    def new_browser(self):
        return Browser(self.new_wsgi_app(site_root=LoginUI))
        
    password = 'topsecret'

    def new_account(self):
        account = EmailAndPasswordSystemAccount(email='[email protected]')
        Session.add(account)
        account.set_new_password(account.email, self.password)
        account.activate()
        return account


class DemoFixture(LoginFixture):
    commit=True
    @set_up
    def do_demo_setup(self):
        self.account
        Session.commit()


@test(LoginFixture)
def logging_in(fixture):
    """A user can log in by going to the Log in page.
       The name of the currently logged in user is displayed on the home page."""

    browser = fixture.browser
    account = fixture.account

    browser.open('/')
    browser.click(XPath.link_with_text('Log in with email and password'))

    browser.type(XPath.input_labelled('Email'), '[email protected]')
    browser.type(XPath.input_labelled('Password'), 'topsecret')
    browser.click(XPath.button_labelled('Log in'))

    browser.click(XPath.link_with_text('Home'))
    assert browser.is_element_present(XPath.paragraph_containing('Welcome [email protected]'))

        

Documentation versions