danutchindris / bbcv Goto Github PK

Check all service methods and write unit tests where appropriate.
For some of the service methods there already are a few unit tests (e.g. the methods in UserService).

Implement a mechanism for serving static resources stored at an external location in the filesystem. The actual location for the static resources should be configurable in the application.yml file.
Spring Boot will allow us to configure the articles.images property from outside the deployed application.

When the session expires the CSRF token is invalidated.
The user, who believes they are still logged in tries to save an article but the server returns a 403. However there is no error message displayed in the page. The attached screen shot shows the errors visible with FireBug.

Handle properly session expiration, implementing a mechanism that checks the validity of the authentication token and redirects the user to the login page when needed.

Add Destinations Page which displays a list of destinations based on available tags.

Implement the mechanism for saving an article in the back office.
The actual content of the article is written in Markdown and there needs to be an editor that allows you to input Markdown code and preview the results on the fly.
We will use EpicEditor for that: EpicEditor
We need to decide how to store the article's title and content (possibly other types of content like pictures as well). Please consider the implications regarding the need to store the article's translations in several languages (both title and content).

Please implement the back office page for managing messages coming from users who filled in the form in the Contact Us page.
As with other objects which are managed in back office, the messaged should be displayed in a table. Each row will have a few actions available.
The message contains the following fields: name, email, phone, message. These are displayed in the Contact Us form. Only email and message should be mandatory in the form.
There should be a mechanism for ensuring no message is overlooked. Therefore we need something like a flag indicating the message was read and processed.

The images are currently related only to articles.
We need to extend the mechanism to be able to store images for other objects, such as tags.

The current login page works but it should be improved to match the look & feel of the overall application.
Design and implement a solution that uses the creative-tim provided templates and components.

As we updated our project to use Java 8 we can take advantage of the platform's latest features.
Refactor the code to use the Java 8 Optional type where appropriate.

Add System Settings page which is available for administrators.

Refactor the implementation for the Administration module so that it's easier to understand and extend. Split the Spring controllers into logical units.

Implement status mechanism for articles.
Only published articles should be displayed.
Articles are not deleted, but marked as deleted using the appropriate status.

At the moment articles can only contain text stored in MarkDown format.
Design and implement a mechanism for storing images properly on the server.
The images will have translated title and alternative stored in the dictionary.
Also, they will be referenced properly in the MarkDown text.

Add new column to the USER table and manage it in the user administration page.
Also retrieve it with the other properties where needed.

There was an effort to implement this functionality however it is not yet complete.
Please see the implementation in GlobalExceptionHandler (which is annotated with @ControllerAdvice). If there is something else that needs to be done please implement that.
Also, implement customized error pages according to various scenarios such as 404 HTTP response code, access denied, authorization error.

Implement a page that displays the profile of the logged in user.
It will be accessible through a link in the "Account" drop down on the header.
Please propose what information this page should contain.
From a technical perspective you need to implement unit tests, integration tests, the controller, template, service methods and data access methods.

Currently we retrieve the whole data set for displaying the rows of a table. The Bootstrap table is able to display pages of data so we should use this feature and only retrieve the relevant subset for a particular page.
This implies sending the offset, limit and related information. Changes go as far as data access layer.

Implement the registration page that uses the creative-tim templates and components. The page should match the overall look & feel of the application.

Implement what is missing in the Articles List page. The page exists but the data access and service layers are not complete.

The "monolith" branch represents the effort to refactor the original service oriented approach into a classic monolith. This decision came after realizing for our use cases there is no need for such architecture. Furthermore, the service oriented approach introduced more complexity in development and deployment and multiple vulnerabilities. For further reading see Bozho's Tech Blog.

When saving words containing umlauts in the database, they aren't stored properly.
Investigate and fix this problem.
Reproduce by saving or editing an article using Romanian.

Investigate possible caching solutions that we could use to increase the application's performance.
For instance, such caching implementations could be Hazelcast or Ehcache.

The articles shouldn't be actually deleted but marked as deleted. Therefore a flag is needed in the ARTICLE table. This flag should be checked before displaying the article or any other action against it.

As suggested by Google (https://webmasters.googleblog.com/2015/12/indexing-https-pages-by-default.html), we should serve the pages via HTTPS.
Please investigate if it's possible to do that with our current setting and provide a solution.

It would be nice to be able to assign labels to articles.
Please design a solution and implement the mechanism for that: database tables, data access layer, service layer, controller and template for back office management.

Implement the necessary database scripts to support the Spanish language.
Also perform the front end changes to display the Spain flag in the available languages list.

Create an SQL script and store it in a proper place in the repository.
The script should create the database for fast and easy setup of the development environment.
It will be maintained by every contributor who makes changes to the schema.

Add translated motto to article header. See article title.

Use Spring's CookieLocaleResolver instead of the "lang" request parameter.
Nibbler reports pages using this parameter as duplicates, therefore not a good practice.
We could use the suggestions described here: Codingpedia
Make the necessary changes in the WebConfig class, considering the localeResolver() and localeChangeInterceptor() methods.

Create the controller, service methods and template for displaying an article.
This should be generic so that all the articles will be displayed through this controller and the URLs are predictable enough.
Implementation suggestions: Codingpedia

The header is too large. That becomes a problem especially on mobile devices because it takes too much of the screen's height.
Investigate how can we make it narrower or replace it with a better alternative.

Rewrite the names of the existing unit test methods as described here: https://dzone.com/articles/anatomy-of-a-good-java-test

Implement the controller, service methods, data access methods and everything front end related for saving user messages coming from the Contact Us form.
Please don't forget unit tests.

We need requirements for implementing a shopping cart. This will be used for delivering free books.
No payment integration is needed, as the products will be given for free. The shipment will be however paid by the customer.

In the home page we need to display a list with the latest articles.
Decide what the layout of the list should look like and how many of them should be displayed.
Decide how to allow the user to see older articles at the bottom of this list.
Implement the basic functionality for the MVP.

Some configuration properties (such as logs location or DB related properties) are currently stored under the web app. These should be placed in a place external to the actual deployment package.
Move these properties in files under Tomcat's lib folder or find a better alternative.

Please implement the mechanism for assigning labels to articles and their representation in the article details page.
For the future it would be nice to be able to filter articles by label.

We need a mechanism that deals with retrieving the tables rows in a sorted manner. This goes hand in hand with pagination, which is described in #22.