Jekyll is a tool that simplifies website creation. It converts text into websites without the need for complex components like databases. This efficiency makes Jekyll both fast and user-friendly. A popular theme for Jekyll websites is “Minimal Mistakes,” known for its appealing design and customizability. This article guides you through customizing templates from “Minimal Mistakes” using the Ruby gem theme.
Begin by referring to Minimal Mistakes - Overriding Theme Defaults for foundational knowledge. Customizing the theme can be approached in two ways:
To replace theme HTML files with personalized versions,
create a _includes folder at your project’s root.
Here, you can craft HTML files named identically to those in the theme.
For instance, to customize the footer, generate _includes/footer.html and insert your unique HTML code.
A practical tip: start by copying the original HTML file from the theme into your project. This acts as a useful reference.
Unsure about file naming? Consult the Minimal Mistakes repository
specifically the _includes folder, or use gem fetch minimal-mistakes-jekyll to download the gem and explore its _includes folder.
In a project of mine, I wanted to augment the existing header with a few HTML lines without replacing the entire header.
This goal was achievable by adhering to a specific naming convention.
Similar to the previous method, create a _includes folder at your project’s root.
Then, inside _includes, make a head directory.
Within this, create custom.html and add your HTML enhancements.
These additions will seamlessly integrate into the website’s existing header.
This method is equally applicable for footer customizations.
Consider this example for organizing the _includes folder:
├── _includes
│ ├── footer.html
│ └── head
│ └── custom.html
├── minimal-mistakes-jekyll-4.24.0
│ ├── checksums.yaml.gz
│ ├── data
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── _data
│ │ │ ├── navigation.yml
│ │ │ └── ui-text.yml
│ │ ├── _includes
│ │ │ ├── analytics-providers
│ │ │ │ ├── custom.html
│ │ │ │ ├── google-gtag.html
│ │ │ │ ├── google-universal.html
│ │ │ │ └── google.html
│ │ │ ├── analytics.html
│ │ │ ├── archive-single.html
│ │ │ ├── author-profile-custom-links.html
│ │ │ ├── author-profile.html
│ │ │ ├── breadcrumbs.html
│ │ │ ├── browser-upgrade.html
│ │ │ ├── category-list.html
│ │ │ ├── comment.html
│ │ │ ├── comments-providers
│ │ │ │ ├── custom.html
│ │ │ │ ├── custom_scripts.html
│ │ │ │ ├── discourse.html
│ │ │ │ ├── disqus.html
│ │ │ │ ├── facebook.html
│ │ │ │ ├── giscus.html
│ │ │ │ ├── scripts.html
│ │ │ │ ├── staticman.html
│ │ │ │ ├── staticman_v2.html
│ │ │ │ └── utterances.html
│ │ │ ├── comments.html
│ │ │ ├── documents-collection.html
│ │ │ ├── feature_row
│ │ │ ├── figure
│ │ │ ├── footer
│ │ │ │ └── custom.html
│ │ │ ├── footer.html
│ │ │ ├── gallery
│ │ │ ├── group-by-array
│ │ │ ├── head
│ │ │ │ └── custom.html
│ │ │ ├── head.html
│ │ │ ├── masthead.html
│ │ │ ├── nav_list
│ │ │ ├── page__date.html
│ │ │ ├── page__hero.html
│ │ │ ├── page__hero_video.html
│ │ │ ├── page__meta.html
│ │ │ ├── page__taxonomy.html
│ │ │ ├── paginator.html
│ │ │ ├── post_pagination.html
│ │ │ ├── posts-category.html
│ │ │ ├── posts-tag.html
│ │ │ ├── scripts.html
│ │ │ ├── search
│ │ │ │ ├── algolia-search-scripts.html
│ │ │ │ ├── google-search-scripts.html
│ │ │ │ ├── lunr-search-scripts.html
│ │ │ │ └── search_form.html
│ │ │ ├── seo.html
│ │ │ ├── sidebar.html
│ │ │ ├── skip-links.html
│ │ │ ├── social-share.html
│ │ │ ├── tag-list.html
│ │ │ ├── toc
│ │ │ ├── toc.html
│ │ │ └── video
│ │ ├── _layouts
│ │ │ ├── archive-taxonomy.html
│ │ │ ├── archive.html
│ │ │ ├── categories.html
│ │ │ ├── category.html
│ │ │ ├── collection.html
│ │ │ ├── compress.html
│ │ │ ├── default.html
│ │ │ ├── home.html
│ │ │ ├── posts.html
│ │ │ ├── search.html
│ │ │ ├── single.html
│ │ │ ├── splash.html
│ │ │ ├── tag.html
│ │ │ └── tags.html
│ │ ├── _sass
│ │ │ ├── minimal-mistakes
│ │ │ │ ├── _animations.scss
│ │ │ │ ├── _archive.scss
│ │ │ │ ├── _base.scss
│ │ │ │ ├── _buttons.scss
│ │ │ │ ├── _footer.scss
│ │ │ │ ├── _forms.scss
│ │ │ │ ├── _masthead.scss
│ │ │ │ ├── _mixins.scss
│ │ │ │ ├── _navigation.scss
│ │ │ │ ├── _notices.scss
│ │ │ │ ├── _page.scss
│ │ │ │ ├── _print.scss
│ │ │ │ ├── _reset.scss
│ │ │ │ ├── _search.scss
│ │ │ │ ├── _sidebar.scss
│ │ │ │ ├── _syntax.scss
│ │ │ │ ├── _tables.scss
│ │ │ │ ├── _utilities.scss
│ │ │ │ ├── _variables.scss
│ │ │ │ ├── skins
│ │ │ │ │ ├── _air.scss
│ │ │ │ │ ├── _aqua.scss
│ │ │ │ │ ├── _contrast.scss
│ │ │ │ │ ├── _dark.scss
│ │ │ │ │ ├── _default.scss
│ │ │ │ │ ├── _dirt.scss
│ │ │ │ │ ├── _mint.scss
│ │ │ │ │ ├── _neon.scss
│ │ │ │ │ ├── _plum.scss
│ │ │ │ │ └── _sunrise.scss
│ │ │ │ └── vendor
│ │ │ │ ├── breakpoint
│ │ │ │ │ ├── _breakpoint.scss
│ │ │ │ │ ├── _context.scss
│ │ │ │ │ ├── _helpers.scss
│ │ │ │ │ ├── _legacy-settings.scss
│ │ │ │ │ ├── _no-query.scss
│ │ │ │ │ ├── _parsers.scss
│ │ │ │ │ ├── _respond-to.scss
│ │ │ │ │ ├── _settings.scss
│ │ │ │ │ └── parsers
│ │ │ │ │ ├── _double.scss
│ │ │ │ │ ├── _query.scss
│ │ │ │ │ ├── _resolution.scss
│ │ │ │ │ ├── _single.scss
│ │ │ │ │ ├── _triple.scss
│ │ │ │ │ ├── double
│ │ │ │ │ │ ├── _default-pair.scss
│ │ │ │ │ │ ├── _default.scss
│ │ │ │ │ │ └── _double-string.scss
│ │ │ │ │ ├── resolution
│ │ │ │ │ │ └── _resolution.scss
│ │ │ │ │ ├── single
│ │ │ │ │ │ └── _default.scss
│ │ │ │ │ └── triple
│ │ │ │ │ └── _default.scss
│ │ │ │ ├── magnific-popup
│ │ │ │ │ ├── _magnific-popup.scss
│ │ │ │ │ └── _settings.scss
│ │ │ │ └── susy
│ │ │ │ ├── _su.scss
│ │ │ │ ├── _susy-prefix.scss
│ │ │ │ ├── _susy.scss
│ │ │ │ ├── plugins
│ │ │ │ │ ├── _svg-grid.scss
│ │ │ │ │ └── svg-grid
│ │ │ │ │ ├── _prefix.scss
│ │ │ │ │ ├── _svg-api.scss
│ │ │ │ │ ├── _svg-grid-math.scss
│ │ │ │ │ ├── _svg-settings.scss
│ │ │ │ │ ├── _svg-unprefix.scss
│ │ │ │ │ └── _svg-utilities.scss
│ │ │ │ └── susy
│ │ │ │ ├── _api.scss
│ │ │ │ ├── _normalize.scss
│ │ │ │ ├── _parse.scss
│ │ │ │ ├── _settings.scss
│ │ │ │ ├── _su-math.scss
│ │ │ │ ├── _su-validate.scss
│ │ │ │ ├── _syntax-helpers.scss
│ │ │ │ ├── _unprefix.scss
│ │ │ │ └── _utilities.scss
│ │ │ └── minimal-mistakes.scss
│ │ └── assets
│ │ ├── css
│ │ │ └── main.scss
│ │ └── js
│ │ ├── _main.js
│ │ ├── lunr
│ │ │ ├── lunr-en.js
│ │ │ ├── lunr-gr.js
│ │ │ ├── lunr-store.js
│ │ │ ├── lunr.js
│ │ │ └── lunr.min.js
│ │ ├── main.min.js
│ │ ├── plugins
│ │ │ ├── gumshoe.js
│ │ │ ├── jquery.ba-throttle-debounce.js
│ │ │ ├── jquery.fitvids.js
│ │ │ ├── jquery.greedy-navigation.js
│ │ │ ├── jquery.magnific-popup.js
│ │ │ └── smooth-scroll.js
│ │ └── vendor
│ │ └── jquery
│ │ └── jquery-3.5.1.js
│ ├── data.tar.gz
│ └── metadata.gz
Signing your GitHub commits adds an extra layer of authenticity and integrity to your codebase. In this article, we’ll explore how to sign your commits using your existing SSH key, without the need to create a separate GPG key. However, please note that SSH signature verification requires Git 2.34 or later.
If you haven’t already done so, follow the steps below to add your public key to your GitHub account for authentication and signing purposes: Refer to the GitHub documentation on Adding a new SSH key to your GitHub account and follow the instructions provided.
GitHub also took care of this in the following documentation page Telling Git about your SSH key.
To configure Git to use your SSH key as the signing key, perform the following steps:
gpg.format configuration to “ssh” by executing the following command:
git config --global gpg.format ssh
$HOME/.ssh/ directory, run the following command:
git config --global user.signingkey /PATH/TO/.SSH/KEY.PUB
Note: You can also use the --local flag instead of --global to add the configuration only to a specific repository.
Here’s an example of configuring your system with an SSH key as the signing key:
git config --global gpg.format ssh
git config --global user.signingkey /Users/a418/.ssh/id_rsa.pub
By following the previous steps, your system is now capable of signing commits.
However, the signing process won’t happen automatically—you need to sign each commit explicitly while creating the commit message.
Use the -S flag as shown in the example below:
git commit -S -m "feat: Implemented new version of bad SKYNET"
To configure Git to sign all your commits automatically, eliminating the need for the -S flag each time,
modify the $HOME/.gitconfig file on your system as follows:
[user]
signingKey = /Users/a418/.ssh/id_rsa.pub
[gpg]
format = ssh
[commit]
gpgsign = true
The crucial part is the [commit] section, where the gpgsign property is set to true.
Note: This reflects only the current state as of IntelliJ IDEA 2023.1.2 or earlier.
As of the current IntelliJ IDEA version, there is no built-in UI for configuring commit signing with ssh.
Therefore, to set up the signing key, either configure it per project or follow the global configuration steps mentioned earlier.
IntelliJ IDEA automatically detects the gitconfig settings when committing.
We needed to download a software from Github in its latest release without specifying the version number. This had to be done with curl, so we came up with the following code.
First we have to retrieve all the data about the latest release, which can be easily done by the use of the GitHub API. The URL follows the same scheme:
https://api.github.com/repos/USERNAME/REPO/releases/latest
In our case:
https://api.github.com/repos/felixb/swamp/releases/latest
The result is a JSON file with the description of the release and download links for specific files:
{
"url": "https://api.github.com/repos/felixb/swamp/releases/assets/11040706",
"id": 11040706,
"node_id": "MDEyOlJlbGVhc2VBc3NldDExMDQwNzA2",
"name": "swamp_amd64",
"label": null,
"uploader": {
"login": "felixb",
"id": 192135,
"node_id": "MDQ6VXNlcjE5MjEzNQ==",
"avatar_url": "https://avatars1.githubusercontent.com/u/192135?v=4",
"gravatar_id": "",
"url": "https://api.github.com/users/felixb",
"html_url": "https://github.com/felixb",
"followers_url": "https://api.github.com/users/felixb/followers",
"following_url": "https://api.github.com/users/felixb/following{/other_user}",
"gists_url": "https://api.github.com/users/felixb/gists{/gist_id}",
"starred_url": "https://api.github.com/users/felixb/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/felixb/subscriptions",
"organizations_url": "https://api.github.com/users/felixb/orgs",
"repos_url": "https://api.github.com/users/felixb/repos",
"events_url": "https://api.github.com/users/felixb/events{/privacy}",
"received_events_url": "https://api.github.com/users/felixb/received_events",
"type": "User",
"site_admin": false
},
"content_type": "application/octet-stream",
"state": "uploaded",
"size": 11765256,
"download_count": 916,
"created_at": "2019-02-12T06:39:41Z",
"updated_at": "2019-02-12T06:39:49Z",
"browser_download_url": "https://github.com/felixb/swamp/releases/download/v0.10.0/swamp_amd64"
}
Now we can write our curl command to retrieve the download URL for the Linux version.
DOWNLOAD_URL=$(curl -s https://api.github.com/repos/felixb/swamp/releases/latest \
| grep browser_download_url \
| grep swamp_amd64 \
| cut -d '"' -f 4)
curl -s -L --create-dirs -o ~/downloadDir "$DOWNLOAD_URL"
Note: Replace the repository URL and grep swamp_amd64 with the file you need (grep YOUR_FILE).
When using Postgres.app on MacOS it is quite possible that you will encounter the folling exception:
FATAL: role “postgres” does not exist
As it states you are trying to connect to Postgres with a role unknown to the database. The easies solution for this is to create one. You can achieve this by running the following command:
╭─me@myMachine /Applications/Postgres.app/Contents/Versions/YOUR_VERSION/bin
╰─$ ./createuser -s missingRoleName
With the -s flag you are creating a superuser.
A little background for Postgres.app: When you start the app the first time, it will create a superuser with the current MacOS username in your application.
In my case I migrated my system to a new MacBook and changed my MacOS username.
If you know your old superuser role name, create a new superuser corresponding to your current MacOS username:
╭─me@myMachine /Applications/Postgres.app/Contents/Versions/YOUR_VERSION/bin
╰─$ ./createuser -s missingRoleName --username=OldSuperUserRoleName
In one of my clients projects we were working with Gradle and building the application on the console with gradlew clean build.
On each build Gradle runs all tests and while the application was growing, the amount of tests also increased accordingly.
The application has a few thousand tests and at some point we were receiving OutOfMemoryExceptions with increasing frequency.
After some analyzing we pined down the cause to the - you guessed it - execution of the tests and their low memory.
There are two solutions, which you can use to solve this problem. Booth of them have to be inserted into the test{}-block.
test {
jvmArgs = ['-Xmx2048m']
}
Gradle offers you the possibility to set the heapSize directly by the use of the keyword maxHeapSize.
test {
maxHeapSize = "2048m"
}
Lately I was working on a Micro-service based on Spring Boot. I deployed the Micro-service onto AWS Elastic Beanstalk, like I’ve done it a few hundred times with other apps, but this time the Micro-service was unable to start. Tomcat was giving me the cold shoulder with 404s.
A look into the logs showed me, that the JDBC_CONNECTION_STRING was not set in the environment, even if it was set in the Environment Properties on the configuration page in AWS Elastic Beanstalk.
Analyzing the problem by comparing the version (64bit Amazon Linux 2017.09 v2.7.0 running Tomcat 8 Java 8) - on which the new app was running - against other instances (64bit Amazon Linux 2015.03 v2.0.1 running Tomcat 8 Java 8), revealed that the environment settings are handled differently:
environment variables and were visible for the app.environment variables, but was setting all custom properties as System Properties. Tomcat received them as -DJDBC_CONNECTION_STRING=something.This changes the way on how to retrieve the properties from the server/Tomcat.
The solution - at least for this Spring Boot Micro-service - was to add spring.datasource.url directly into the Environment Properties on the configuration page in AWS Elastic Beanstalk. The title of the settings is misleading at least and judging it by its name and by the many years of use you would not expect this behavior.
After realizing what was happening I searched the docs for some clues. Here is an excerpt:
]]>You can use environment properties to pass secrets, endpoints, debug settings, and other information to your application. Environment properties help you run your application in multiple environments for different purposes, such as development, testing, staging, and production.
Environment Variables
In most cases, environment properties are passed to your application as environment variables, but the behavior is platform dependent. For example, the Java SE platform sets environment variables that you retrieve with System.getenv, while the Tomcat platform sets Java system properties that you retrieve with System.getProperty.
Git offers three possibilities on how you can set your username and email.
The settings will be considered in the following order, where 1. will always override 2. and 2. will override 3..
project - The data is stored directly in the corresponding project(repository) under .git/config.global - for all repositories of the current user. The config file can be found in your home directory ~/.gitconfig.system - This is a system wide configuration and is available for all users and all repositories. You will find it in /etc/gitconfig.In the most cases you will setup a global config for your user and additionally - if you work for example for different companies - you will also setup project specific configurations.
git config user.name "Your project specific name"
git config user.email "your@project-specific-email.com"
Verify your settings:
git config --get user.name
git config --get user.email
git config --global user.name "Your global username"
git config --global user.email "your@email.com"
Verify your settings:
git config --global --get user.name
git config --global --get user.email
This is a case which is usually not needed, but we will list it in any case.
git config --system user.name "Your default name"
git config --system user.email "your@system-email.com"
Verify your settings:
git config --system --get user.name
git config --system --get user.email
Architecture changes over time and sometimes it is not easy to keep the documentation up-to-date. As a result you get an invalid description of your architecture.
One of the hidden gems of Spring Data JPA is the possibility to put your query results directly into a DTO instead of having it transformed by a mapper on a higher level. Of course this depends on the question if you are okay with this way of handling data.
Spring Data itself is an abstraction layer between the way of how you query data and the underlying different data source types. The way how you use Spring Data to write your queries does not change. It will transform the queries into the corresponding underlying query languages for JPA, MongoDB, Couchbase, Neo4j a.s.o..
The special about Spring Data is that it is sufficient to just create interface methods. There is no need of implementing any Repositories or DataAccessObjects.
This is just an example for a JpaRepository showing how Spring Data is working:
package de.smarterco.example.repositories;
import de.smarterco.example.entities.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findAll();
}
The keywords:
@Repository - Marks the class as a repository to get picked up by the dependency framework.JpaRepository - Extends our interface UserRepository by base functionality for the use with JPA datasources.<User, Long> - User is our entity on which this repository will perform its queries. The Long is the type of the id in the User entity.List<User> findAll() - Example of a method, which will retrieve all Users from the repository and store them into a List. Query methods in Spring Data start with the keyword find, followed by restrictions and parameters.There is also another way of how you can achieve the same result using Spring Data JPA.
Spring Data JPA offers you the keyword Query, which allows you to write your own queries with JPQL - Java Persistence Query Language.
package de.smarterco.example.repositories;
import de.smarterco.example.entities.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
@Query("SELECT u FROM User AS u")
List<User> findAll();
}
This paragraph describes how to put results from a query directly into a DTO without mapping the data on a second layer outside of the Repository.
The first thing you will need is a DTO, like in our case our UserNameDTO.
Please note that you will need a constructor accepting all internal variables as parameters.
package de.smarterco.example.dto;
public class UserNameDTO {
private Long id;
private String name;
public UserNameDTO(Long id, String name) {
this.id = id;
this.name = name;
}
public Long getId() {
return id;
}
public String getName() {
return name;
}
}
Storing the data directly into the DTO (explanation below) is done by writing a JPQL query in the JpaRepository:
package de.smarterco.example.repositories;
import de.smarterco.example.dto.UserNameDTO;
import de.smarterco.example.entities.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
@Query("SELECT u FROM User AS u")
List<User> findAll();
@Query("SELECT new de.smarterco.example.dto.UserNameDTO(u.id, u.name) FROM User u WHERE u.name = :name")
List<UserNameDTO> retrieveUsernameAsDTO(@Param("name") String name);
}
List<UserNameDTO> retrieveUsernameAsDTO(...) - This is the new method, which will retrieve the results as a List of UserNameDTOs instead of User.@Param("name") String name - @Param helps the system to recognize the passed parameter and insert it into the query. Here :name.new de.smarterco.example.dto.UserNameDTO(u.id, u.name) - This is where the magic happens. The JPQL query creates a new UserNameDTO by the use of the complete package name and the parameterized constructor created before. The only thing left is to map the necessary User variables(u.id, u.name) onto the DTO.As a developer you get quite often confronted with the setup of a new Java project and some tasks repeat themselves.
One of them is thinking about how you would like to design your entities - if you work with JPA of course 🙂 - and if you would like to create a BaseEntity.
The advantage of a BaseEntity-class is, that it provides all extending classes with - like the name says - base functionality and you don’t need to create the id on each class for itself.
Let’s take a look at some of the keywords in this class:
@MappedSuperclass - By the use of @MappedSuperclass the BaseEntity class will not have a separate representation as table in the database. All fields in this class will be stored in the table of the extending class.public abstract class BaseEntity - Making this class abstract prevents the developers from instantiating an instance of this class. Only extending classes can instantiate an instance.id - The id is annotated with @Id, which marks it as the primary key to identify this entity.@GeneratedValue(strategy = GenerationType.AUTO) - You can specify the generation strategy. GenerationType.AUTO will automatically choose a strategy for you, depending on the underlying database.version - This field is not necessary, but with the @Version annotation you will get Optimistic Locking as addition. When you first instantiate an instance of a extending class, the value of version will be 0. Saving/Updating this object in the database will increment this field by one. Did a change happen while you are trying to persist it into the database, an exception will get thrown.Possible bottleneck @GeneratedValue(strategy = GenerationType.AUTO)
Using @GeneratedValue(strategy = GenerationType.AUTO) can be also a disadvantage, while using it with Postgres or Oracle. This databases do not have autoincremental fields as you know it from MySQL and they will use a sequence. Depending on how you created your database or sequences, it can happen that all your entities will share the same sequence: a possible bottleneck when performing a lot of insert operations.
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;
@MappedSuperclass
public abstract class BaseEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Version
private Long version;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getVersion() {
return version;
}
public void setVersion(Long version) {
this.version = version;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
BaseEntity that = (BaseEntity) o;
return Objects.equals(id, that.id) &&
Objects.equals(version, that.version);
}
@Override
public int hashCode() {
return Objects.hash(id, version);
}
@Override
public String toString() {
return "BaseEntity{" +
"id=" + id +
", version=" + version +
'}';
}
}
While we have seen the BaseEntity class, it is also possible to go further and use additional keywords provided by JPA for our advantage.
The following entity contains additional fields like createdBy, updatedBy, createdAt and updatedAt. The last two are TemporalType, which contain a timestamp.
@PrePersist - This annotation is a marker, which tells the underlying JPA implementation to execute this marked method. In our case it fills the createdAt field with the current time. This method will be executed on the first insert/creation/persist of the entity.@PreUpdate- This annotation is a marker, which tells the underlying JPA implementation to execute this marked method on each update of the entity. In our case it fills the updatedAt field with the current time.import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;
import java.util.Objects;
@MappedSuperclass
public abstract class BaseEntityAudit extends BaseEntity implements Serializable {
private String createdBy;
private String updatedBy;
@Temporal(TemporalType.TIMESTAMP)
private Date createdAt;
@Temporal(TemporalType.TIMESTAMP)
private Date updatedAt;
/**
* Sets createdAt before insert
*/
@PrePersist
public void setCreationDate() {
this.createdAt = new Date();
}
/**
* Sets updatedAt before update
*/
@PreUpdate
public void setChangeDate() {
this.updatedAt = new Date();
}
public Date getCreatedAt() {
return createdAt;
}
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
public Date getUpdatedAt() {
return updatedAt;
}
public void setUpdatedAt(Date updatedAt) {
this.updatedAt = updatedAt;
}
public String getCreatedBy() {
return createdBy;
}
public void setCreatedBy(String createdBy) {
this.createdBy = createdBy;
}
public String getUpdatedBy() {
return updatedBy;
}
public void setUpdatedBy(String updatedBy) {
this.updatedBy = updatedBy;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
BaseEntityAudit that = (BaseEntityAudit) o;
return Objects.equals(createdBy, that.createdBy) &&
Objects.equals(updatedBy, that.updatedBy) &&
Objects.equals(createdAt, that.createdAt) &&
Objects.equals(updatedAt, that.updatedAt);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), createdBy, updatedBy, createdAt, updatedAt);
}
@Override
public String toString() {
return "BaseEntityAudit{" +
"createdBy='" + createdBy + '\'' +
", updatedBy='" + updatedBy + '\'' +
", createdAt=" + createdAt +
", updatedAt=" + updatedAt +
"} " + super.toString();
}
}