Review

In the previous section, we have discussed the Spring Security-related configurations. In this section we will discuss the remaining configuration of our application.

Click on a link to jump to that section:

Functional Specs
Generate OAuth keys

Facebook
Twitter

Spring Social configuration
Spring Security configuration
JavaConfig

ApplicationInitializer.java
ApplicationContext.java
DataConfig.java
ThymeleafConfig.java
spring.properties

View with Thymeleaf
Layers

Domain
Repository
Service
Controller

Running the application

Clone from GitHub
Create the Database
Run with Maven and Tomcat 7
Run with Maven and Jetty 8
Import to Eclipse
Validate with W3C

JavaConfig

As stated in the introduction, we will be using JavaConfig-based configuration instead of the usual XML config. However, I don't want to alienate our readers who are used to XML. As a result, I've decided to provide both implementations. However, our focus here is still on JavaConfig.

Note: With JavaConfig, we can now omit the ubiquitous web.xml. But in order to that, we need to run a Servlet 3.0 web container. For this tutorial, I have tested the application with Tomcat 7.0.30 (Maven plugin), 7.0.33 (standalone Tomcat), and Jetty 8.1.5.v20120716 (Maven plugin).

ApplicationInitializer.java

The ApplicationInitializer.java is the equivalent of web.xml. Here's where we declare the DispatcherServlet and also we've registered two filters: one for Spring Security and another for Spring Social.

	package org.krams.config;

	import javax.servlet.FilterRegistration;
	import javax.servlet.ServletContext;
	import javax.servlet.ServletException;
	import javax.servlet.ServletRegistration;

	import org.springframework.web.WebApplicationInitializer;
	import org.springframework.web.context.ContextLoaderListener;
	import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
	import org.springframework.web.filter.DelegatingFilterProxy;
	import org.springframework.web.filter.HiddenHttpMethodFilter;
	import org.springframework.web.servlet.DispatcherServlet;

	public class ApplicationInitializer implements WebApplicationInitializer {

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
	// Load application context
	AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
	rootContext.register(ApplicationContext.class);
	rootContext.setDisplayName("Spring Social Tutorial");

	// Add context loader listener
	servletContext.addListener(new ContextLoaderListener(rootContext));

	// Declare dispatcher servlet
	ServletRegistration.Dynamic dispatcher =
	servletContext.addServlet("dispatcher", new DispatcherServlet(rootContext));
	dispatcher.setLoadOnStartup(1);
	dispatcher.addMapping("/");

	// Register Spring security filter
	FilterRegistration.Dynamic springSecurityFilterChain =
	servletContext.addFilter("springSecurityFilterChain", DelegatingFilterProxy.class);
	springSecurityFilterChain.addMappingForUrlPatterns(null, false, "/*");

	// Register Spring Social filter so that we can disconnect from providers
	FilterRegistration.Dynamic hiddenHttpMethodFilter =
	servletContext.addFilter("hiddenHttpMethodFilter", HiddenHttpMethodFilter.class);
	hiddenHttpMethodFilter.addMappingForUrlPatterns(null, false, "/*");
	}

	}

