Thursday, September 22, 2016

Exploring Devise, Part 1

In some of my previous articles about image uploading in Rails, I made mention of Devise but did not go deep into it. In this tutorial, I will be teaching you about Devise.

Ready? Let's get started!

Devise Introduction and Modules

Devise is an authentication solution for Rails built with Warden and provided by the awesome people at Plataformatec. Devise provides different modules:

  • Database Authenticatable: This encrypts and stores a password to the database to validate the authenticity of a user while signing in.
  • Omniauthable: This attaches OmniAuth support to Devise. Users of your application will be able to sign in using accounts such as Facebook, Twitter, and Google.
  • Confirmable: This enables the sending of emails with instructions that will help in the verification of an account.
  • Recoverable: This module helps in times when users forget their password and need to recover it. With this, the user will be able to reset the password.
  • Registerable: This handles the signup of users. It also allows users to edit and delete their accounts.
  • Rememberable: This module makes it possible for your application to remember a logged-in user by storing a cookie.
  • Trackable: This module helps track sign-in count, timestamps, and IP address.
  • Timeoutable: This module is responsible for expiring a session that has not been active for a period of time.
  • Validatable: With this module, email and password get to be validated.
  • Lockable: This provides an extra layer of security—when activated, an account can be locked after a given number of failed sign-in attempts.

Devise Integration

For the purpose of this tutorial, we are going to generate a Rails application that we'll use to check out the workings of Devise. Let's proceed!

rails new devise-app -T

The -T flag tells Rails to generate the application without the default test suite. Navigate to your application directory and drop the following gems into your Gemfile.

Now install the Devise and Bootstrap gems you just added.

bundle install

Rename your app/assets/stylesheets/application.css file to app/assets/stylesheets/application.scss and add the following lines in it:

Open up the app/assets/javascripts/application.js file and require bootstrap-sprockets. Mine looks like this:

Next, you need to run the Rails command to install the configuration files for Devise. You do so by running this command:

rails generate devise:install

The command generates the following on your terminal. You should read it to understand what happened.

The command also generates two files, which you can find in the config directory. It also gives us some instructions on what we should do.

Navigate to your application layout, app/views/layouts/application.html.erb, and make it look like what I have below:

You need to define the default URL options for your development environment. Add the code below in config/environments/development.rb.

Now you need to create a User model for Devise. You can do so using your terminal.

rails generate devise User

This will generate a user.rb file in your app/models directory. The file generated will look like this:

You can see that it contains the default modules I mentioned above. The command you ran also modified your config/routes.rb file by adding a route for devise. You should check that out.

At this point, you need to migrate your database. You do so by running: 

rake db:migrate

Authentication Using Devise

Now you need to create a PagesController and wrap Devise authentication around it—this will prevent unauthorized persons from seeing the page.

rails generate controller Pages index

Open up your routes file and set the root of your application.

Open up your PagesController and add authentication for your index and new pages.

The code shows that the index and new pages are accessible only to registered users. Open up your terminal and start your rails server. Point your browser to http://localhost:3000 and you will automatically be redirected to the Devise sign-in page.

Signing in Without Using Email

The default means of signing into Devise involves the use of email address and password. What if you want to enable users to sign in with their unique username? If that is what you want, it is possible. Let's see how.

Run the command:

rails generate migration AddUsernameToUSers username:string

This will add a new column for username in your users table. Migrate your database.

rake db:migrate

You need to add a field to your views where your users can enter their username. When you go to your app/views directory, you will not find any file that renders the Devise views. This is because Devise loads the views from its gemset. To customize it, you have to generate copies of the views. The command below does the magic.

rails generate devise:views

This will generate some folders and files in your app/views directory.

You will need to edit the page for signing in, signing up, and updating user information. Just paste the blocks of code below into their respective files.

Sign-Up

Edit

Sign-In

Using your text editor, navigate to app/controllers/application_controller.rb. You need to modify it to permit the use of username. Modify it to look like this:

Now a user can sign in with his/her username. At this point there is something not right about your application. When a user signs in, there is no way of signing out. This does not result in a great user experience. I'll show you how to fix that.

From your terminal, create a new directory called shared in your app/views folder.

The file you created above is a partial where the code for your navigation bar will be written. Drop in the following code.

Now you need to render the navigation bar in your application layout. Open up app/views/layouts/application.html.erb and drop in the code to render your navigation bar.

Conclusion

In this part you learned how to install Devise and add authentication to your pages. I also made mention of a partial. I will cover that in a separate tutorial. 

In the next part, we will cover some areas more advanced than this. I hope this was worth your time!


by Kingsley Silas Chijioke via Envato Tuts+ Code

AtoZ CSS Quick Tip: Using Hover and Height

H is for Hover and Height

