Forem: Junior Gantin

Sending automated emails with Masonite Framework

Junior Gantin — Fri, 02 Nov 2018 12:11:45 +0000

Imagine a scenario where you want to send a weekly email to your customers (maybe a newsletter 💌). So you need to send that email at a specific day and time.

This post will walk through creating and sending automated emails with Masonite Framework.

What you’ll need

To code along with this post, you’ll need:

Python (I’m using Python 3.6.5);
Pipenv: Python Development Workflow for Humans;
Masonite: The Modern And Developer Centric Python Web Framework
Mailtrap.io: Email testing for dev teams;

Setting up your application

First, create a new directory and a Python virtualenv:

$ mkdir masonite-weekly-email
$ cd masonite-weekly-email
$ pipenv install --three
$ pipenv shell

After that, you'll need to install masonite-cli package and crafting a new
Masonite application.

$ pipenv install masonite-cli
$ craft new masonite_weekly_email .
$ craft install

This will create a new Masonite application inside your current directory (the use of . at the end of craft new command).

Creating and sending an Email

Masonite comes with email support out of the box 🎉. So you can easily send an email like this:

Mail.to('hello@email.com').template('mail/welcome').send()

Task Scheduling

Now that we are done with sending email, let's schedule it.
Masonite provides a package called masonite-scheduler. It enables your app to schedule cron tasks. First, you need to run a command to install the package:

$ pipenv install masonite-scheduler

The second command is a craft task command which will create a new task under the app/tasks directory.

$ craft task WeeklyEmail

Before running our task weekly, let's run it every 1 minute.

from scheduler.Task import Task

class WeeklyEmail(Task):

    run_every = '1 minute'

    def __init__(self, Mail):
        self.mail = Mail

    def handle(self):
        self.mail.subject('Build your next SaaS with Masonite 🚀')\
                .to('hello@email.com').template('mail/weekly')\
                .send()

Above, you send a email with a template located under mail folder. Create a file called weekly.html and put a random text inside.

<h2>Hello world!</h2>
<p><a href="https://github.com/MasoniteFramework/masonite">Masonite</a> is magic. ✨ </p>
<p>
    There are many benefits Masonite brings to your next SaaS project.
</p>
<img src="https://media.giphy.com/media/3o6Ztqh4JSlVqi2Z20/giphy.gif" alt="just do it">

Let's test this before setting up a cron job. Put your Mailtrap credentials into your .env file and run this command.

$ craft schedule:run

Let's Masonite fetch and run your task!

Let's put the right parameters and tell the task when it should run (remember a weekly email).

class WeeklyEmail(Task):
    run_every = '7 days'
    run_at = '17:00'

Cron Jobs

You need to set up the Cron Jobs to run automatically our tasks. Each crontab line must start with a time at which the command should be run and then the command:
So, to run command at 17:00 every monday, you'd do:

00 17 * * 1 command

You need to append && craft schedule:run to run your run the scheduled task.

Masonite Task Scheduling documentation page can provide further information. Just read it ✊!

If you want to contribute or interested in the development of Masonite then be sure to join the Slack channel or star the repo on GitHub.

Let's make Masonite Framework and Laravel Mix work together

Junior Gantin — Wed, 22 Aug 2018 22:22:48 +0000

Masonite is a beautifully crafted Web Framework for Python. We usually use files like CSS, JavaScript and image files known as Web assets to make our web app looks great.

In this article, I'll show you how you can use Laravel Mix for processing and compiling assets into your Masonite web app.

What is Laravel Mix?

Laravel Mix makes asset compiling incredibly easy.
Using Laravel Mix with Masonite is really a simple task. There we go!

Create a new Masonite project

Before we get started, create a new Masonite project. Just install Masonite's CLI called craft.

$ pip install masonite-cli
$ craft new masonite_laravel_mix
$ cd masonite_laravel_mix
$ craft install

Install and setup Laravel Mix

Laravel Mix can be used for any type of application, not just for Laravel apps. To get started, just install laravel-mix as our project dependency.

$ npm install laravel-mix

Put webpack config file into our project root.

$ cp node_modules/laravel-mix/setup/webpack.mix.js .

Then, add this sample script into webpack.mix.js like Laravel does.

mix.js('resources/assets/js/app.js', 'public/js')
   .sass('resources/assets/sass/app.scss', 'public/css');

This is definition of our asset pipeline. It's time to add some npm scripts.

