Minor changes have been done in the SQL scripts to make them
compatible with MySQL 8. The main change is the way that the user is
created.

The performance of the auto-redeploy executions configured in Maven have
been improved by adjusting the directories watched by the plugin
responsible for the redeployment.

The @angular/cdk library was not updated when the other Angular
libraries were updated. This commit fixes this by updating this
library.

The POM and other configuration files have been updated to support a new
execution mode where Cargo is used to execute the backend and NPM to
execute the frontend, both in auto-redeploy mode.

Acceptance tests were not working as they wasn't adapted to the Angular
framework after the migration. This commit fixes these test that now
work again.

Angular version has been upgraded to 8.2. In addition, "npm audit fix"
has been run to fix any security issue.

A bug was causing the "Limpiar" button of the people view not to work,
as the event-managing method was calling itself. This bugfix solves this
problem by changing the method called by the event-managing method.

The auto-redeploy mode now ignores node_modules, as it slows excesively
down the execution.

The PeopleResourceTests now include security tests to verify that normal
users can't access people data.

The example done for JavaScript, were people can be managed, has been
migrated to Angular.

The user authentication was currently done using a cookie and following
the same style of token as the HTTP Basic authentication (i.e. a
concatenation of user and password joined with a ':' encoded with
base64).

This authentication has been replaced by a standard HTTP Basic
authentication.

The message showed currently by the HasHttpStatus when de expected
status didn't match the actual status was not very informative, as
the actual status was not shown in the message.

This commit modifies this behaviour to show both status (expected and
actual) in the message.

When an invalid login is provided to the UsersDAO.get method it throws
an IllegalArgumentException. This may happen when the user's credentials
are checked by the LoginFilter, and the exception was not currently
managed. As a result, an user trying to login with an invalid login will
access the main.html page showing an error message.

This commit fixes this error, and invalid user login attempts now return
to the index.html page.

Commit 9ef1c405 redesigned the user interface by introducing Bootstrap.
Although the structure changes where minimal, the changes on class types
caused the page object classes' selectors to fail.

This commit fixes this error and, in addition, fixes an unexpected error
on person deletion. This error was caused due to a missing wait for an
AJAX request response.

Some labels in the user interface were in Spanish and some in English.
This commit standardizes the language used to Spanish, translating every
label to that language.

Red background was added to the body of the login view for debugging
purposes, but shouldn't have passed to a stable release. This commit
removes the red background configuration.

The application appearance has been improved applying Bootstrap formats.

Some "console.logs" have been removed from the PeopleView class and the full
resposibility for the edition and deletion of people has been moved to public
methods of PeopleView.

The frontend has been refactorized to use classes in the JavaScript files.

Some backend classes have been refactorized and simplified.

The EqualsVerifier library has been added to test the equals and hashCode
methods and it has been used to test the Person entity.

The login token was incorrectly set to "admin:admin" instead of
"admin:adminpass". This commit fixes this and sets the valid token
value.

This commit adds the new resource UsersResource (/users) with a simple
functionality: retrieving the data of an user. This functionality
requires knowing the login of the user that is performing the request.
In this regard, this commit is an example of how this information can be
retrieved and how to test a resource that requires knowing the login of
an user.

This test was unintentionally leaved out when creating the test case.

The redirect created in the LoginFilter when the request URL included
query parameters was incomplete, as it missed the "?" that separates the
query parameters from the request URL. This commit fixes this error.

When a user is correctly logged in, the LoginFilter adds the user login
to the HTTP session. This allows, for example, the REST layer to
retrieve the current logged user.

The tests classes have been simplified by delegating some of the
functions in the test classes to external utility classes. For example,
a PeopleDataset has been added to manage the dataset or the
IsEqualToEntity Hamcrest matcher has been added to simplify entity
comparisons.

In addition, a PersonUnitTest class has been added to test the Person
entity.