There’s not too much more I can say about hover that I haven’t already covered in the video about the letter H. However, there are some cool animations that you can apply for a hover state. Google "CSS hover effects" and you’ll find plenty.

Here are a couple of sites that have some nifty effects:

Further to those, I recently produced a video for Code School, all about a library called hover.css.

Continue reading %AtoZ CSS Quick Tip: Using Hover and Height%


by Guy Routledge via SitePoint

Creating Custom WordPress Administration Pages, Part 3

Projekcje

Projections is an event organised by designers for other designers. It's main goal is not only to bring the members of graphic designer's community together, but also to inspire them to be creative.
by via Awwwards - Sites of the day

4 Creative Ways to Use Instagram for Business

dc-instagram-creative-business-600

Is your business using Instagram? Want to learn how to be more creative with Instagram? By making the most of Instagram’s unique features, you can stand out from the crowd and leave a lasting impression with customers and fans. In this article, you’ll discover four creative Instagram accounts you can model in your own marketing. [...]

This post 4 Creative Ways to Use Instagram for Business first appeared on .
- Your Guide to the Social Media Jungle


by Dorothy Cheng via

Two Chimps Coffee

Two Chimps Coffee

Sweet SVG animations in this clean One Pager promoting the product range from 'Two Chimps Coffee'. Neat newsletter sign up solution in the footer and stoked to find out it's built on WordPress!

by Rob Hope via One Page Love

A Hibernate Introduction – Persisting Java Objects the Easy Way

When it comes to object persistence, the JPA/Hibernate tandem is one of those gems you’ll never want to leave behind once you get used to it. Thorben Janssen has written a great introduction to the subject, listing five good reasons why to use it. (It’s not a prerequisite for this article but I nevertheless strongly encourage you to give it a read.) In this tutorial we will focus on Hibernate’s core feature: persisting object graphs.

Why Do We Need Automated Persistence? - The Case for Hibernate

Let’s first answer the question why we would even use a framework to persist application data. Is JDBC (Java Database Connectivity) not good enough for us?

Well, if we look at the data held by our applications, we’ll usually see a complex network of objects, also known as the object graph, that we want to write to and read from some store, usually a relational database. Unfortunately, the persistence process is far from straightforward. Translating entire objects graphs to plain tabular data is everything but simple and storing objects using plain JDBC is painful and cumbersome, as the standard exposes a low-level API. You know, connecting to a database and writing SQL queries from scratch is all well and fine. But be honest with yourself: Do you want to do that over and over again? If you’re anything like me, you don’t.

And this is where Hibernate comes in. Besides a lot of other things, it allows us to create the objects that hold our data, called entities, as we are used to and automates the process of reading and writing them.

Let’s get started!

Developing a Basic Java Application - Getting Started Using Hibernate

A nice way to start pulling the reins of Hibernate is to create a simple example. To do so, I’m very going to develop a naive Java application, whose functionality will boil down to performing CRUD operations on some user objects. In turn, the objects will be persisted, fetched, updated and removed from a MySQL database.

To get things rolling as expected, we first need to grab the required Hibernate ORM JARs, along with the corresponding MySQL Java Connector. Maven will do that nicely for us, so we can focus on coding, rather than on dealing with dependency issues.

Here’s my POM file:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://ift.tt/IH78KX"
    xmlns:xsi="http://ift.tt/ra1lAU"
    xsi:schemaLocation="http://ift.tt/IH78KX
        http://ift.tt/VE5zRx">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.electricalweb.hibernatepplication</groupId>
    <artifactId>hibernateapplication</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.2.Final</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.3</version>
        </dependency>
    </dependencies>
</project>

In this particular case, I’ll be using IntelliJ IDEA as my personal IDE, but the project can be easily created in NetBeans, Eclipse, or the IDE of your choice.

With the POM file under the way, here’s how this sample application will be laid out:

application_layout

As shown above, the application’s skeleton is structured in only three packages: com.electricalweb.entities, which contains the domain class that models users, com.electricalweb.daos, which houses a basic user DAO class, and lastly com.electricalweb.application, which is the application’s entry point. Since the primary goal is to persist user objects in MySQL, let’s define the User domain class.

Defining a Persistable Entity - Hibernate's Core Feature

To keep things simple, the domain class will be extremely anemic, having only a couple of private properties, name and email, along with a parameterized constructor and the typical setters/getters. Here’s the class in question:

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
    private String name;
    private String email;

    public User() {}

    public User(String name, String email) {
        this.setName(name);
        this.setEmail(email);
    }

    // getters and setters for name and email

}