"scripts": {
    "dev": "npm run development",
    "development": "cross-env NODE_ENV=development node_modules/webpack/bin/webpack.js --progress --hide-modules --config=node_modules/laravel-mix/setup/webpack.config.js",
    "watch": "npm run development -- --watch",
    "watch-poll": "npm run watch -- --watch-poll",
    "hot": "cross-env NODE_ENV=development node_modules/webpack-dev-server/bin/webpack-dev-server.js --inline --hot --config=node_modules/laravel-mix/setup/webpack.config.js",
    "prod": "npm run production",
    "production": "cross-env NODE_ENV=production node_modules/webpack/bin/webpack.js --no-progress --hide-modules --config=node_modules/laravel-mix/setup/webpack.config.js"
}

I just copied this npm scripts from Laravel repository - again 😅.
This scripts helps in asset compilation for development or production.
As you can see it, you need to install cross-env to make it works well.

$ npm install cross-env

Now that we’ve done all the hard work, let’s go ahead and a simple html file.

...
<link rel="stylesheet" href="/public/css/app.css">
...
<script src="/public/js/app.js"></script>
...

Simple thing to make all this stuff work is to create a template alias. All configurations that are specific to static files can be found in config/storage.py.
In this file we'll add a constant to STATICFILES which is simply a dictionary:

STATICFILES = {
    # folder  # template alias
    'public': 'public/'
}

We did it 🎉 🎉 🎉! You should see a screen similar to this:

You can watch this repository where I add Bootstrap as dependencies and use it as sample!

nioperas06 / masonite-laravel-mix

🎨 Masonite and Laravel Mix for processing and compiling assets

Masonite - Laravel Mix

Let's make Laravel Mix and Masonite Framework work together.

This application is a demo on how you can use Laravel Mix for processing and compiling assets.

View tutorial: Link

Built With:

Masonite - The Modern And Developer Centric Python Web Framework.
Laravel Mix - An elegant wrapper around Webpack for the 80% use case.

View on GitHub

Conclusion

Hopefully this article has helped you understand how Masonite and Laravel Mix can be used together for processing and compiling assets. If you want to contribute or interested in the development of Masonite then be sure to join the Slack or star Masonite's repository on GitHub.

Build Email Verification from Scratch With Masonite Framework and JSON Web Tokens

Junior Gantin — Thu, 09 Aug 2018 00:31:54 +0000

Masonite Framework is a modern and developer centric Python web framework. The architecture of Masonite is much more similar to the Laravel framework.

In this tutorial, I’ll show you how to build email verification from scratch for your Masonite application.

Masonite comes with a CLI tool called Craft. Craft provides an easy way to scaffold what you need for authentication using a simple command:

$ craft auth

The above command generates everything you need for authentication: 4 new controllers, 5 new templates and 6 new routes. So you want to handle a user email verification and validate the email. There we go!

Create new Masonite project and scaffold authentication

$ pipenv install masonite-cli
$ craft new masonite-app-with-user-verification 
$ cd masonite-app-with-user-verification 
$ craft install 
$ craft auth

Setup database

In order to register users, we will need a database. Let’s use a MySQL Database.

$ pipenv install PyMySQL

Create new database and put your database credentials into .env file:

DB_DRIVER=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=masonite
DB_USERNAME=root
DB_PASSWORD=root

Add ‘active’ attribute to User Model

Let’s create a new migration:

$ craft migration add_active_to_users_table --table=users

Then, add new active attribute:

from orator.migrations import Migration
class AddActiveToUsersTable(Migration):
    def up(self):
         with self.schema.table('users') as table:
             table.boolean('active').default(False)

    def down(self):
         with self.schema.table('users') as table:
             table.drop_column('active')

Apply your migrations 😄

$ craft migrate

Why use JWT for email verification?

JSON Web Tokens are a good way of securely transmitting information between parties.

For email verification, we need to send a random hash to registered user.

Generate new jwt token on registration

We need to use JSON Web Token implementation in Python:

$ pipenv install PyJWT

Then

data = {'email': user.email}
encoded = jwt.encode(data, os.environ.get('KEY'), algorithm='HS256')
token = str(encoded, 'utf-8')

Now, we need to send a mail. Masonite provides a package call notification that can help us perform this.

$ pipenv install masonite-notifications

Let’s create a notification for email verification.

$ craft notification EmailVerificationNotification

Our notification should send an e-mail with a link containing the verification token.

from notifications import Notifiable

class EmailVerificationNotification(Notifiable):
def mail(self):
    return self.subject('New account signup!') \
        .driver('smtp') \
        .heading('Masonite App With User Verification') \
        .line('In order to use your account, you have to validate your email address.') \
        .line('Please click on the link below.') \
        .action('Validate my account', href=self._link)

Not bad.

Then, let’s send that email to our users:

if token:
    Notify.mail(EmailVerificationNotification, to=user.email, link='http://localhost:8000/activate/{0}'.format(token))
    Session.flash(‘success’, ‘Almost done! Please check your email to complete the registration process.’)
    return Request.redirect(‘/login’)