A big refactorization has been done in this commit, focused on
simplifying the testing and execution process. The Spring-DbUnit library
has been added to allow the use of DbUnit through annotations in the
test classes. This change has been complemented with two new test
listeners that allow the creation of custom initial contexts and the use
of custom SQL scripts to create and destroy the database tables before
and after the test execution, respectively. In addition, all the tests
are executed now using a HSQLDB database.

The datasource configuration has been pulled out of the project, and now
it must be provided by the container.

The sample classes have been reviewed, refactorized and documented with
JavaDoc.

The POM file has been reworked to ease test and application execution
using maven. The new execution modes are:
	- The default execution includes unit, integration and acceptance (with
Selenium) test execution.
	- No acceptance tests: mvn -P -acceptance-tests-cargo <phase>
	- Run server for manual acceptance tests: mvn
-Dcargo.tomcat.start.skip=true -Dcargo.tomcat.run.skip=false
-DskipTests=true pre-integration-test 
	- Run server with MySQL database: mvn -P
run-tomcat-mysql,-acceptance-tests-cargo -DskipTests=true package
cargo:run

DatabaseQueryUnitTest mocks the database and there is no need to create
a testing database. Therefore, the TestUtils method calls to initialize
and clear the testing database where removed.

Several testing improvement have been done:
	- Cobertura plugin was replaced by JaCoCo plugin that supports Java 8
syntax.
	- Unit tests with a controller fixtured using EasyMock were added for
PeopleDAO and PeopleResource.
	- POM was reviewed, reordered and reformatted.
	- Test classes naming was reviewed and standarized.
	- Three test suites were added to group the unit, integration, and
acceptance tests.
	- Naming context management done in TestUtils was improved. 

Dependency with Apache Commons Codec was removed and now the native Java
8 utilities for SHA-256 and Base64 encoding and decoding is used.

The java.util.logging.Logger was introduced as the logger for the
application.

Web configuration for REST services and login filter was moved from the
web.xml file to code annotations.

POM was reviewed to update the dependencies of the project to the last
version and to improve the test execution.

Now it is possible to run the project with the testing database in a
Tomcat Server v7.0 using the mvn tomcat7:run goal. In addition, Selenium
tests now are executed as integration tests, starting the web server
before the test execution and stoping it after the tests end. Finally,
support for generating regular and cobertura test reports in HTML format
was also added.

The project was also cleaned by removing the MANIFEST.MF files and by
reallocating the SQL files.

Sunfire report generation plugin added to pom.xml.

Minor code cleaning in pom.xml and PeopleWebTest class.

New login method based in HTTP's Basic Authentication used. This new
method eliminates the need of the database supporting the SHA256
algorithm and facilitates the future use of Basic Authentication.

Tests were updated to use the new token encoding.

DAO class modified to support and alternative JNDI for the data source
through the "db.jndi" system property. A new testing database resource
was added to the Context.xml file.

DAO tests use the "spring-test" library to create a JNDI context, as
JUnit doesn't create any context. Additionaly, a custom DataSource is
created using the "commons-dbcp" library and injected into the context.
Testing database creation scripts are provided in the mysql-tests.sql
file.

REST API is tested in the server side using the
"jersey-test-framework-provider-grizzly2" library. These tests also use
the "spring-test" and "commons-dbcp" libraries to create a context and
inject a custom data source.

REST API is tested in the client side using the "Selenium IDE" and
"RESTClient" plugins for Firefox. Manual database reset is required
before launching the test suite.

Web interface is tested using the "Selenium IDE" plugin for Firefox and
using the "Selenium WebDrive" in JUnit tests. Same tests are implemented
in both cases. Selenium IDE tests require a manual database reset before
launching the test suite. JUnit test require the server to be started
using the testing database.

PeopleDAO functions now throw an IllegalArgumentException when an
invalid id or a null name or surname are provided. People's REST API
modified to return a "Bad Request" status when an
IllegalArgumentException is catched.

LoginFilter modified to send redirect when login is done with parameters
and to return a 403 error when accesing Rest API without authorization.

Access to any resource except index.html can be restricted enabling the
LoginFilter in the web.xml configuration file. It is currently disabled.

Old index.html moved to main.html and replaced with an index.html that
contains a login form.