Yes, you’re right. The above class is just a lightweight data container with no behavior attached to it (feel free to judge me for committing this cardinal sin). The only detail worth to stress here is that in order to make it persistable for Hibernate (or any other JPA implementation) it’s been marked with an @Entity annotation. In addition, Hibernate needs to know how to handle the entities’ primary keys.

To tackle this, the @Id and @GeneratedValue(strategy = GenerationType.AUTO) annotations instruct Hibernate to automatically generate an ID for each user entity, which will be mapped to the primary key of the corresponding database entry. Finally, the @Table(name = "users") annotation tells Hibernate to map instances of the class to rows in a users table.

With the domain class already defined, the final step to take in order to get the sample application up and running is create a configuration file, not surprisingly called persistence.xml, which will contain all the data required for connecting to the database and mapping entities to the database.

Accessing the Database - Creating a Persistence Unit

Unquestionably, the most common way of setting up the connection parameters to the database, along with additional Hibernate proprietary options, is by defining the aforementioned persistence.xml file. The process is pretty boring but extremely straightforward, trust me.

Here’s how a typical version of this file might look:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://ift.tt/UICAJV" version="2.0">

    <persistence-unit name="user-unit" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <class>com.electricalweb.entities.User</class>
        <properties>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/usersdb" />
            <property name="javax.persistence.jdbc.user" value="username" />
            <property name="javax.persistence.jdbc.password" value="password" />
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

As you can see, the file is easily readable from top to bottom. It just sets up a few database connection parameters, which you should be familiar with if you’ve worked with JDBC before, including the database URL, the JDBC driver, the database username and the password (make sure to provide the right values for your own database server).

Additionally, and this is by far the most interesting segment of the file, it defines a persistence-unit, that is a set of persistence entities (in this case just users, but it could be multiple entities wrapped inside several <class> tags) which are handled by a JPA entity manager. Considering that in this case Hibernate is the chosen JPA implementation, the entities will be managed by Hibernate’s entity manager.

If you’re like me, at this point you’ll be eager to see how to use the entity manager for performing CRUD operations on a few user entities in a snap. Just relax. The next section covers the process in depth.

Performing CRUD Operations on Entities - Working with Hibernate's Entity Manager

In a nutshell, running CRUD operations on user objects is much easier than one might think. The entire process just boils down to spawning the EntityManager and consuming its API. It’s really that easy.

For instance, we could use the application’s entry point, which is a simple class with a plain static main method, and call the entity manager in the following way:

EntityManager entityManager = Persistence
        .createEntityManagerFactory("user-unit")
        .createEntityManager();
EntityTransaction entityTransaction = entityManager.getTransaction();

/* Persist a User entity */
entityTransaction.begin();
User user = new User("Alejandro", "alejandro@domain.com");
entityManager.persist(user);
entityTransaction.commit();

/* Fetch a User entity */
entityManager.find(User.class, 1);

/* Update a User entity */
entityTransaction.begin();
User user = entityManager.find(User.class, 1);
user.setName("Alex");
user.setEmail("alex@domain.com");
entityManager.merge(user);
entityTransaction.commit();

/* Remove a User entity */
entityTransaction.begin();
User user = entityManager.find(User.class, 1);
entityManager.remove(user);
entityTransaction.commit();

entityManager.close();

Quite simple, isn’t it? Saving, fetching, updating and deleting user entities with a non-managed entity manager is a no-brainer process that can be mastered literally within minutes. The procedure is limited to first getting the manager via an EntityManagerFactory, then grabbing an instance of the EntityTransaction class, and finally calling the desired method of the entity manager.

The above code snippet assumes there’s a MySQL database table called users already defined, together with a MySQL instance running on a local server. So, make sure to set up that before testing the sample application.

At this point, you hopefully learned the basics behind persisting single entities with Hibernate. So, what comes up next? Well, a lot actually. As you may have noticed, I left out of the picture persisting entities that have a specific relationship with other entities (yes, the relational aspect). I did this deliberately, in order to keep the whole learning process free from additional, unnecessary complexities. After all, this is just an introduction to getting started using Hibernate.

Still, I’d like to polish the demo a little bit, as in its current state it looks pretty monolithic and its execution flow can’t be controlled through a user interface.

Taking this into consideration, what I’ll do next will be defining a DAO class, which will encapsulate the handling of the entity manager and the entity transaction behind the fences of a declarative API. Finally, you’ll see how to use the class for selectively executing CRUD methods on user entities, based on options entered in the Java console.

Adding a Nice API - Defining a DAO Class

Believe me. I’m not a blind worshiper of design patterns, using them everywhere without having strong reasons to do so. In this case, however, it’s worth to appeal to the functionality provided by the DAO pattern, so you can give the previous example a try without much hassle.

Continue reading %A Hibernate Introduction – Persisting Java Objects the Easy Way%


by Alejandro Gervasio via SitePoint