view raw ApplicationInitializer.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<web-app xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">
	<display-name>Spring Social Tutorial</display-name>

	<filter>
	<filter-name>springSecurityFilterChain</filter-name>
	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>

	<filter-mapping>
	<filter-name>springSecurityFilterChain</filter-name>
	<url-pattern>/*</url-pattern>
	</filter-mapping>

	<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
	/WEB-INF/spring-security.xml
	/WEB-INF/applicationContext.xml
	</param-value>
	</context-param>

	<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<servlet>
	<servlet-name>spring</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	</servlet>

	<servlet-mapping>
	<servlet-name>spring</servlet-name>
	<url-pattern>/</url-pattern>
	</servlet-mapping>

	<filter>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
	</filter>

	<filter-mapping>
	<filter-name>hiddenHttpMethodFilter</filter-name>
	<url-pattern>/*</url-pattern>
	</filter-mapping>
	</web-app>

view raw web.xml hosted with ❤ by GitHub

ApplicationContext.java

The ApplicationContext.java contains our main configuration. It's responsible for loading other configurations, either as JavaConfig or XML config.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.ComponentScan;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Import;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.context.annotation.PropertySource;
	import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
	import org.springframework.context.support.ResourceBundleMessageSource;
	import org.springframework.core.io.ClassPathResource;
	import org.springframework.core.io.Resource;
	import org.springframework.web.servlet.config.annotation.EnableWebMvc;
	import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

	@Configuration
	@ComponentScan(basePackages = {"org.krams"})
	@EnableWebMvc
	@Import({DataConfig.class, ThymeleafConfig.class, SocialConfig.class, SecurityConfig.class})
	@ImportResource({"classpath:trace-context.xml"})
	@PropertySource("classpath:spring.properties")
	public class ApplicationContext extends WebMvcConfigurerAdapter {

	// Maps resources path to webapp/resources
	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
	registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
	}

	// Provides internationalization of messages
	@Bean
	public ResourceBundleMessageSource messageSource() {
	ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
	messageSource.setBasename("messages");
	return messageSource;
	}

	// Only needed if we are using @Value and ${...} when referencing properties
	// Otherwise @PropertySource is enough by itself
	@Bean
	public static PropertySourcesPlaceholderConfigurer properties() {
	PropertySourcesPlaceholderConfigurer propertySources = new PropertySourcesPlaceholderConfigurer();
	Resource[] resources = new ClassPathResource[] {
	new ClassPathResource("spring.properties") };
	propertySources.setLocations(resources);
	propertySources.setIgnoreUnresolvablePlaceholders(true);
	return propertySources;
	}
	}

view raw ApplicationContext.java hosted with ❤ by GitHub

Let's describe each annotation:

@Configuration
- Marks a class as a JavaConfig
@ComponentScan(basePackages = {"org.krams"})
- Configures scanning of Spring components

This is equivalent in XML as:

<context:annotation-config />

<context:component-scan base-package="org.krams" />

view raw context-annotation-config.xml hosted with ❤ by GitHub
@EnableWebMvc
- Activates Spring's MVC support

This is equivalent in XML as:

<mvc:annotation-driven />

view raw mvc-annotation-driven.xml hosted with ❤ by GitHub
@Import({DataConfig.class, ThymeleafConfig.class, SocialConfig.class, SecurityConfig.class})
- This allows us to import JavaConfig-based config. Notice we have imported four configuration classes
@ImportResource("classpath:trace-context.xml")
- This allows us to import XML-based config files. (As a side note why can't we just declare this as a JavaConfig? It turns out there's no direct translation for the trace-context.xml, so we'll have to import it as XML).

This is equivalent in XML as:

<import resource="trace-context.xml"/>

view raw import-resource.xml hosted with ❤ by GitHub
@PropertySource("classpath:spring.properties")
- This allows us to import property files
@Bean
- Declares a Spring bean

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

	<!-- Activates various annotations to be detected in bean classes -->
	<context:annotation-config />

	<!-- Scans the classpath for annotated components that will be auto-registered as Spring beans.
	For example @Controller and @Service. Make sure to set the correct base-package -->
	<context:component-scan base-package="org.krams" />

	<!-- Configures the annotation-driven Spring MVC Controller programming model.
	Note that, with Spring 3.0, this tag works in Servlet MVC only! -->
	<mvc:annotation-driven />

	<!-- Maps resources path to webapp/resources -->
	<mvc:resources mapping="/resources/**" location="/resources/" />

	<!-- Provides internationalization of messages -->
	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource"
	p:basename="messages" />

	<!-- Imports Spring Social configuration -->
	<import resource="spring-social.xml"/>

	<!-- Imports datasource configuration -->
	<import resource="spring-data.xml"/>

	<!-- Imports logging configuration -->
	<import resource="trace-context.xml"/>

	<bean id="deployProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean"
	p:location="/WEB-INF/spring.properties" />

	</beans>

view raw applicationContext.xml hosted with ❤ by GitHub

DataConfig.java

The DataConfig.java contains our Spring Data configuration. This is where we declare our data source, transaction manager, and JPA entity manager.

	package org.krams.config;

	import javax.sql.DataSource;

	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.core.env.Environment;
	import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
	import org.springframework.orm.jpa.JpaTransactionManager;
	import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
	import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
	import org.springframework.transaction.annotation.EnableTransactionManagement;
	import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
	import com.mchange.v2.c3p0.ComboPooledDataSource;

	@Configuration
	@EnableTransactionManagement
	@EnableJpaRepositories("org.krams.repository")
	public class DataConfig extends WebMvcConfigurerAdapter {

	@Autowired
	private Environment env;

	@Bean
	public DataSource dataSource() {
	try {
	ComboPooledDataSource ds = new ComboPooledDataSource();
	ds.setDriverClass(env.getRequiredProperty("app.jdbc.driverClassName"));
	ds.setJdbcUrl(env.getRequiredProperty("app.jdbc.url"));
	ds.setUser(env.getRequiredProperty("app.jdbc.username"));
	ds.setPassword(env.getRequiredProperty("app.jdbc.password"));
	ds.setAcquireIncrement(5);
	ds.setIdleConnectionTestPeriod(60);
	ds.setMaxPoolSize(100);
	ds.setMaxStatements(50);
	ds.setMinPoolSize(10);
	return ds;
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	}

	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
	HibernateJpaVendorAdapter vendor = new HibernateJpaVendorAdapter();
	vendor.setShowSql(false);

	LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
	em.setPersistenceXmlLocation("classpath*:META-INF/persistence.xml");
	em.setPersistenceUnitName("hibernatePersistenceUnit");
	em.setDataSource(dataSource());
	em.setJpaVendorAdapter(vendor);
	return em;
	}

	@Bean
	public JpaTransactionManager transactionManager() {
	JpaTransactionManager transactionManager = new JpaTransactionManager();
	transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
	return transactionManager;
	}
	}

view raw DataConfig.java hosted with ❤ by GitHub

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
	http://www.springframework.org/schema/jdbc
	http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
	http://www.springframework.org/schema/data/jpa
	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util-3.1.xsd">

	<context:property-placeholder properties-ref="deployProperties" />

	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- Activate Spring Data JPA repository support -->
	<jpa:repositories base-package="org.krams.repository" />

	<!-- Declare a datasource that has pooling capabilities-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
	destroy-method="close"
	p:driverClass="${app.jdbc.driverClassName}"
	p:jdbcUrl="${app.jdbc.url}"
	p:user="${app.jdbc.username}"
	p:password="${app.jdbc.password}"
	p:acquireIncrement="5"
	p:idleConnectionTestPeriod="60"
	p:maxPoolSize="100"
	p:maxStatements="50"
	p:minPoolSize="10" />

	<!-- Declare a JPA entityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
	p:persistenceXmlLocation="classpath*:META-INF/persistence.xml"
	p:persistenceUnitName="hibernatePersistenceUnit"
	p:dataSource-ref="dataSource"
	p:jpaVendorAdapter-ref="hibernateVendor"/>

	<!-- Specify our ORM vendor -->
	<bean id="hibernateVendor" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
	p:showSql="false"/>

	<!-- Declare a transaction manager-->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
	p:entityManagerFactory-ref="entityManagerFactory"/>

	</beans>

view raw spring-data.xml hosted with ❤ by GitHub

ThymeleafConfig.java

The ThymeleafConfig.java contains our Thymeleaf configuration. This is where we declare our Thymeleaf view resolver.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.thymeleaf.spring3.SpringTemplateEngine;
	import org.thymeleaf.spring3.view.ThymeleafViewResolver;
	import org.thymeleaf.templateresolver.ServletContextTemplateResolver;

	@Configuration
	public class ThymeleafConfig {

	@Bean
	public ServletContextTemplateResolver templateResolver() {
	ServletContextTemplateResolver resolver = new ServletContextTemplateResolver();
	resolver.setPrefix("/WEB-INF/templates/");
	resolver.setSuffix(".html");
	resolver.setTemplateMode("HTML5");
	resolver.setOrder(1);

	// Declare virtual paths
	resolver.addTemplateAlias("connect/facebookConnect","facebook/connect");
	resolver.addTemplateAlias("connect/twitterConnect","twitter/connect");
	resolver.addTemplateAlias("connect/facebookConnected","facebook/connected");
	resolver.addTemplateAlias("connect/twitterConnected","facebook/connected");

	// Disable cache for testing purposes
	resolver.setCacheable(false);
	return resolver;
	}

	@Bean
	public SpringTemplateEngine templateEngine() {
	SpringTemplateEngine engine = new SpringTemplateEngine();
	engine.setTemplateResolver(templateResolver());
	return engine;
	}

	@Bean
	public ThymeleafViewResolver thymeleafViewResolver() {
	ThymeleafViewResolver resolver = new ThymeleafViewResolver();
	resolver.setTemplateEngine(templateEngine());
	return resolver;
	}

	}

view raw ThymeleafConfig.java hosted with ❤ by GitHub

We've declared some special settings on our Thymeleaf configuration:

// Declare virtual paths
resolver.addTemplateAlias("connect/facebookConnect","facebook/connect");
resolver.addTemplateAlias("connect/twitterConnect","twitter/connect");
resolver.addTemplateAlias("connect/facebookConnected","facebook/connected");
resolver.addTemplateAlias("connect/twitterConnected","facebook/connected");

// Disable cache for testing purposes
resolver.setCacheable(false);

These allows to redirect virtual path requests to specific templates within our application. We need to do this because the ConnectController from Spring Social has its own built-in controller path requests. And we need to redirect the resulting views that matches our template path.

For example, when connecting to Facebook, ConnectController will use the connect/facebookConnect path and you are required to provide a view. Using the addTemplateAlias() method, we can provide a custom view, in this case, the view points to the directory in the WEB-INF/templates/facebook/connect.

Also, we've disabled the caching feature so that we can easily update and test our html pages.

Here's the equivalent XML configuration:

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util-3.1.xsd">

	<!-- Declare a Thymeleaf resolver -->
	<bean id="templateResolver" class="org.thymeleaf.templateresolver.ServletContextTemplateResolver"
	p:prefix="/WEB-INF/templates/"
	p:suffix=".html"
	p:templateMode="HTML5"
	p:order="1"
	p:cacheable="false"
	p:templateAliases-ref="templateAliases"/>

	<util:map id="templateAliases">
	<entry key="connect/facebookConnect" value="facebook/connect"/>
	<entry key="connect/twitterConnect" value="twitter/connect"/>
	<entry key="connect/facebookConnected" value="facebook/connected"/>
	<entry key="connect/twitterConnected" value="twitter/connected"/>
	</util:map>

	<bean id="templateEngine" class="org.thymeleaf.spring3.SpringTemplateEngine"
	p:templateResolver-ref="templateResolver" />

	<bean class="org.thymeleaf.spring3.view.ThymeleafViewResolver"
	p:templateEngine-ref="templateEngine"/>

	</beans>

view raw spring-servlet.xml hosted with ❤ by GitHub

SecurityConfig.java

The SecurityConfig.java contains a single bean DelegatingFilterProxy. This is required for Spring Security.

	package org.krams.config;

	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.ImportResource;
	import org.springframework.web.filter.DelegatingFilterProxy;

	@Configuration
	@ImportResource({"classpath:spring-security.xml"})
	public class SecurityConfig {

	@Bean
	public DelegatingFilterProxy springSecurityFilterChain() {
	DelegatingFilterProxy filterProxy = new DelegatingFilterProxy();
	return filterProxy;
	}

	}

view raw SecurityConfig.java hosted with ❤ by GitHub

spring.properties

spring.properties contains the property settings of our application. You need to declare your Facebook and Twitter OAuth settings here. Here's also where you declare your database.

	# database properties
	app.jdbc.driverClassName=com.mysql.jdbc.Driver
	app.jdbc.url=jdbc\:mysql\://localhost/spring_social_tutorial
	app.jdbc.username=root
	app.jdbc.password=

	# social properties
	facebook.clientId=YOUR-FACEBOOK-CLIENT-ID
	facebook.clientSecret=YOUR-FACEBOOK-CLIENT-SECRET
	twitter.consumerKey=YOUR-TWITTER-CONSUMER-KEY
	twitter.consumerSecret=YOUR-TWITTER-CONSUMER-SECRET
	application.url=http://localhost:8080/spring-social-tutorial

view raw spring.properties hosted with ❤ by GitHub

messages_en.properties

This is for internationalization of messages. The default language is English. If you need to provide custom language, create a new properties file and replace the values according to the language you've chosen. Please see the Spring documentation for more info on internationalization.

	app.name=TestApp

	#login.html
	login.title=Sign in
	login.legend=Sign in
	login.username=Username
	login.password=Password
	login.button=Sign in
	login.noaccount=No account? Create one now!

	#signup.html
	signup.title=Sign up
	signup.legend=Sign up
	signup.button=Sign up
	signup.hasaccount=Already have an account? Sign in!

	#welcome.html
	welcome.title=Welcome

	#post.html
	post.title.fb=Post to Facebook
	post.title.tw=Post to Twitter
	post.form.legend.fb=Update your status:
	post.form.legend.tw=Tweet a message:
	post.form.action.fb=/fb/post
	post.form.action.tw=/tw/post
	post.form.submit.fb=Post it!
	post.form.submit.tw=Tweet it!

	#posted.html
	posted.title.fb=Facebook
	posted.title.tw=Twitter
	posted.success.fb=The following message has been posted:
	posted.success.tw=The following message has been tweeted:
	posted.failure.fb=Unable to post to your Facebook account!
	posted.failure.tw=Unable to post to your Twitter account!

	#profile.html
	profile.title.fb=Facebook Profile
	profile.title.tw=Twitter Profile
	profile.h3.fb=Facebook Profile
	profile.h3.tw=Twitter Profile
	profile.id.fb=Facebook ID:
	profile.id.tw=Twitter ID:
	profile.name.fb=Name:
	profile.name.tw=Screen Name
	profile.loc.fb=Email:
	profile.loc.tw=Location:
	profile.url.fb=Profile Url:
	profile.url.tw=Profile Url:

	#connect.html
	connect.title.fb=Connect to Facebook
	connect.title.tw=Connect to Twitter
	connect.h3.fb=Connect to Facebook
	connect.h3.tw=Connect to Twitter
	connect.form.action.fb=/connect/facebook
	connect.form.action.tw=/connect/twitter
	connect.message.fb=You haven't created any connections with Facebook yet. Click the button to create a connection between your account and your Facebook profile. (You'll be redirected to Facebook where you'll be asked to authorize the connection)
	connect.message.tw=You haven't created any connections with Twitter yet. Click the button to create a connection between your account and your Twitter profile. (You'll be redirected to Twitter where you'll be asked to authorize the connection)
	connect.button.fb=Connect with Facebook
	connect.button.tw=Connect with Tweeter

	#connected.html
	connected.title.fb=Facebook Connected
	connected.title.tw=Twitter Connected
	connected.h3.fb=Facebook Connected
	connected.h3.tw=Twitter Connected
	connected.message.fb=is now connected to your Facebook account. Click the button if you wish to disconnect. Try loading your profile or posting a message to test your connection.
	connected.message.tw=is now connected to your Tweeter account. Click the button if you wish to disconnect. Try loading your profile or posting a message to test your connection.

	#include.html
	disconnect.url.fb=/connect/facebook
	disconnect.url.tw=/connect/twitter
	disconnect.button.fb=Disconnect from Facebook
	disconnect.button.tw=Disconnect from Twitter

	#users.html
	users.title=User Management
	users.table.caption=Site Users
	user.id.label=Id
	user.firstname.label=First Name
	user.lastname.label=Last Name
	user.username.label=Username
	user.password.label=Password
	user.role.label=Role
	user.role.1=admin
	user.role.2=regular
	new.user.table.caption=New User
	new.user.button.label=add
	update.user.table.caption=Existing User
	update.user.button.label=update

	error.profile.fb=Failure! An error has occurred while trying to retrieve your profile!
	error.profile.tw=Failure! An error has occurred while trying to retrieve your profile!
	error.post.fb=Failure! We are unable to process your request!
	error.post.tw=Failure! We are unable to process your request!

	#errors
	error.access.denied=Access denied! You're not allowed to access that!
	status.login.failure=Unable to login. Invalid credentials!
	status.logout.success=You have successfully logged out!
	status.signup.invalid.username.duplicate=Username already exist!
	status.signup.invalid.password.notmatching=Passwords do not match!