If your smtp credentials are correct, you’ll have this in your mail:

Create a route for email verification

get('/activate/@token', 'RegisterController@validate')

Define fillable attribute ‘activate’ on User Model

class User(Model):
    __fillable__ = ['name', 'email', 'password', 'active']

Validate users

def validate(self, Request):
    if Request.param('token'):
        data = jwt.decode(Request.param('token'), os.environ.get('KEY'), algorithms=[‘HS256’])
        user = User.where('email', data['email']).first()
        if user:
            user.active = True
            user.save()
            Session.flash('success', 'You\'re in! Let\'s login!')
    return Request.redirect('/login')

Last thing! Login users:

def store(self, Request, Session):
    user = User.where('email', Request.input('email')).first()
    if user.active:
        if Auth(Request).login(Request.input('email'), Request.input('password')):
            return Request.redirect('/home')
        return Request.redirect('/login')
    else:
        Session.flash('warning', 'Please check your email to complete the registration process.')
        return Request.back()

Your user is now verified 🔥

I’ll release this stuff inside a Masonite package. If you want to contribute to the development of the package or interested in the development of Masonite then be sure to join the Slack channel or star the repo on GitHub.

Feel free to add you comments for further discussion. The entire code for this tutorial is available on Github. Thanks!

Saying "Hello world" using Masonite Framework

Junior Gantin — Wed, 20 Jun 2018 23:15:56 +0000

In this post, we will build a simple Hello World application using Masonite Framework.

What is Masonite Framework?

According to the official documentation, Masonite is describe as a Python web framework that strives for an actual batteries included developer tool with a lot of out of the box functionality with an extremely extendable architecture. Masonite is perfect for beginner developers getting into their first web applications as well as experienced developers.

Masonite uses the power of Python to offer developers a great set of features such as a simple and expressive routing engine, a powerful command line helpers, a simple migration system, a great Active Record style ORM, a great filesystem architecture for navigating and expanding your project and many more.

Let's begin

In order to use Masonite Framework, you’ll need:

Python 3.4+
Pip3 or Pipenv

You can now install Masonite using pip:

$ pip install masonite-cli

The next step is to create the Masonite project using craft command line tool:

$ craft new hello_world

This will get the latest Masonite project template inside a folder with the name hello_world. Now run the following commands:

$ cd hello_world
$ craft install
$ craft serve

Open your browser and visit the following address:

http://localhost:8000/

Voila!

Masonite is a truly MVC framework. All routes that define which action of which controller will serve are located in routes/web.py.

Now, add the following line in ROUTES list:

Get().route('/home', 'HomeController@home')

In Masonite, you can define a Controller method to a route. Let's create HomeController. Run this command:

$ craft controller Home

All controllers are located in the app/http/controllers directory. The HomeController generated contains:

''' A Module Description '''

class HomeController:
    ''' Class Docstring Description '''

    def show(self):
        pass

Just rename show method and return a view:

class HomeController:

    def home(self):
        return view('home')

view is called a helper function that do not require any imports and are simply just available 🔥. Let's create our home template with craft.

$ craft view home

This will create resources/templates/home.html. Change its content:

<h1>Masonite is awesome!</h1>

Open your browser at http://localhost:8000/home and there it is:

Deploy Angular Apps To Surge

Junior Gantin — Sun, 14 Jan 2018 21:36:34 +0000

I usually use Heroku for hosting my Angular Apps. It works fine but I want to try anything else: something new, something smart. I heard about two deploying tools dedicated to front-end developers: Netlify and Surge. In this article, I will show you how to deploy Angular apps to Surge.

What’s Surge?

Surge is a simple tool for publishing HTML5 apps without leaving the command line. Surge is powerful. I took 10 or 20 minutes sometimes for publishing Angular Apps on Heroku because you need to create a Procfile, add express and angular-cli on app’s dependencies and so on. But with Surge, you need to build your app and it’s alive!

How to do it?

First install Surge using npm:

$ npm install -g surge

Create a new Angular app:

$ ng new angular-surge
$ cd angular-surge

What you need to do now is to build your application for production environment.

$ ng build --prod

Now angular-cli put the build artifacts into dist folder. You need to deploy this folder with surge. Let’s move into dist folder with command line and start deploying.

$ cd dist
$ surge

Voila! Account creation will happen on your first run. Surge will show you where your application is alive on. Enjoy!

You can do more with Surge. Custom domain, 404 page, SSL and so more. Here is where you can start with these functionalities of Surge.

Never forget that you can deploy your Angular apps in one minute or less with Surge!!!

Happy coding!
Originally published at Medium on January 14, 2018.