The main functionality of our test case website that we are working on from part 1 of Mojolicious series is for registered users to be able to publish their testimonials in the website. To achieve that, we need to follow the below steps:

• Create Database Components
• Create Testimonials Page Template
• Database Connectivity Logic
• Verification
• Deploy to Production

Create Database Components

The testimonials entered by the users needs to be stored in the database so that all the testimonials entered by all the users is visible to everyone. We will use MariaDB database to store our testimonial table. First, we will create a MariaDB database called tct_mojo_db by logging in as root user:

mysql -u root -p

CREATE database tct_mojo_db;

Then we will create a database user called demo and give it all the privileges to the database tct_mojo_db

CREATE USER 'demo'@'localhost' IDENTIFIED BY 'welcome123';

GRANT ALL PRIVILEGES ON tct_mojo_db.* TO 'demo'@'localhost';

Finally we login as the new user(demo) and create the table tct_mojo_testimonials in our new database tct_mojo_db

mysql -u demo -p

use tct_mojo_db;

CREATE TABLE IF NOT EXISTS tct_mojo_testimonials (
id             INT(20)         NOT NULL AUTO_INCREMENT,
published_by   VARCHAR(560)    NOT NULL,
published_on   TIMESTAMP       NOT NULL DEFAULT CURRENT_TIMESTAMP,
testimonial    VARCHAR(32000)  NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB;

We will store the testimonials published by the users in the above database table. We have all the database related components in place for your project.

Create Testimonials Page Template

We need a new page template where users can publish their testimonials and view the testimonials of others. We will have a single page which does both. The first section of the page will be a html form which registered users can use to provide their testimonials and we will have a section below which will have all the testimonials given by everyone.

Let us go ahead and create a new template called: managetestimonials.html.ep in our templates folder: myWebSite/templates/myTemplates/ with the below content:

% layout 'master';
% title 'View Testimonials';
<a href="/">Home</a>&nbsp;&nbsp;
<a href="/logout">Log Out</a>

<h1><%= $msg %></h1>

<center>
<form action="/testimonials" method="post">

    <textarea id="userReview" name="userReview" rows="8" cols="50">Please enter your testimonial here</textarea></br>
    <input type="reset" value="Clear" />
    <input type="submit" value="Publish">

</form>
</center>

<table width=100% align=center border=1 cellspacing=0 cellpadding=0>
  <tr>
    <th>Testimonials</th>
  </tr>

  <%== $alltestimonials %>

</table>
</body>
</html>

We are referring to a perl variable $alltestimonials in the template code, this will have the existing testimonials from database in HTML format. We will set this value in our controller after getting them from database.

Database Connectivity Logic

Now that we have the new page template ready, time for us to add the logic to handle database operations. In order to achieve that we need to make the following changes to our project:

• Update DB credentials in myWebSite.conf file
• Add DB handler and logic to handle new route
• Create DB Modeller for database operations
• Change Controller logic to handle DB operations

myWebSite.conf

We need to update our conf file to include database credentials. We will add the database connectivity in the below format:

mysql => 'mysql://dbusername:dbpassword@localhost/databasename'

So our updated myWebSite.conf file will look like this:

{
  secrets => ['8c285c2b2f9ce11c46ee322d52179ac32be6d42a'],
  mysql => 'mysql://demo:welcome123@localhost/tct_mojo_db'
}

DB Handler

We have DB connections in place. Now let us create a helper in our main library(myWebSite.pm) which will be used as a handle to our database. This can be used my our modeller and controller to access the database.

Database helpers can be created using the below statement:

# Invoking Database handle 
$self->helper(mysql => 
sub { state $mysql = Mojo::mysql->new(shift->config('mysql')) });

$self->helper(dbhandle => 
sub { state $vikidb = myWebSite::Model::Database->new(mysql => shift->mysql) });

We will also add the below routes to handle the new testimonial page action using :

$authorized->get('/testimonials')->to('CustomController#loadTestimonials');
$authorized->post('/testimonials')->to('CustomController#saveTestimonial');

If you remember from our previous session, the $authorized handle helps us in making sure that only logged in users can access the above calls since these statements are called after the under statement.

Do not forget to import the module use Mojo::mysql; in your main library. If Mojo::mysql is not installed, go ahead and install the perl module.

We will also import our database modeller in our main library: use myWebSite::Model::Database;. This does not exist yet, we will be creating this modeller in the next section.

Once all the change are done, your main library file myWebSite.pm should look something like this.

DB Modeller

Next we will be creating a database modeller which will have the logic to query the testimonial data and insert any newly published testimonial. We will create the modeller inside our lib directory using the command:

mkdir lib/myWebSite/Model

touch lib/myWebSite/Model/Database.pm

Let us now open the database modeller file and add the below content:

package myWebSite::Model::Database;
use Mojo::Base -base;

has 'mysql';

# Subroutine to get all the testimonials
sub fetch_all_testimonials{ shift->mysql->db->query('select * from tct_mojo_testimonials order by published_on desc')->hashes->to_array }

# Subroutine to insert the new testimonial to database
sub publish_testimonial{


   my ($self, $new_testimonial, $username) = @_;
   my $sql = 'insert into tct_mojo_testimonials(published_by,testimonial) values (?,?)';


   $self->mysql->db->query($sql, $username, $new_testimonial);

}


1;

We have 2 subroutine in our modeller, fetch_all_testimonials will fetch all the testimonials into an array of hashes and the second subroutine publish_testimonial inserts the newly published testimonials to the database. These are the only 2 database operation we require for your website.

Controller CustomController.pm Changes

We have our modeller in place that handles the DB operations, let us go ahead and add subroutines in our controller which calls these.

In the above section, we had added 2 new subroutine calls to our controller in the main library file: myWebSite.pm. Let us add the logic to those 2 subroutines in our existing controller: lib/myWebSite/Controller/CustomController.pm

loadTestimonials basically generates a HTML data of all the testimonials that are there in the database. The generated HTML data is passed as parameter to the template where it is rendered. It uses the fetch_all_testimonials subroutine from the DB modeller that we created above. In the section Create Testimonials Page Template above we had used the variable $alltestimonials to display the data, the value for it is being set in the below subroutine.

sub loadTestimonials{

    my $self = shift;
    my $all_testimonials_html;

    foreach my $all_testimonials (@{$self->dbhandle->fetch_all_testimonials})
    {
        $all_testimonials_html .= "
  <tr>
      <td>
          ".$all_testimonials->{testimonial}."</br></br>
          <div style='text-align: right;'><i>".$all_testimonials->{published_by}."</br>".$all_testimonials->{published_on}."</i></div>
     </td>
  </tr>";
    }
    $self->render(template => 'myTemplates/managetestimonials',msg => 'View Testimonials',alltestimonials => $all_testimonials_html);


}

saveTestimonial basically saves the newly created testimonial added by the registered users. It uses the publish_testimonial subroutine from the DB modeller that we created above.

sub saveTestimonial{

    my $self = shift;
    my $new_testimonial = $self->param('userReview');
    my $user = $self->session('username');

    $self->dbhandle->publish_testimonial($new_testimonial,$user);
    &loadTestimonials($self);
}

Once all the above changes are done, our CustomController.pm controller will look like this.

Verification

That’s about it, we have everything we need to start our web application. Let us start our web application using morbo webserver:

I have SSH Tunnel enabled, so let me access our website using localhost IP and port 3000.

Once we login and navigate to Testimonials page, it should look like this:

If we add any new testimonial, we can see it getting added in the table below:

We have successfully handled database connection in our website.

Deploy to Production

Now that we have a fully operational website with all the requirements met and tested, we can deploy our changes in production and start it to be available for everyone. To do that, as explained in the Mojolicious Introduction article, we will use the production webserver hypnotoad.

1. Let’s tell hypnotoad to run on port 80. To do that, we will update the myWebSite/myWebSite.conf file to look like this:

{
     secrets => ['8c285c2b2f9ce11c46ee322d52179ac32be6d42a'],
     mysql => 'mysql://demo:welcome123@localhost/tct_mojo_db',
     hypnotoad => {
          listen => ['http://*:80'],
          workers => 10
     }
}

We have also told hypnotoad to run 10 workers.

2. Next we will open firewall ports 80 so that the website is accessible to everyone. I run Mojolicious on Fedora and use firewalld, I will run the below command to open the ports:

firewall-cmd --zone=public --permanent --add-port 80/tcp
firewall-cmd --reload

3. Start the web application using hypnotoad by using the command:

hypnotoad myWebSite/script/myWebSite

4. Finally verify by accessing the website using your server IP (or domain name if you have one mapped):

Note: I recommend to use Apache Reverse Proxy along with hypnotoad for production deployments.

With that the Mojolicious tutorial comes to an end. We have successfully created a fully operational website covering major features of any website and made it available to general public. Hope the Mojolicious tutorial series were informative and helpful. Do let me know your thoughts and comments in the comment section below. You can find the entire source code of the testimonials project here. You can watch the entire Mojolicious series that we discussed in this blog series in my youtube channel. Keep visiting this blog for more technical tutorials.

Edits:

[13-May-2021] It so happened that I missed to mention about changing the homepage.html.ep file to point to the new testimonial route(/testimonials) that we created in the main library(myWebSite.pm). You just need to change the href tag in the homepage template to point to the new route and you should be good to go.

% layout 'master';
% title 'Home Page';
    <a href="/logout">Log Out</a>
      <h1><%= $msg %></h1>
      <h5 class="w3-padding-32">This is my personal site built with Mojolicious. You can provide testimonials using the link <a href="/testimonials">here</a>. 
</h5>

Thanks to Jim for pointing this out.

The post Mojolicious (Part 4): Database Management appeared first on The Curious Technoid.

• Create Login and Logout Pages
• Authentication and Session Management Logic
• Verification

Before we proceed further, let us all remind ourselves how our Mojolicious website looks as of now:

and this is our project file structure:

Create Login and Logout Pages

Instead of the home page, we will redirect the users to the login page whenever they access our website. If they provide the correct username / password, we will create session cookies and re-direct them to the home page. Once they are done browsing our website, they can click the Logout link (which we will add to our homepage). This will remove the session cookies and safely logout.

We have already created a master layout in our previous session which is the skeleton of our website. This makes us not worry about the look and feel of the website as it is already taken care of. We just need to create template files for login and logout pages which will call our already created master layout.

Login Page

Let us create a new template called login.html.ep inside the template folder of our project: myWebSite/templates/myTemplates. We will add the below code to it:

% layout 'master';
% title 'Login Page';

<center>
<h1>Please Login to Access the Website</h1>

<h6>
<!-- Logic to display errors if any -->
<font color=red>
<% if($error_message){ %>
<%= $error_message %>
<% } %>
</font>
</h6>

<form action="/login" method="post">

    <b>UserName</b> <input type="text" name="username" required></br>
    <b>Password</b> <input type="password" name="pass" required></br>

    <input type="submit" value="Submit">
    <input type="reset" value="Reset" />

</form>
</center>

The variable $error_message is used to display any error encountered while validating the user credentials.

We are using the master layout that we created in the previous session. We changed the title helper to say it’s a Login Page. Then we created a very simple login form which on submit is routed to /login action.

Logout Page

We will now create a logout page template with the name logout.html.ep in our template folder: myWebSite/templates/myTemplates with the below content:

% layout 'master';
% title 'Logout Page';

<center>
<h6>You have successfully logged out of the website. Thank you for visiting. If you want to login again, please <a href="/">click here</a></h6>
</center>

Modify Home Page

Let’s also add a logout link to our homepage template that we created in the previous article.

% layout 'master';
% title 'Home Page';
      <a href="/logout">Log Out</a>
      <h1><%= $msg %></h1>
      <h5 class="w3-padding-32">This is my personal site built with Mojolicious. You can provide testimonials using the link <a href="#">here</a>. 
</h5>

Authentication and Session Management

Our login and logout pages are ready, now time to add logic to authenticate the registered users using session cookies. We will create the below 3 subroutines in our controller (CustomController.pm*):

• displayLogin
• validUserCheck
• alreadyLoggedIn
• logout

*myWebSite/lib/myWebSite/Controller/CustomController.pm

displayLogin

This subroutine will display the login page template that we created in the previous section of this article. In case the user is already logged in, they will be redirected to the home page.

sub displayLogin {

    my $self = shift;

    # If already logged in then direct to home page, if not display login page
    if(&alreadyLoggedIn($self)){
    # If you are using Mojolicious v9.25 and above use this if statement as re-rendering is forbidden
    # Thank you @Paul and @Peter for pointing this out.
    # if($self->session('is_auth')){

            &welcome($self);

    }else{

       $self->render(template => "myTemplates/login", error_message =>  "");

    }

}

validUserCheck

This subroutine will check the details entered by the user in the login page and authenticates the user to access the website. This also creates session cookies to keep the user’s session active. The users are prompted with proper error messages when incorrect credentials are passed. We set the variable error_message here which gets displayed in our login.html.ep template.

sub validUserCheck {

    my $self = shift;

    # List of registered users
    my %validUsers = ( "JANE" => "welcome123"
                      ,"JILL" => "welcome234"
                      ,"TOM"  => "welcome345"
                      ,"RAJ"  => "test123"
                      ,"RAM"  => "digitalocean123"
                     );

    # Get the user name and password from the page
    my $user = uc $self->param('username');
    my $password = $self->param('pass');

    # First check if the user exists
    if($validUsers{$user}){

        # Validating the password of the registered user
        if($validUsers{$user} eq $password){

            # Creating session cookies
            $self->session(is_auth => 1);             # set the logged_in flag
            $self->session(username => $user);        # keep a copy of the username
            $self->session(expiration => 600);        # expire this session in 10 minutes if no activity


            # Re-direct to home page
            &welcome($self);

        }else{

            # If password is incorrect, re-direct to login page and then display appropriate message
            $self->render(template => "myTemplates/login", error_message =>  "Invalid password, please try again");
        }

    }else{

        # If user does not exist, re-direct to login page and then display appropriate message
        $self->render(template => "myTemplates/login", error_message =>  "You are not a registered user, please get the hell out of here!");

    }

}

alreadyLoggedIn

This subroutine checks session cookies to see if the user has already logged in, if yes then the user will be automatically allowed to access the pages in the website

sub alreadyLoggedIn {

      my $self = shift;

      # checks if session flag (is_auth) is already set
      return 1 if $self->session('is_auth');


      # If session flag not set re-direct to login page again.
      $self->render(template => "myTemplates/login", error_message =>  "You are not logged in, please login to access this website");

      return;

}

logout

We need to destroy all the session cookies that were created when the user logged in, forcing any visitor to the website to enter the credentials again. logout subroutine does that.

sub logout {

    my $self = shift;

    # Remove session and direct to logout page
    $self->session(expires => 1);  #Kill the Session
    $self->render(template => "myTemplates/logout");

}

After all these changes your controller should look like this.

Now we need to tell Mojolicious to call these subroutine whenever there is any action on the page. What handles the action on the page? If you have gone through the previous articles, you know it’s the main library file: myWebSite/lib/myWebSite.pm. Right now we only have 1 routes in our main library file which looks like this:

# Normal route to controller
$r->get('/')->to('CustomController#welcome');

Lets add the routes to send requests to all the subroutines we created in the previous section

# Normal route to controller
$r->get('/')->to('CustomController#displayLogin');
$r->post('/login')->to('CustomController#validUserCheck');
$r->any('/logout')->to('CustomController#logout');

my $authorized = $r->under('/')->to('CustomController#alreadyLoggedIn');

Our main library file should finally look like this.

Let us just try to understand quickly what all we are trying to do:

$r->get('/')->to('CustomController#login'); Whenever anyone accesses our root path of the website redirect them to login subroutine(which renders login page), instead of the home page which was the case before.

$r->post('/login')->to('CustomController#validUserCheck'); When the credentials are entered and submitted in the login page we will route the request to validUserCheck subroutine which basically validates the user, creates session cookies and redirects the user to website home page.

$r->any('/logout')->to('CustomController#logout'); Whenever Log Out link is clicked, it directs the request to logout subroutine which destroys the session cookies.

my $authorized = $r->under('/')->to('CustomController#alreadyLoggedIn'); This is a special condition. The “under” call ensures nothing after this statement gets executed, if the subroutine in “under” call fails(in our case the subroutine is alreadyLoggedIn). This is especially useful when we have multiple webpages and you want only authorized users has access to it. We will see this is our next session when we build our testimonials page.

Verification

I guess we have done everything that is required to enable authentication to our website. Let us not waste any more time and start our web application with morbo:

When we access our website now, we are greeted with the login page instead of the home page:

If you give incorrect credentials, you will get not be allowed to login and will get the below messages:

Valid users will be logged into the website and they can access the home page. They will also see a logout link in their home page.

With that we have secured our website. This completes the session management and user authentication part of Mojolicious tutorial. Ofcourse in the real world, you would validate the user credentials from your database with encrypted passwords. For the purpose of this demo, I have kept it simple. In the next session, we will cover database management in Mojolicious. You can watch the demo of this article in my youtube channel below.

The post Mojolicious (Part 3): Session Management appeared first on The Curious Technoid.

Layouts are reusable skeleton of your website. This generally would have your header, logo, footer, menus, side bar etc
Templates are the dynamic content that you want to display based on different actions on the web portal. This is generally the content that needs to be inside the layout.

Download Template

To put it into action, let’s download a free HTML template from the internet. I downloaded one from w3 schools.

It looks like this:

You can get the source code here.

Create a Layout

Let us make this HTML template as a layout in Mojolicious, so that we can use it across our pages. To do so, lets follow the below steps:

We will finally have the layout file, master.html.ep which looks like this. You can check comments by The Curious Technoid to know the changes I did to the original file.

This will be our layout which is our website skeleton and will be used across our website. We will only change the content and title dynamically using Mojolicious templates.

Create Templates

Now that we have our website layout in place, we will create templates from where these layouts gets called from. If you have gone through the previous article, you have already created a new template called: myWebSite/templates/myTemplates/homepage.html.ep which looks like this:

% layout 'default';
% title 'Home Page';
<h2><%= $msg %></h2>
<p> This is my personal site built with Mojolicious. You can provide testimonials using the link <a href="#">here</a>. 
</p>

Lets change it to call our newly created layout master.html.ep. We also add our “content” using the same HTML tag and CSS Class which was their in the original HTML source:

% layout 'master';
% title 'Home Page';
<h1><%= $msg %></h1>
<h5 class="w3-padding-32"> This is my personal site built with Mojolicious. You can provide testimonials using the link <a href="#">here</a>. 
</h5>

% layout 'master'; tells Mojolicious which layout to use
% title 'Home Page'; – the title helper which gets replaced in layout
Any HTML data you enter in the template will be displayed in the <%= content %> section of the layout.

Verify Changes

Now that we have our templates and layouts in place. Lets start our web application using morbo:

morbo myWebSite/script/myWebSite

Since we have SSH Tunnel enabled as usual, we will check our website using local host and port 3000:

Our website doesn’t look that bad now, does it.

In the next article, we will make our website accessible by only registered users using sessions and cookies.

The post Mojolicious (Part 2): Layouts and Templates appeared first on The Curious Technoid.

Test Case Synopsis

The test case that we have is to build a web application for testimonials. That’s the easiest one that I could think of to cover the topics I want to discuss. The web application will have the following features:

• Login Page: Which restricts website access to registered users
• Home Page: Main page for the registered users with a welcome message and website instructions
• Testimonial Page: Testimonial Page which displays all the testimonials from database entered by the users and option to save new testimonials in the database
• Log Out: To gracefully logout of the website

We will also add a simple HTML template to the website which would cover the templates and layouts concept in Mojolicious.

Without further adieu, let’s begin building this project.

Create full_app project

In our previous tutorial on Mojolicious, we created “Hello World” web app with lite_app. This time we will build this project with full_app. To create a full_app, open the terminal and enter the below command:

mojo generate app myWebSite

This will create a directory called myWebSite with the below folder structure:

Lets understand the below components from the above screenshot

• lib
• myWebSite.conf
• public
• script
• t
• templates

lib

The library directory is probably the most crucial directory which holds all your programming code. Your Controller and Model logic goes here. The logic to handle any action on your webpage will be somewhere in this directory.

Your routes and page-actions are sent to the file myWebSite/lib/myWebSite.pm which then invokes the relevant Controller and Model to handle your requests.

myWebSite.conf

This is the master configuration file for your web app. You can add secret phrases for signed cookies, mention the number of workers that you want webservers to run, the port that your application should run on, database connection details, so on and so forth.

public

You can find all your static pages here. Along with the static pages, all publicly available components like your css, images or any other media goes into this directory.

script

Script to start your web site is present in this directory. You run you web app using the script/myWebSite file present in this directory.

t

Folder dedicated for your test scripts.

templates

Directory which holds the templates and layouts used by your web app.

I will not go in detail about the theory as you can always read more about it in the official website of Mojolicious. Let us proceed with our project.

Let’s go ahead and run this sample web app as it is, using the development web server morbo:

morbo myWebSite/script/myWebSite

Since we don’t see any errors, let’s fire up the browser and check our page (I have SSH Tunnel enabled, so I can access the webpage with localhost IP and default port(3000):

Our Website is running fine.

How did our website’s content get rendered ? Let us understand the flow of events. First, let me just remind you how the structure of your web application looks like:

Below diagram shows the flow of events from different files when you access your web page:

Whenever you access any web page built in mojolicious, the first file that gets called is the library file: lib/myWebSite.pm. The line $r->get('/')->to('example#welcome'); in the file basically tells to go to the controller Example.pm and execute the welcome sub-routine. Controllers, as you can see in the above screenshot are stored in lib/myWebSite/Controller.

In the controller we see the below lines:

# Render template "example/welcome.html.ep" with message
$self->render(msg => 'Welcome to the Mojolicious real-time web framework!');

This basically tells Mojolicious to set a value to the variable $msg and render the template. But which template ? We don’t see any template name mentioned in the controller, then which page is getting rendered?? Well, since no template is explicitly called Mojolicious will look for the template is the path similar to the controller path: example/welcome. In the above directory structure, we can see a template: template/example/welcome.html.ep, that’s what is getting rendered in the home page now. Ofcourse, you can explicitly mention the template name in the controller and it will exactly behave the same way. Just pass the template name like this:

  $self->render(msg => 'Welcome to the Mojolicious real-time web framework!',template => "example/welcome");

I prefer explicitly mentioning the template names in my controller, to avoid any confusion.

Now that we know that our main page’s content is being displayed by myWebSite/templates/example/welcome.html.ep and the contents looks like this:

% layout 'default';
% title 'Welcome';
<h2><%= $msg %></h2>
<p>
  This page was generated from the template "templates/example/welcome.html.ep"
  and the layout "templates/layouts/default.html.ep",
  <%= link_to 'click here' => url_for %> to reload the page or
  <%= link_to 'here' => '/index.html' %> to move forward to a static page.
</p>

We will change it to add our content:

% layout 'default';
% title 'Home Page';
<h2><%= $msg %></h2>
<p> This is my personal site built with Mojolicious. You can provide testimonials using the link <a href="#">here</a>. 
</p>

If you notice that the heading in the above html content is displayed by the variable $msg. This was set by our controller: myWebSite/lib/myWebSite/Controller/Example.pm. Let us open the controller file and change the below line:

# Render template "example/welcome.html.ep" with message
$self->render(msg => 'Welcome to the Mojolicious real-time web framework!');

to

# Render template "example/welcome.html.ep" with message
$self->render(msg => 'Welcome to My Personal Website!',template => "example/welcome");

Not only did I change the heading, I also explicitly mentioned which template to render.

Lets run our web app with morbo:

morbo myWebSite/script/myWebSite

Refresh our web browser:

Working as expected. Before we wind up, lets just change the default controller and template files to our customized file names:

cp myWebSite/lib/myWebSite/Controller/Example.pm myWebSite/lib/myWebSite/Controller/CustomController.pm

mkdir myWebSite/templates/myTemplates

cp myWebSite/templates/example/welcome.html.ep myWebSite/templates/myTemplates/homepage.html.ep

New Controller Name : myWebSite/lib/myWebSite/Controller/CustomController.pm
New Template Name : myWebSite/templates/myTemplates/homepage.html.ep

Open the new controller(CustomController.pm) and change the first line to reflect the new controller name, from:

package myWebSite::Controller::Example;

to

package myWebSite::Controller::CustomController;

Now change the below line in the same file to point to our newly created template: myTemplates/homepage

# Render template "example/welcome.html.ep" with message
$self->render(msg => 'Welcome to My Personal Website!',template => "example/welcome");

to

# Render template "myTemplates/homepage.html.ep" with message
$self->render(msg => 'Welcome to My Personal Website!',template => "myTemplates/homepage");

Finally, open the main library file: myWebSite/lib/myWebSite.pm and change the below line to call our now custom controller rather than the default:

$r->get('/')->to('example#welcome');

to

$r->get('/')->to('CustomController#welcome');

Lets start our web app and refresh the browser:

morbo myWebSite/script/myWebSite

You will not see any changes since we didn’t change the content. But we also didn’t see any errors that means we have achieved what we want.

We successfully created the home page of your website. In the next session, we will learn about templates and layouts. We will try to add some color to our dull home page that we created in this article.

The post Mojolicious (Part 1): Build Full App appeared first on The Curious Technoid.