grogv3 / grog-cubi

Go to a project
Toggle navigation Toggle navigation pinning
JR Utily
29de9570 1 parent d189a98a

final organisation 

+ full spring boot application for db-generator
Inline Side-by-side
Showing 102 changed files with 2900 additions and 4 deletions
......@@ -28,6 +28,21 @@
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<!--
<version>5.1.6</version>
-->
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.legrog</groupId>
<artifactId>grog-entities</artifactId>
<version>3.0-SNAPSHOT</version>
......@@ -40,6 +55,13 @@
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
......
package org.legrog.entities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DbGeneratorApplication {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(DbGeneratorApplication.class);
logger.info("Create an empty MySQL database - schema/user should already be created, only manage the tables and so.");
logger.info("Needs to now USERNAME, PASSWORD, HOST, PORT and SCHEMA");
logger.info("Usage :");
logger.info(" java -jar target/grog-db-generator-3.0-SNAPSHOT.jar --spring.datasource.username=USERNAME --spring.datasource.password=PASSWORD --spring.datasource.url=\"jdbc:mysql://HOST:PORT/SCHEMA\"");
SpringApplication.run(DbGeneratorApplication.class, args);
}
}
spring:
application.name: grog-db-generator
profiles.active: prod
main:
web-environment: false
banner-mode: off
---
spring:
profiles: prod
datasource:
driverClassName: com.mysql.jdbc.Driver
initialize: false
url: jdbc:mysql://localhost:3306/grogdev
username: grogdev
password: grogdev
jpa:
show-sql: true
generate-ddl: true
hibernate:
ddl-auto: create
---
spring:
profiles: test
datasource:
driverClassName: org.h2.Driver
initialize: true
jpa:
show-sql: true
hibernate:
ddl-auto: create-drop
package org.legrog.entities;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import static org.junit.Assert.*;
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles(profiles = "test")
public class DbGeneratorApplicationTests {
@Autowired
ApplicationContext context;
@Test
public void contextLoads() {
assertNotNull(context);
}
}
package org.legrog.entities;
import javax.persistence.*;
import java.util.*;
// TODO Evaluer l'interet de cet import
//import org.roliste.data.DbValidationEntity;
// TODO Vérifier les extends
/*
Entité persistante représentant un utilisateur.
Migréee depuis la v2.
*/
@Entity
public class Account /* extends org.roliste.data.DbTraceableEntity */ implements DisplayNameConfigurable /*, DbValidationEntity */ {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int userId;
// TODO traiter Traceable
/**
* Retrieve this object's Traceable.
* @hibernate.many-to-one
* column="ID_JOURNALISABLE"
* class="org.roliste.data.db.Traceable"
* access="property"
* lazy="false"
* cascade="all"
* foreign-key="FK_THEME_JOURNALISABLE"
* @return the {@link org.roliste.data.db.Traceable} record corresponding to this object. May be <code>null</code>.
* @see #setTraceable(org.roliste.data.db.Traceable)
*/
/*
public Traceable getTraceable()
{
return _traceRoot;
}
*/
/**
* The mask used for account name.
*/
private DisplayNameMask displayNameMask;
/*
@Override
public String getUrlKey()
{
return "/utilisateurs/" + getScreenName();
}
*/
/**
* @return the account's name as desired. By default, return the complete name.
* see org.roliste.data.db.NameMask#mask(org.roliste.data.DbMaskableEntity)
*/
public String getDisplayName()
{
if (displayNameMask != null)
return displayNameMask.getDisplayName(this);
else
return DisplayNameMask.COMPLET.getDisplayName(this);
}
/**
* Returns the account's name mask.
* @return the mask.
* see #setNameMask(NameMask)
* hibernate.property
* column="MASQUE_NOM_UTILISATEUR"
* access="property"
* length="50"
* hibernate.type
* name="org.roliste.data.util.NameMaskUserType"
*/
public DisplayNameMask getDisplayNameMask() {
return displayNameMask;
}
/**
* Initializes the account's name mask.
* @param mask the new {link org.roliste.data.db.NameMask}.
* see #getNameMask()
*/
public void setDisplayNameMask(DisplayNameMask mask) {
this.displayNameMask = mask;
}
// TODO Faire ailleurs les contrôles de chaîne vide sur : username, password, firstname, lastname, nickname, email, text
/**
* The account identifier.
*/
private String username;
/**
* The account password.
*/
private String password;
/**
* The account first name.
*/
private String firstName;
/**
* The account last name.
*/
private String lastName;
/**
* The account nick name.
*/
private String nickname;
/**
* The account email address.
*/
private String email;
/**
* The {link org.roliste.data.db.AccountRole}s for this account.
*/
@ManyToMany(fetch = FetchType.EAGER)
private List<AccountRole> roles;
/**
* Retrieves the list of {@link AccountRole}s for this account.
* SHALL be used as a read-only attribute. In particular, avoid
* using {@link List#add(Object)} or {@link List#remove(Object)} on
* the returned value without caution.
* @return a {@link List} of {@link AccountRole}. Shall not be <code>null</code>.
* @see #setRoles(List)
* see #addToRole(AccountRole)
* see #removeFromRole(AccountRole)
* hibernate.many-to-many
* column="ROLE_FK"
* class="org.roliste.data.db.AccountRole"
* foreign-key="FK_UTILISATEURROLE_ROLEUTILISATEUR"
* @hibernate.key
* column="UTILISATEUR_FK"
* not-null="true"
* foreign-key="FK_UTILISATEURROLE_UTILISATEUR"
* @hibernate.bag
* cascade="save-update"
* access="property"
* table="role_utilisateur"
* lazy="true"
*/
public List<AccountRole> getRoles() {
return roles;
}
/**
* Lists the list of {@link AccountRole}s for this account.
* @param roles the new {@link List} of {@link AccountRole}s. Shall not be <code>null</code>.
* @throws NullPointerException if roles is <code>null</code>.
* @see #getRoles()
* see #addToRole(AccountRole)
* see #removeFromRole(AccountRole)
*/
public void setRoles(List<AccountRole> roles) {
if (roles == null)
{
throw new NullPointerException("Impossible d'affecter un ensemble nul aux r�les d'un utilisateur");
}
this.roles = roles;
}
/**
* Add the account to a given {@link AccountRole}s.
* @param role the new {@link AccountRole}. Ignored if <code>null</code>.
* @see #getRoles()
* @see #setRoles(List)
* @see #removeFromRole(AccountRole)
*/
/*
public void addToRole(AccountRole role) {
synchronized (this)
{
if ((role != null) && !(getRoles().contains(role)) )
{
role.getAccounts().add(this);
getRoles().add(role);
}
}
}
*/
/**
* Remove the account from a given {@link AccountRole}s.
* @param role the {@link AccountRole} this {@link Account} will lose. Ignored if <code>null</code>.
* @see #getRoles()
* @see #setRoles(List)
* @see #addToRole(AccountRole)
*/
/*
public void removeFromRole(AccountRole role) {
synchronized (this)
{
if ((role != null) && (getRoles().contains(role)) )
{
role.getAccounts().remove(this);
getRoles().remove(role);
}
}
}
*/
/**
* The account anonymous status.
* If anonymous, account cannot be contacted through email.
*/
private boolean anonymous;
/**
* The account validation status.
*/
private boolean visible;
/**
* The account was activated at least once.
*/
private boolean activated;
/**
* The account provides critics for archive.
*/
private boolean criticProvider;
/**
* Presentation text.
*/
@Lob
private String presentation;
/**
* The {@link org.roliste.data.db.BookDetails}s in this account's collection.
*/
// private List<BookDetails> _collection;
/**
* Retrieves the list of {@link org.roliste.data.db.BookDetails}s in this account's collection.
* SHALL be used as a read-only attribute. In particular, avoid using {@link List#add(Object)}
* or {@link List#remove(Object)} on the returned value without caution.
* @return a {@link List} of {@link org.roliste.data.db.BookDetails}. Shall not be <code>null</code>.
* @see #setCollection(List)
* @see #addToCollection(BookDetails)
* @see #removeFromCollection(BookDetails)
* @hibernate.many-to-many
* column="DETAILS_FK"
* class="org.roliste.data.db.BookDetails"
* foreign-key="FK_COLLECTION_DETAIL"
* @hibernate.key
* column="UTILISATEUR_FK"
* not-null="true"
* foreign-key="FK_COLLECTION_UTILISATEUR"
* @hibernate.bag
* access="property"
* table="collection"
* lazy="true"
*/
/*
public List<BookDetails> getCollection() {
return _collection;
}
*/
/**
* Lists the list of {@link org.roliste.data.db.BookDetails}s in this account's collection.
* @param collec the new {@link List} of {@link org.roliste.data.db.BookDetails}s. Shall not be <code>null</code>.
* @throws NullPointerException if collec is <code>null</code>.
* @see #getCollection()
* @see #addToCollection(BookDetails)
* @see #removeFromCollection(BookDetails)
*/
/*
public void setCollection(List<BookDetails> collec) {
if (collec == null)
{
throw new NullPointerException("Impossible d'affecter un ensemble nul pour la collection d'un utilisateur");
}
_collection = collec;
}
*/
/**
* Add a book to the account's collection.
* @param book the new {@link org.roliste.data.db.BookDetails}. Ignored if <code>null</code>.
* @see #getCollection()
* @see #setCollection(List)
* @see #removeFromCollection(BookDetails)
*/
/*
public void addToCollection(BookDetails book) {
synchronized (this)
{
if ((book != null) && !(getCollection().contains(book)) )
{
book.getOwners().add(this);
getCollection().add(book);
}
}
}
*/
/**
* Remove a book from account's collection.
* @param book the {@link org.roliste.data.db.BookDetails} this {@link Account} will lose. Ignored if <code>null</code>.
* @see #getCollection()
* @see #setCollection(List)
* @see #addToCollection(BookDetails)
*/
/*
public void removeFromCollection(BookDetails book) {
synchronized (this)
{
if ((book != null) && (getCollection().contains(book)) )
{
book.getOwners().remove(this);
getCollection().remove(book);
}
}
}
*/
/**
* The {@link org.roliste.data.db.Traceable}s delegated to this account.
*/
// private List<Traceable> _delegations;
/**
* Retrieves the list of delegations for this account.
* Each delegation is a link to a {@link org.roliste.data.db.Traceable} object.
* A account having delegation may update field values for delegated object.
* @return a {@link List} of {@link AccountRole}. Shall not be <code>null</code>. SHALL be used as a
* read-only attribute. In particular, avoid using {@link List#add(Object)} or {@link List#remove(Object)}
* on the returned value without caution.
* @see #setDelegations(List)
* @see #giveDelegation(Traceable)
* @see #removeDelegation(Traceable)
* @hibernate.many-to-many
* column="ID_JOURNALISABLE"
* class="org.roliste.data.db.Traceable"
* foreign-key="FK_DELEGATION_JOURNALISABLE"
* @hibernate.key
* column="ID_UTILISATEUR"
* not-null="true"
* foreign-key="FK_DELEGATION_UTILISATEUR"
* @hibernate.bag
* cascade="save-update"
* access="property"
* table="delegation_utilisateur"
* lazy="true"
*/
/*
public List<Traceable> getDelegations() {
return _delegations;
}
*/
/**
* Sets the list of delegations for this account.
* @param objects the new {@link List} of delegated {@link Traceable}. Shall not be <code>null</code>.
* @throws NullPointerException if objects is <code>null</code>.
* @see #getDelegations()
* @see #giveDelegation(Traceable)
* @see #removeDelegation(Traceable)
*/
/*
public void setDelegations(List<Traceable> objects) {
if (_delegations == null)
{
throw new NullPointerException("Impossible d'affecter un ensemble nul aux d�l�gations d'un utilisateur");
}
_delegations = objects;
}
*/
/**
* Give delegation on a given {@link Traceable} to this account.
* @param object the new delegation. Ignored if <code>null</code>.
* @see #getDelegations()
* @see #setDelegations(List)
* @see #removeDelegation(Traceable)
*/
/*
public void giveDelegation(Traceable object) {
synchronized (this)
{
if ((object != null) && !(getDelegations().contains(object)) )
{
object.getDelegates().add(this);
getDelegations().add(object);
}
}
}
*/
/**
* Remove delegation on a given {@link Traceable} from this account.
* @param object the delegation this {@link Account} will lose. Ignored if <code>null</code>.
* @see #getDelegations()
* @see #setDelegations(List)
* @see #giveDelegation(Traceable)
*/
/*
public void removeDelegation(Traceable object) {
synchronized (this)
{
if ((object != null) && (getDelegations().contains(object)) )
{
object.getDelegates().remove(this);
getDelegations().remove(object);
}
}
}
*/
/**
* Clear all delegations for this account.
*/
/*
public void clearDelegations()
{
synchronized (this)
{
for (Traceable root : getDelegations())
{
root.getDelegates().remove(this);
}
getDelegations().clear();
}
}
*/
/**
* The list of attributes / properties for this account.
*/
@OneToMany(mappedBy = "account")
private List<AccountAttribute> accountAttributes;
/**
* Retrieve this account's attributes.
* @hibernate.one-to-many
* class="org.roliste.data.db.AccountAttribute"
* @hibernate.bag
* cascade="all"
* lazy="true"
* inverse="true"
* @hibernate.key
* column="ID_UTILISATEUR"
* @return a {@link java.util.List} of account attributes linked to this. Shall not be <code>null</code>.
* @see #setAttributes(java.util.List)
*/
public List<AccountAttribute> getAttributes()
{
return accountAttributes;
}
/**
* @param attribs the List of attributes for this account.
* @see #getAttributes()
*/
public void setAttributes(List<AccountAttribute> attribs)
{
this.accountAttributes = attribs;
}
/**
* The {@link org.roliste.data.db.GamingEvent}s this account's visited.
*/
// private Set<GamingEvent> _visitedEvents = new HashSet<GamingEvent>();
/**
* Retrieves the list of {@link GamingEvent}s visited by this account.
* SHALL be used as a read-only attribute. In particular, avoid
* using {@link Set#add(Object)} or {@link Set#remove(Object)} on
* the returned value without caution.
* @return a {@link Set} of {@link GamingEvent}s. May be <code>null</code>.
* @see #setVisitedEvents(Set)
* @hibernate.many-to-many
* column="MANIF_FK"
* class="org.roliste.data.db.GamingEvent"
* @hibernate.key
* column="UTILISATEUR_FK"
* not-null="true"
* @hibernate.set
* access="property"
* table="manif_utilisateur"
* inverse="true"
* lazy="true"
*/
/*
public Set<GamingEvent> getVisitedEvents() {
return _visitedEvents;
}
*/
/**
* Sets the list of {link GamingEvent}s for this account.
* param events the new {@link Set} of {link GamingEvent}s. May be
* <code>null</code> (we don't handle the relation from this side).
* see #getVisitedEvents()
*/
/*
protected void setVisitedEvents(Set<GamingEvent> events) {
_visitedEvents = events;
}
*/
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
/**
* Returns the account identifier.
* @return the {@link String} identifier.
* @see #setUsername(String)
* hibernate.property
* column="LOGIN_UTILISATEUR"
* not-null="true"
* unique="true"
* access="property"
* length="50"
*/
public String getUsername() {
return username;
}
/**
* Initializes the account identifier.
* @param name the new {@link String} identifier.
* @see #getUsername()
*/
public void setUsername(String name) {
this.username = name;
}
/**
* Returns the account password.
* @return the {@link String} password.
* @see #setPassword(String)
* hibernate.property
* column="PASS_UTILISATEUR"
* not-null="true"
* access="property"
* length="50"
*/
public String getPassword() {
return password;
}
/**
* Initializes the account password.
* @param pwd the new {@link String} password.
* @see #getPassword()
*/
public void setPassword(String pwd) {
this.password = pwd;
}
/**
* Returns the account full first name.
* @return the {@link String} first name.
* @see #setFirstName(String)
* hibernate.property
* column="PRENOM_UTILISATEUR"
* not-null="true"
* access="property"
* length="50"
*/
public String getFirstName() {
return firstName;
}
/**
* Initializes the account first name.
* @param name the new {@link String} first name.
* @see #getFirstName()
*/
public void setFirstName(String name) {
this.firstName = name;
}
/**
* Returns the account full last name.
* @return the {@link String} last name.
* @see #setLastName(String)
* hibernate.property
* column="NOM_UTILISATEUR"
* not-null="true"
* access="property"
* length="50"
*/
public String getLastName() {
return lastName;
}
/**
* Initializes the account last name.
* @param name the new {@link String} last name.
* @see #getLastName()
*/
public void setLastName(String name) {
this.lastName = name;
}
/**
* Returns the account full screen name.
* @return the {@link String} screen name.
* @see #setNickName(String)
* hibernate.property
* column="PSEUDO_UTILISATEUR"
* access="property"
* length="50"
*/
public String getNickName() {
return nickname;
}
/**
* Initializes the account screen name.
* @param name the new {@link String} screen name.
* @see #getNickName()
*/
public void setNickName(String name) {
this.nickname = name;
}
/**
* Returns the account email.
* @return the {@link String} email.
* @see #setEmail(String)
* hibernate.property
* column="EMAIL_UTILISATEUR"
* unique="true"
* not-null="true"
* access="property"
* length="100"
*/
public String getEmail() {
return email;
}
/**
* Initializes the account email.
* @param address the new {@link String} email.
* @see #getEmail()
*/
public void setEmail(String address) {
this.email = address;
}
/**
* Indicates if the account is anonymous.
* Anonymous users' email and first/last name won't be shown.
* @return the anonymous flag.
* @see #setAnonymous(boolean)
* hibernate.property
* column="IND_ANONYME"
* access="property"
*/
public boolean isAnonymous() {
return anonymous;
}
/**
* Initializes the account anonymous flag.
* @param anonymous the new flag value.
* @see #isAnonymous
*/
public void setAnonymous(boolean anonymous) {
this.anonymous = anonymous;
}
/**
* hibernate.property
* column="IND_VISIBLE"
* access="property"
*/
public boolean isVisible() {
// WARNING: Method documentation copied from DbValidationEntity
return visible;
}
public void setVisible(boolean visible) {
// WARNING: Method documentation copied from DbValidationEntity
this.visible = visible;
}
/**
* Indicates if the account was activated at least once.
* @return the activation flag.
* @see #setCriticProvider(boolean)
* hibernate.property
* column="IND_ACTIVE"
* access="property"
*/
public boolean isActivated() {
return activated;
}
/**
* Initializes the account activation flag.
* @param active the new flag value.
* @see #isActivated
*/
public void setActivated(boolean active) {
this.activated = active;
}
/**
* Indicates if the account provides critics for archives.
* @return the critics provider flag.
* @see #setCriticProvider(boolean)
* hibernate.property
* column="IND_CRITIQUES"
* access="property"
*/
public boolean isCriticProvider() {
return criticProvider;
}
/**
* Initializes the critics provider flag.
* @param flag the new flag value.
* @see #isCriticProvider
*/
public void setCriticProvider(boolean flag) {
this.criticProvider = flag;
}
/**
* Returns the HTML text presentation for this account.
* @return the {@link String} HTML text.
* @see #setPresentation(String)
* hibernate.property
* column="PRESENTATION"
* access="property"
* type="text"
* length="2147483647"
*/
public String getPresentation() {
return presentation;
}
/**
* Initializes the HTML text presentation.
* @param presentation the new {@link String} HTML text.
* @see #getPresentation()
*/
public void setPresentation(String presentation) {
this.presentation = presentation;
}
/**
* The account submission date.
*/
private Date creationDate;
/**
* Returns this object creation {@link Date}.
* @return the object creation {@link Date}.
* @see #setCreationDate(Date)
* hibernate.property
* column="DATE_ENREGISTREMENT"
* access="property"
*/
public Date getCreationDate() {
return creationDate;
}
/**
* Initializes the object creation {@link Date}.
* @param date the new object creation {@link Date}.
* @see #getCreationDate()
*/
public void setCreationDate(Date date) {
this.creationDate = date;
}
@Override
public String toString()
{
return "ID_UTILISATEUR=" + userId + " LOGIN_UTILISATEUR=" + username + " EMAIL_UTILISATEUR=" + email +
" PRENOM_UTILISATEUR=" + firstName + " NOM_UTILISATEUR=" + lastName + " PSEUDO_UTILISATEUR=" + nickname;
}
}
\ No newline at end of file
package org.legrog.entities;
import javax.persistence.*;
/*
Entité persistante représentant les propriétés qui sont paramétrées pour un utilisateur.
Migréee depuis la v2.
*/
@Entity
public class AccountAttribute {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int userAttributeId;
public int getUserAttributeId() {
return userAttributeId;
}
/**
* The linked account.
*/
@ManyToOne
private Account account;
/**
* Retrieve the account this attribute is attached to.
* hibernate.many-to-one
* column="ID_UTILISATEUR"
* class="org.roliste.data.db.Account"
* not-null="true"
* access="property"
* lazy="proxy"
* properties-name="PropertyPerUser"
* foreign-key="FK_ATTRIBUTUTILISATEUR_UTILISATEUR"
* @return the {link org.roliste.data.db.Account} this attribute is attached to.
* Shall not be <code>null</code>.
* see #setAccount(org.roliste.data.db.Account)
*/
public Account getAccount() {
return account;
}
/**
* Set the account this attribute is attached to.
* @param account the new {link org.roliste.data.db.Account} this attribute will be attached to. Shall not be <code>null</code>.
* @see #getAccount()
*/
public void setAccount(Account account) {
this.account = account;
}
/**
* The linked property.
*/
@ManyToOne
private AccountProperty accountProperty;
/**
* Retrieve the property this attribute is attached to.
* hibernate.many-to-one
* column="ID_PROP"
* class="org.roliste.data.db.AccountProperty"
* not-null="true"
* access="property"
* lazy="false"
* properties-name="PropertyPerUser"
* foreign-key="FK_ATTRIBUTUTILISATEUR_PROPRIETE"
* @return the {link org.roliste.data.db.AccountProperty} this attribute is attached to.
* Shall not be <code>null</code>.
* see #setProperty(org.roliste.data.db.AccountProperty)
*/
public AccountProperty getProperty() {
return accountProperty;
}
/**
* Set the property this attribute is attached to.
* @param prop the new {link org.roliste.data.db.AccountProperty} this attribute will be attached to. Shall not be <code>null</code>.
* @see #getProperty()
*/
public void setProperty(AccountProperty prop) {
accountProperty = prop;
}
/**
* The property value.
*/
private String value;
/**
* Returns the property value.
* @return the {@link String} value. If property is known to be some other kind of value, you shall
* convert it yourself. May be <code>null</code>, in cases where the sole existence of the attribute
* is the value, or for unset attributes.
* @see #setValue(String)
* hibernate.property
* column="ATTR_VALUE"
* access="property"
* length="200"
*/
public String getValue() {
return value;
}
/**
* Initializes attribute value.
* @param value the new {@link String} value.
* @see #getValue()
*/
public void setValue(String value) {
this.value = value;
}
/**
* Returns a string representation of this account attribute definition.
* @return a string representing this account attribute definition.
* hidden
*/
@Override
public String toString()
{
return "ID_ATTR=" + getUserAttributeId() + " ATTR_PROP=" + accountProperty + " ATTR_VALUE=" + value;
}
}
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AccountAttributeRepository extends JpaRepository<AccountAttribute, Integer> {
}
package org.legrog.entities;
import javax.persistence.*;
/*
Entité persistente représentant la codification des propriétés qui peuvent être paramétrées pour un utilisateur.
Importée depuis la v2.
*/
@Entity
public class AccountProperty {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY) /* Permet la population */
private int userPropertyId;
/**
*
* hibernate.id
* generator-class="identity"
* column="ID_PROP"
* access="property"
*/
public Integer getUserPropertyId() {
return userPropertyId;
}
/**
* The property name.
*/
private String name;
/**
* Returns the property name.
* @return the {@link String} attribute identifier.
* @see #setName(String)
* hibernate.property
* column="ATTR_NAME"
* not-null="true"
* unique="true"
* access="property"
* length="50"
*/
public String getName() {
return name;
}
/**
* Initializes the property name.
* @param name the new {@link String} identifier.
* @see #getName()
*/
public void setName(String name) {
this.name = name;
}
/**
* The property tag.
*/
private String tag;
/**
* Returns the property tag.
* @return the {@link String} value.
* @see #setTag(String)
* hibernate.property
* column="PROP_TAG"
* access="property"
* length="100"
*/
public String getTag() {
return tag;
}
/**
* Initializes property tag.
* @param tag the new {@link String} tag.
* @see #getTag()
*/
public void setTag(String tag) {
this.tag = tag;
}
/**
* The property validation status.
* A property may be temporarily deactivated.
*/
private boolean visible;
/**
* Indicates if the property is visible / usable.
* If not, users should not be able to access the privileges
* they inherit from having this property set.
* @return the visible flag.
* @see #setVisible(boolean)
* hibernate.property
* column="IND_VISIBLE"
* access="property"
*/
public boolean isVisible() {
return visible;
}
/**
* Initializes the property visible flag.
* @param visible the new flag value.
* @see #isVisible
*/
public void setVisible(boolean visible) {
this.visible = visible;
}
/**
* Returns a string representation of this property definition.
* @return a string representing this property definition.
* hidden
*/
@Override
public String toString()
{
return "ID_PROP=" + getUserPropertyId() + "PROP_NAME=" + name + " PROP_TAG=" + tag + " IND_VISIBLE=" + visible;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AccountPropertyRepository extends JpaRepository<AccountProperty, Integer> {
}
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface AccountRepository extends JpaRepository<Account, Integer> {
/**
*
* @param integers list of Ids for the Accounts we're looking for
* @return Accounts looked for
*/
List<Account> findByUserIdIn(List<Integer> integers);
/**
*
* @return accounts that have a presentation
*/
List<Account> findByPresentationIsNotNull();
}
package org.legrog.entities;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.*;
/**
* The database representation of a account role or group.
* A given {@link Account} may be part of one or more {@link AccountRole}.
* <br/>
* Warning: due to laziness of mapped objects, private attributes of all DB entities shall never be used directly.
* You shall always use the getter/setter methods.
* alias AccountRole
*
*/
/*
Importé depuis la v2.
*/
@Entity
// TODO évaluer extend v2
public class AccountRole /* extends org.roliste.data.DbEntity */
{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int userRoleId;
/**
* The role identifier.
*/
private String rolename;
/**
* The {@link Account}s for this account role.
*/
@ManyToMany(mappedBy = "roles")
private Set<Account> accounts;
/**
* Builds a new and empty account role definition.
* All attributes are set to their default value.
* <br/>
* Needed by Hibernate for Java reflection.
*/
public AccountRole() {
super();
rolename = null;
visible = true;
// no need to synchronize this
accounts = new HashSet<Account>();
}
public int getUserRoleId() {
return userRoleId;
}
public void setUserRoleId(int userRoleId) {
this.userRoleId = userRoleId;
}
/**
* Returns the role identifier.
* @return the {@link String} identifier.
* @see #setRolename(String)
* hibernate.property
* column="NOM_ROLE"
* not-null="true"
* unique="true"
* access="property"
* length="50"
*/
public String getRolename() {
return rolename;
}
/**
* Initializes the role identifier.
* @param name the new {@link String} identifier.
* @see #getRolename()
*/
public void setRolename(String name) {
rolename = name;
}
/**
* The role validation status.
* A role may be temporarily deactivated.
*/
private boolean visible;
/**
* Indicates if the role is visible.
* If not, accounts should not be able to access the privileges
* they inherit from being part of this role.
* @return the visible flag.
* @see #setVisible(boolean)
* hibernate.property
* column="IND_VISIBLE"
* access="property"
*/
public boolean isVisible() {
return visible;
}
/**
* Initializes the account visible flag.
* @param visible the new flag value.
* @see #isVisible
*/
public void setVisible(boolean visible) {
this.visible = visible;
}
/**
* Retrieves the list of {@link Account}s for this account role.
* SHALL be used as a read-only attribute. In particular, avoid
* using {@link Set#add(Object)} or {@link Set#remove(Object)} on
* the returned value without caution.
* @return a {@link Set} of {@link Account}. May be <code>null</code>.
* @see #setAccounts(Set)
* hibernate.many-to-many
* column="UTILISATEUR_FK"
* class="org.roliste.data.db.Person"
* foreign-key="FK_UTILISATEURROLE_UTILISATEUR"
* hibernate.key
* column="ROLE_FK"
* not-null="true"
* foreign-key="FK_UTILISATEURROLE_ROLEUTILISATEUR"
* hibernate.set
* access="property"
* table="role_utilisateur"
* lazy="true"
* inverse="true"
*/
public Set<Account> getAccounts() {
return accounts;
}
/**
* Sets the list of {@link Account}s for this account role.
* @param accounts the new {@link Set} of {@link Account}s. May be
* <code>null</code> (we don't handle the relation from this side).
* @see #getAccounts()
*/
protected void setAccounts(Set<Account> accounts) {
this.accounts = accounts;
}
/**
* Returns a string representation of this account role definition.
* @return a string representing this account role definition.
* hidden
*/
@Override
public String toString() {
return "ID_ROLE=" + getUserRoleId() + " NOM_ROLE=" + rolename + " IND_VISIBLE=" + visible;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AccountRoleRepository extends JpaRepository<AccountRole, Integer> {
}
\ No newline at end of file
package org.legrog.entities;
import java.util.List;
/**
* Search interface for IndexedAccount
*/
public interface AccountSearchRepository {
/**
*
* @param string String searched in indexed Accounts
* @return Accounts that match the string
*/
List<IndexedAccount> search(String string) throws SearchingException;
/**
*
* @param indexedAccounts IndexedAccounts to reindex
*/
public void reindex(List<IndexedAccount> indexedAccounts) throws IndexingException;
}
package org.legrog.entities;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.enterprise.inject.Default;
import javax.inject.Inject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Implementation of AccountSearchRepository using SolrJ
*/
@Default
public class AccountSearchRepositorySolrj implements AccountSearchRepository {
Logger logger = LoggerFactory.getLogger(getClass());
SolrClient solrClient;
protected static String collectionName = "accounts";
@Inject
AccountSearchRepositorySolrj(SolrClient solrClient) {
this.solrClient = solrClient;
}
//no args constructor to make it proxyable
AccountSearchRepositorySolrj() {
}
@Override
public List<IndexedAccount> search(String string) throws SearchingException {
SolrQuery solrQuery = new SolrQuery(string);
QueryResponse queryResponse;
try {
queryResponse = solrClient.query(collectionName, solrQuery);
} catch (IOException ioe) {
throw new SearchingException(ioe);
} catch (SolrServerException sse) {
logger.error("SolrServerException {}", sse);
throw new SearchingException(sse.getRootCause());
}
if (queryResponse != null) {
return queryResponse.getBeans(IndexedAccount.class);
} else {
return new ArrayList<>();
}
}
@Override
public void reindex(List<IndexedAccount> indexedAccounts) throws IndexingException {
try {
UpdateResponse updateResponse = solrClient.addBeans(collectionName, indexedAccounts);
solrClient.commit(collectionName);
logger.trace("reindex indexedAccounts SolrJ UpdateResponse {}", updateResponse);
} catch (IOException ioe) {
throw new IndexingException(ioe);
} catch (SolrServerException sse) {
logger.error("SolrServerException {}", sse);
throw new IndexingException(sse.getRootCause());
}
}
}
package org.legrog.entities;
/**
* Available actions are an enumeration
*/
public enum ActionType {
VALIDATE;
}
\ No newline at end of file
package org.legrog.entities;
import javax.persistence.*;
/**
* Country persistence entity
* Id and name seem enough
*/
@Entity
public class Country {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer countryId;
private String countryName;
public Integer getCountryId() {
return countryId;
}
public void setCountryId(Integer countryId) {
this.countryId = countryId;
}
public String getCountryName() {
return countryName;
}
public void setCountryName(String countryName) {
this.countryName = countryName;
}
@Override
public String toString()
{
return "ID_PAYS=" + countryId + " LIB_PAYS=" + countryName;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
public interface CountryRepository extends JpaRepository<Country, Integer> {
}
package org.legrog.entities;
/* DbMaskableEntity en v2, mais je pense le nouveau nom plus clair */
public interface DisplayNameConfigurable {
String getFirstName();
String getLastName();
String getNickName();
/* ScreenName en v2, mais je pense la nouveau nom plus clair */
String getDisplayName();
}
package org.legrog.entities;
/**
* This enumeration provide options for name masking of authors and users.
* Every {link org.roliste.data.DbMaskableEntity} provide first name, last name and nickname
* capabilities, that may be "masked", thus shown in some specific way depending on chosen
* NameMask.
*/
/*
v3 {@link org.legrog.entities.DisplayNameConfigurable}
*/
public enum DisplayNameMask
{
PRENOMNOM("Prénom Nom")
{
public String listMask(DisplayNameConfigurable person)
{
return NOMPRENOM.getDisplayName(person);
}
public String getDisplayName(DisplayNameConfigurable person)
{
StringBuilder sb = new StringBuilder();
if (person.getFirstName() != null)
{
sb.append(person.getFirstName());
}
if (person.getLastName() != null)
{
sb.append(' ');
sb.append(person.getLastName());
}
return sb.toString();
}
},
NOMPRENOM("Nom, Prénom")
{
public String listMask(DisplayNameConfigurable person)
{
return NOMPRENOM.getDisplayName(person);
}
public String getDisplayName(DisplayNameConfigurable person)
{
StringBuilder sb = new StringBuilder();
if (person.getLastName() != null)
{
sb.append(person.getLastName());
if (person.getFirstName() != null)
{
sb.append(", ");
sb.append(person.getFirstName());
}
}
else
{
sb.append("!Pas de nom");
}
return sb.toString();
}
},
PSEUDO("Pseudo")
{
public String listMask(DisplayNameConfigurable person)
{
return PSEUDO.getDisplayName(person);
}
public String getDisplayName(DisplayNameConfigurable person)
{
StringBuilder sb = new StringBuilder();
if (person.getNickName() != null)
{
sb.append(person.getNickName());
}
else
{
sb.append("!Pas de pseudo");
}
return sb.toString();
}
},
COMPLET("Prénom 'Pseudo' Nom")
{
public String listMask(DisplayNameConfigurable person)
{
return NOMPRENOM.getDisplayName(person);
}
public String getDisplayName(DisplayNameConfigurable person)
{
StringBuilder myResult = new StringBuilder();
if (person.getFirstName() != null)
{
myResult.append(person.getFirstName());
myResult.append(' ');
}
if ( person.getNickName() != null )
{
myResult.append('\'');
myResult.append(person.getNickName());
myResult.append('\'');
myResult.append(' ');
}
if (person.getLastName() != null)
{
myResult.append(person.getLastName());
}
return myResult.toString();
}
};
private final String symbol;
DisplayNameMask(String symbol) {
this.symbol = symbol;
}
public String getSymbol()
{
return symbol;
}
public String toString()
{
return symbol;
}
public abstract String getDisplayName(DisplayNameConfigurable person);
public abstract String listMask(DisplayNameConfigurable person);
}
\ No newline at end of file
package org.legrog.entities;
import org.apache.solr.client.solrj.beans.Field;
import javax.persistence.Id;
import javax.persistence.Lob;
/**
* Simplified class for searching indexed Accounts
*/
public class IndexedAccount {
@Id
@Field
private Integer userId;
@Lob
@Field
private String presentation;
/**
*
* @param account Account to be simplified as IndexedAccount
*/
public IndexedAccount(Account account) {
this.userId = account.getUserId();
this.presentation = account.getPresentation();
}
public IndexedAccount() {
//no args constructor to make it proxyable
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getPresentation() {
return presentation;
}
public void setPresentation(String presentation) {
this.presentation = presentation;
}
}
package org.legrog.entities;
import org.apache.solr.client.solrj.beans.Field;
import javax.persistence.Id;
import javax.persistence.Lob;
/**
* Simplified class for indexing and searching validated publishers: content from PublisherVersion with id from Publisher
*/
public class IndexedPublisher {
@Id
@Field
private Integer publisherId;
@Field
private String publisherName;
@Lob
@Field
private String publisherHistory;
/**
* Extracts data needed for indexing from Publisher and its validated PublisherVersion
*
* @param publisher Publisher we want to be indexed
*/
public IndexedPublisher(Publisher publisher) {
PublisherVersion publisherVersion = publisher.getValidatedVersion();
this.publisherId = publisher.getPublisherId();
this.publisherName = publisherVersion.getPublisherName();
this.publisherHistory = publisherVersion.getPublisherHistory();
}
public IndexedPublisher() {
//no args constructor to make it proxyable
}
public Integer getPublisherId() {
return publisherId;
}
public String getPublisherName() {
return publisherName;
}
public String getPublisherHistory() {
return publisherHistory;
}
public void setPublisherId(Integer publisherId) {
this.publisherId = publisherId;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public void setPublisherHistory(String publisherHistory) {
this.publisherHistory = publisherHistory;
}
}
\ No newline at end of file
package org.legrog.entities;
/**
* Exception when indexing fails, whatever the reason. Has to be dealt with at service level.
*/
public class IndexingException extends Exception {
public IndexingException() {
super();
}
public IndexingException(String message) {
super(message);
}
public IndexingException(String message, Throwable cause) {
super(message, cause);
}
public IndexingException(Throwable cause) {
super(cause);
}
protected IndexingException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
package org.legrog.entities;
import javax.persistence.*;
import java.util.Set;
/**
* Persisted entity for a publisher
* Has versions of type PublisherVersion
* May have a validated PublisherVersion among those
* Has access to PublisherAction related to it
*/
@Entity
public class Publisher /* extends org.roliste.data.DbLinkableEntity */ {
// TODO L'éventuel usage de Linkable reste à confirmer https://tree.taiga.io/project/jr-utily-grog-v3/us/48
// TODO Attention, en v2 Linkable implique Traceable (journalisable) qui devrait aussi être évalué
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer publisherId;
@OneToOne
private PublisherVersion validatedVersion;
@OneToMany(mappedBy = "publisher", fetch = FetchType.EAGER)
private Set<PublisherVersion> versions;
@OneToMany(mappedBy = "publisher", fetch = FetchType.EAGER)
private Set<PublisherAction> actions;
public Integer getPublisherId() {
return publisherId;
}
public void setPublisherId(Integer publisherId) {
this.publisherId = publisherId;
}
public PublisherVersion getValidatedVersion() {
return validatedVersion;
}
public void setValidatedVersion(PublisherVersion activeVersion) {
this.validatedVersion = activeVersion;
}
public Set<PublisherVersion> getVersions() {
return versions;
}
public void setVersions(Set<PublisherVersion> versions) {
this.versions = versions;
}
public Set<PublisherAction> getActions() {
return actions;
}
public void setActions(Set<PublisherAction> actions) {
this.actions = actions;
}
@Override
public String toString() {
return "PUBLISHER_ID = " + publisherId + ", Validated Version = " + validatedVersion;
}
}
package org.legrog.entities;
import javax.persistence.*;
import java.sql.Timestamp;
/**
* Pesisted entity for actions made on PublisherVersion
*/
@Entity
public class PublisherAction {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer publisherActionId;
@Enumerated
private ActionType actionType;
@ManyToOne
private Account publisherActionActor;
@ManyToOne
private PublisherVersion publisherVersion;
private Timestamp publisherActionDatetime;
// Simplified access instead of going through PublisherVersion
@ManyToOne
private Publisher publisher;
public void setPublisherActionActor(Account publisherActionActor) {
this.publisherActionActor = publisherActionActor;
}
public void setPublisherActionDatetime(Timestamp publisherActionDatetime) {
this.publisherActionDatetime = publisherActionDatetime;
}
public void setActionType(ActionType actionType) {
this.actionType = actionType;
}
public void setPublisherVersion(PublisherVersion publisherVersion) {
this.publisherVersion = publisherVersion;
}
public void setPublisher(Publisher publisher) {
this.publisher = publisher;
}
public ActionType getActionType() {
return actionType;
}
public Account getPublisherActionActor() {
return publisherActionActor;
}
public PublisherVersion getPublisherVersion() {
return publisherVersion;
}
public Timestamp getPublisherActionDatetime() {
return publisherActionDatetime;
}
public Publisher getPublisher() {
return publisher;
}
public Integer getPublisherActionId() {
return publisherActionId;
}
public void setPublisherActionId(Integer publisherActionId) {
this.publisherActionId = publisherActionId;
}
@Override
public String toString() {
return "publisherActionId = " + publisherActionId + ", actionType = " + actionType +
", publisherActionAuthor = " + publisherActionActor + ", publisherVersion = " + publisherVersion +
", publisherActionDatetime = " + publisherActionDatetime + ", publisher = " + publisher;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
/**
* Interface for accessing PublisherAction
*/
public interface PublisherActionRepository extends JpaRepository<PublisherAction, Integer> {
/**
* Returns last action of a type for a publisher
*
* @param actionType ActionType requested
* @param publisher Publisher concerned by the action
* @return PublisherAction
*/
PublisherAction findFirstByActionTypeAndPublisherOrderByPublisherActionDatetimeDesc(ActionType actionType, Publisher publisher);
/**
* Returns all actions for a PublisherVersion
*
* @param publisherVersion PublisherVersion concerned by the actions
* @return List<PublisherAction>
*/
List<PublisherAction> findByPublisherVersion(PublisherVersion publisherVersion);
}
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface PublisherRepository extends JpaRepository<Publisher, Integer> {
List<Publisher> findByValidatedVersionIsNotNull();
}
package org.legrog.entities;
import java.util.List;
/**
* Indexing/Search interface for IndexedPublisher
*/
public interface PublisherSearchRepository {
/**
* Indexes an IndexedPublisher
*
* @param indexedPublisher IndexedPublisher to be indexed
* @return IndexedPublisher
*/
IndexedPublisher save(IndexedPublisher indexedPublisher) throws IndexingException;
/**
* Searches for IndexedPublishers
*
* @param string String looked for in IndexedPublishers
* @return list of matching IndexedPublishers
*/
List<IndexedPublisher> search(String string) throws SearchingException;
/**
*
* @param inxdexedPublishers IndexedPublishers to reindex
*/
public void reindex(List<IndexedPublisher> inxdexedPublishers) throws IndexingException;
}
package org.legrog.entities;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.enterprise.inject.Default;
import javax.inject.Inject;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Implementation of PublisherSearchRepository using SolrJ
*/
@Default
public class PublisherSearchRepositorySolrj implements PublisherSearchRepository {
Logger logger = LoggerFactory.getLogger(getClass());
SolrClient solrClient;
protected static String collectionName = "publishers";
@Inject
PublisherSearchRepositorySolrj(SolrClient solrClient) {
this.solrClient = solrClient;
}
//no args constructor to make it proxyable
PublisherSearchRepositorySolrj() {
}
@Override
public IndexedPublisher save(IndexedPublisher indexedPublisher) throws IndexingException {
try {
UpdateResponse updateResponse = solrClient.addBean(collectionName, indexedPublisher, 1);
logger.trace("validatePublisherVersion SolrJ UpdateResponse {}", updateResponse);
} catch (IOException ioe) {
throw new IndexingException(ioe);
} catch (SolrServerException sse) {
logger.error("SolrServerException {}", sse);
throw new IndexingException(sse.getRootCause());
}
return indexedPublisher;
}
@Override
public List<IndexedPublisher> search(String string) throws SearchingException {
SolrQuery solrQuery = new SolrQuery(string);
QueryResponse queryResponse;
try {
queryResponse = solrClient.query(collectionName, solrQuery);
} catch (IOException ioe) {
throw new SearchingException(ioe);
} catch (SolrServerException sse) {
logger.error("SolrServerException {}", sse);
throw new SearchingException(sse.getRootCause());
}
if (queryResponse != null) {
return queryResponse.getBeans(IndexedPublisher.class);
} else {
return new ArrayList<>();
}
}
@Override
public void reindex(List<IndexedPublisher> indexedPublishers) throws IndexingException {
try {
UpdateResponse updateResponse = solrClient.addBeans(collectionName, indexedPublishers);
solrClient.commit(collectionName);
logger.trace("reindex inxdexedPublishers SolrJ UpdateResponse {}", updateResponse);
} catch (IOException ioe) {
throw new IndexingException(ioe);
} catch (SolrServerException sse) {
logger.error("SolrServerException {}", sse);
throw new IndexingException(sse.getRootCause());
}
}
}
package org.legrog.entities;
import javax.persistence.*;
import java.sql.Timestamp;
/**
* Persisted entity for a publisher version
* Contains the data
* Postal Address is split according to http://schema.org/PostalAddress
*/
@Entity
public class PublisherVersion {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer publisherVersionId;
@ManyToOne
private Publisher publisher;
private String publisherName;
private String publisherStreetAddress;
private String publisherPostalCode;
private String publisherPostOfficeBoxNumber;
private String publisherAddressRegion;
private String publisherAddressLocality;
@ManyToOne
private Country publisherAddressCountry;
private String publisherTelephone;
private String publisherEmail;
private String publisherURL;
@Lob
private String publisherHistory;
@ManyToOne
private Account publisherVersionCreator;
private Timestamp publisherVersionDatetime;
public Timestamp getPublisherVersionDatetime() {
return publisherVersionDatetime;
}
public void setPublisherVersionDatetime(Timestamp publisherVersionDatetime) {
this.publisherVersionDatetime = publisherVersionDatetime;
}
public String getPublisherHistory() {
return publisherHistory;
}
public void setPublisherHistory(String publisherHistory) {
this.publisherHistory = publisherHistory;
}
public String getPublisherStreetAddress() {
return publisherStreetAddress;
}
public void setPublisherStreetAddress(String publisherStreetAddress) {
this.publisherStreetAddress = publisherStreetAddress;
}
public String getPublisherPostalCode() {
return publisherPostalCode;
}
public void setPublisherPostalCode(String publisherPostalCode) {
this.publisherPostalCode = publisherPostalCode;
}
public String getPublisherPostOfficeBoxNumber() {
return publisherPostOfficeBoxNumber;
}
public void setPublisherPostOfficeBoxNumber(String publisherPostOfficeBoxNumber) {
this.publisherPostOfficeBoxNumber = publisherPostOfficeBoxNumber;
}
public String getPublisherAddressRegion() {
return publisherAddressRegion;
}
public void setPublisherAddressRegion(String publisherAddressRegion) {
this.publisherAddressRegion = publisherAddressRegion;
}
public String getPublisherAddressLocality() {
return publisherAddressLocality;
}
public void setPublisherAddressLocality(String publisherAddressLocality) {
this.publisherAddressLocality = publisherAddressLocality;
}
public String getPublisherTelephone() {
return publisherTelephone;
}
public void setPublisherTelephone(String publisherTelephone) {
this.publisherTelephone = publisherTelephone;
}
public String getPublisherEmail() {
return publisherEmail;
}
public void setPublisherEmail(String publisherEmail) {
this.publisherEmail = publisherEmail;
}
public String getPublisherURL() {
return publisherURL;
}
public void setPublisherURL(String publisherURL) {
this.publisherURL = publisherURL;
}
public Integer getPublisherVersionId() {
return publisherVersionId;
}
public void setPublisherVersionId(Integer publisherVersionId) {
this.publisherVersionId = publisherVersionId;
}
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public Country getPublisherAddressCountry() {
return publisherAddressCountry;
}
public void setPublisherAddressCountry(Country publisherAddressCountry) {
this.publisherAddressCountry = publisherAddressCountry;
}
public Account getPublisherVersionCreator() {
return publisherVersionCreator;
}
public void setPublisherVersionCreator(Account publisherVersionCreator) {
this.publisherVersionCreator = publisherVersionCreator;
}
@Override
public String toString() {
return "PUBLISHER_VERSION_ID = " + publisherVersionId + ", Name = " + publisherName + ", St Address = " +
publisherStreetAddress + ", CP = " + publisherPostalCode + ", BP = " + publisherPostOfficeBoxNumber +
", Region = " + publisherAddressRegion + ", Ville = " + publisherAddressLocality + ", Pays = " +
publisherAddressCountry + ", Telephone = " + publisherTelephone + ", email = " + publisherEmail +
", URL = " + publisherURL + ", History = " + publisherHistory +
", Version Author = " + publisherVersionCreator + ", Version DateTime = " + publisherVersionDatetime;
}
public Publisher getPublisher() {
return publisher;
}
public void setPublisher(Publisher publisher) {
this.publisher = publisher;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface PublisherVersionRepository extends JpaRepository<PublisherVersion, Integer> {
/**
*
* @param integers list of Ids for the PublisherVersions we're looking for
* @return PublisherVersions looked for
*/
List<PublisherVersion> findByPublisherVersionIdIn(List<Integer> integers);
}
package org.legrog.entities;
/**
* Exception when searching fails, whatever the reason. Has to be dealt with at service level.
*/
public class SearchingException extends Exception {
final Throwable rootCause;
SearchingException(Throwable rootCause) {
this.rootCause = rootCause;
}
public Throwable getRootCause() {
return rootCause;
}
}
\ No newline at end of file
package org.legrog.entities;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.beans.BindingException;
import org.apache.solr.common.params.SolrParams;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.legrog.test.MockitoExtension;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Classe testant AccountSearchRepositorySolrj
*/
@RunWith(JUnitPlatform.class)
@ExtendWith(MockitoExtension.class)
@DisplayName("Indexes and searches with SearchRepository")
public class AccountSearchRepositorySolrjTest {
Logger logger = LoggerFactory.getLogger(getClass());
private AccountSearchRepository accountSearchRepository;
private SolrClient solrClient;
@Captor
ArgumentCaptor<SolrParams> solrParamsArgumentCaptor;
@BeforeEach
public void setup(@Mock SolrClient solrClient) {
accountSearchRepository = new AccountSearchRepositorySolrj(solrClient);
this.solrClient = solrClient;
}
@Nested
@DisplayName("search method")
class SearchTests {
@DisplayName("when repository in IO error, should throw a SearchingException")
@Test
public void searchIOETest() throws IOException, SolrServerException{
when(solrClient.query(Mockito.anyString(), Mockito.any())).thenThrow(new IOException());
Assertions.assertThrows(SearchingException.class, () -> accountSearchRepository.search("a"));
}
@DisplayName("when repository in SolrServerException, should throw an SearchingException with its root cause")
@Test
public void searchSSETest() throws SolrServerException, IOException {
when(solrClient.query(Mockito.any())).thenThrow(new SolrServerException(new BindingException("BE test 2")));
try {
accountSearchRepository.search("b");
} catch (SearchingException se) {
logger.error("SearchingException {}", se);
assertThat(se.getRootCause().getClass()).isEqualTo(BindingException.class);
}
}
@DisplayName("when called, it parameter should be embedded in a query sent through SolrClient")
@Test
public void searchParameterTest() throws IOException, SolrServerException {
try {
accountSearchRepository.search("c");
Mockito.verify(solrClient).query(Mockito.anyString(), solrParamsArgumentCaptor.capture());
} catch (SearchingException se) {
logger.error("SearchingException {}", se);
}
SolrQuery solrQuery = (SolrQuery) solrParamsArgumentCaptor.getValue();
assertThat(solrQuery.getQuery()).isEqualTo("c");
}
}
}
package org.legrog.entities;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.beans.BindingException;
import org.apache.solr.common.params.SolrParams;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.legrog.test.MockitoExtension;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Classe testant PublisherSearchRepositorySolrj
*/
@RunWith(JUnitPlatform.class)
@ExtendWith(MockitoExtension.class)
@DisplayName("Indexes and searches with SearchRepository")
public class PublisherSearchRepositorySolrjTest {
Logger logger = LoggerFactory.getLogger(getClass());
private PublisherSearchRepository publisherSearchRepository;
private SolrClient solrClient;
@Captor
ArgumentCaptor<SolrParams> solrParamsArgumentCaptor;
@BeforeEach
public void setup(@Mock SolrClient solrClient) {
publisherSearchRepository = new PublisherSearchRepositorySolrj(solrClient);
this.solrClient = solrClient;
}
@Nested
@DisplayName("save method")
class SaveTests {
@Test
@DisplayName("when called with right parameters, should addBean IndexedPublisher with commitWithinMs of 1 to repository")
public void addBeanTest(@Mock IndexedPublisher indexedPublisher) throws IndexingException, SolrServerException, IOException {
publisherSearchRepository.save(indexedPublisher);
verify(solrClient).addBean(PublisherSearchRepositorySolrj.collectionName, indexedPublisher, 1);
}
@Test
@DisplayName("When repository in IO error, should throw an IndexingException")
public void addBeanIOETest(@Mock IndexedPublisher indexedPublisher) throws SolrServerException, IOException {
when(solrClient.addBean(PublisherSearchRepositorySolrj.collectionName, indexedPublisher, 1)).thenThrow(new IOException());
Assertions.assertThrows(IndexingException.class, () -> publisherSearchRepository.save(indexedPublisher));
}
@Test
@DisplayName("When repository in SolrServerException, should throw an IndexingException with its root cause")
public void addBeanSSETest(@Mock IndexedPublisher indexedPublisher) throws SolrServerException, IOException{
when(solrClient.addBean(indexedPublisher, 1)).thenThrow(new SolrServerException(new BindingException("BE test")));
try {
publisherSearchRepository.save(indexedPublisher);
} catch (IndexingException ie) {
logger.error("IndexingException {}", ie);
assertThat(ie.getCause().getClass()).isEqualTo(BindingException.class);
}
}
}
@Nested
@DisplayName("search method")
class SearchTests {
@DisplayName("when repository in IO error, should throw a SearchingException")
@Test
public void searchIOETest() throws IOException, SolrServerException{
when(solrClient.query(Mockito.anyString(), Mockito.any())).thenThrow(new IOException());
Assertions.assertThrows(SearchingException.class, () -> publisherSearchRepository.search("a"));
}
@DisplayName("when repository in SolrServerException, should throw an SearchingException with its root cause")
@Test
public void searchSSETest() throws SolrServerException, IOException {
when(solrClient.query(Mockito.any())).thenThrow(new SolrServerException(new BindingException("BE test 2")));
try {
publisherSearchRepository.search("b");
} catch (SearchingException se) {
logger.error("SearchingException {}", se);
assertThat(se.getRootCause().getClass()).isEqualTo(BindingException.class);
}
}
@DisplayName("when called, it parameter should be embedded in a query sent through SolrClient")
@Test
public void searchParameterTest() throws IOException, SolrServerException {
try {
publisherSearchRepository.search("c");
Mockito.verify(solrClient).query(Mockito.anyString(), solrParamsArgumentCaptor.capture());
} catch (SearchingException se) {
logger.error("SearchingException {}", se);
}
SolrQuery solrQuery = (SolrQuery) solrParamsArgumentCaptor.getValue();
assertThat(solrQuery.getQuery()).isEqualTo("c");
}
}
}
package org.legrog.test;
/*
TAKEN FROM JUnit 5 Sample
https://github.com/junit-team/junit5-samples/blob/master/junit5-mockito-extension/src/main/java/com/example/mockito/MockitoExtension.java
*/
/*
* Copyright 2015-2016 the original author or authors.
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution and is available at
*
* http://www.eclipse.org/legal/epl-v10.html
*
*/
import static org.mockito.Mockito.mock;
import java.lang.reflect.Parameter;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ExtensionContext.Store;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolver;
import org.junit.jupiter.api.extension.TestInstancePostProcessor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
/**
* {@code MockitoExtension} showcases the {@link TestInstancePostProcessor}
* and {@link ParameterResolver} extension APIs of JUnit 5 by providing
* dependency injection support at the field level and at the method parameter
* level via Mockito 2.x's {@link Mock @Mock} annotation.
*/
public class MockitoExtension implements TestInstancePostProcessor, ParameterResolver {
@Override
public void postProcessTestInstance(Object testInstance, ExtensionContext context) {
MockitoAnnotations.initMocks(testInstance);
}
@Override
public boolean supports(ParameterContext parameterContext, ExtensionContext extensionContext) {
return parameterContext.getParameter().isAnnotationPresent(Mock.class);
}
@Override
public Object resolve(ParameterContext parameterContext, ExtensionContext extensionContext) {
return getMock(parameterContext.getParameter(), extensionContext);
}
private Object getMock(Parameter parameter, ExtensionContext extensionContext) {
Class<?> mockType = parameter.getType();
Store mocks = extensionContext.getStore(Namespace.create(MockitoExtension.class, mockType));
String mockName = getMockName(parameter);
if (mockName != null) {
return mocks.getOrComputeIfAbsent(mockName, key -> mock(mockType, mockName));
} else {
return mocks.getOrComputeIfAbsent(mockType.getCanonicalName(), key -> mock(mockType));
}
}
private String getMockName(Parameter parameter) {
String explicitMockName = parameter.getAnnotation(Mock.class).name().trim();
if (!explicitMockName.isEmpty()) {
return explicitMockName;
} else if (parameter.isNamePresent()) {
return parameter.getName();
}
return null;
}
}
package org.legrog.util;
// Code copied from org.h2.server.web.WebSession
/*
* Copyright 2004-2014 H2 Group. Multiple-Licensed under the MPL 2.0,
* and the EPL 1.0 (http://h2database.com/html/license.html).
* Initial Developer: H2 Group
*/
///package org.h2.server.web;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Locale;
import org.h2.bnf.Bnf;
import org.h2.bnf.context.DbContents;
import org.h2.bnf.context.DbContextRule;
import org.h2.message.DbException;
import org.h2.util.New;
/**
* The web session keeps all data of a user session.
* This class is used by the H2 Console.
*/
class WebSession {
private static final int MAX_HISTORY = 1000;
/**
* The last time this client sent a request.
*/
long lastAccess;
/**
* The session attribute map.
*/
final HashMap<String, Object> map = New.hashMap();
/**
* The current locale.
*/
Locale locale;
/**
* The currently executing statement.
*/
Statement executingStatement;
/**
* The current updatable result set.
*/
ResultSet result;
private final WebServer server;
private final ArrayList<String> commandHistory;
private Connection conn;
private DatabaseMetaData meta;
private DbContents contents = new DbContents();
private Bnf bnf;
private boolean shutdownServerOnDisconnect;
WebSession(WebServer server) {
this.server = server;
// This must be stored in the session rather than in the server.
// Otherwise, one client could allow
// saving history for others (insecure).
this.commandHistory = server.getCommandHistoryList();
}
/**
* Put an attribute value in the map.
*
* @param key the key
* @param value the new value
*/
void put(String key, Object value) {
map.put(key, value);
}
/**
* Get the value for the given key.
*
* @param key the key
* @return the value
*/
Object get(String key) {
if ("sessions".equals(key)) {
return server.getSessions();
}
return map.get(key);
}
/**
* Remove a session attribute from the map.
*
* @param key the key
*/
void remove(String key) {
map.remove(key);
}
/**
* Get the BNF object.
*
* @return the BNF object
*/
Bnf getBnf() {
return bnf;
}
/**
* Load the SQL grammar BNF.
*/
void loadBnf() {
try {
Bnf newBnf = Bnf.getInstance(null);
DbContextRule columnRule =
new DbContextRule(contents, DbContextRule.COLUMN);
DbContextRule newAliasRule =
new DbContextRule(contents, DbContextRule.NEW_TABLE_ALIAS);
DbContextRule aliasRule =
new DbContextRule(contents, DbContextRule.TABLE_ALIAS);
DbContextRule tableRule =
new DbContextRule(contents, DbContextRule.TABLE);
DbContextRule schemaRule =
new DbContextRule(contents, DbContextRule.SCHEMA);
DbContextRule columnAliasRule =
new DbContextRule(contents, DbContextRule.COLUMN_ALIAS);
DbContextRule procedure =
new DbContextRule(contents, DbContextRule.PROCEDURE);
newBnf.updateTopic("procedure", procedure);
newBnf.updateTopic("column_name", columnRule);
newBnf.updateTopic("new_table_alias", newAliasRule);
newBnf.updateTopic("table_alias", aliasRule);
newBnf.updateTopic("column_alias", columnAliasRule);
newBnf.updateTopic("table_name", tableRule);
newBnf.updateTopic("schema_name", schemaRule);
newBnf.linkStatements();
bnf = newBnf;
} catch (Exception e) {
// ok we don't have the bnf
server.traceError(e);
}
}
/**
* Get the SQL statement from history.
*
* @param id the history id
* @return the SQL statement
*/
String getCommand(int id) {
return commandHistory.get(id);
}
/**
* Add a SQL statement to the history.
*
* @param sql the SQL statement
*/
void addCommand(String sql) {
if (sql == null) {
return;
}
sql = sql.trim();
if (sql.length() == 0) {
return;
}
if (commandHistory.size() > MAX_HISTORY) {
commandHistory.remove(0);
}
int idx = commandHistory.indexOf(sql);
if (idx >= 0) {
commandHistory.remove(idx);
}
commandHistory.add(sql);
if (server.isCommandHistoryAllowed()) {
server.saveCommandHistoryList(commandHistory);
}
}
/**
* Get the list of SQL statements in the history.
*
* @return the commands
*/
ArrayList<String> getCommandHistory() {
return commandHistory;
}
/**
* Update session meta data information and get the information in a map.
*
* @return a map containing the session meta data
*/
HashMap<String, Object> getInfo() {
HashMap<String, Object> m = New.hashMap();
m.putAll(map);
m.put("lastAccess", new Timestamp(lastAccess).toString());
try {
m.put("url", conn == null ?
"${text.admin.notConnected}" : conn.getMetaData().getURL());
m.put("user", conn == null ?
"-" : conn.getMetaData().getUserName());
m.put("lastQuery", commandHistory.size() == 0 ?
"" : commandHistory.get(0));
m.put("executing", executingStatement == null ?
"${text.admin.no}" : "${text.admin.yes}");
} catch (SQLException e) {
DbException.traceThrowable(e);
}
return m;
}
void setConnection(Connection conn) throws SQLException {
this.conn = conn;
if (conn == null) {
meta = null;
} else {
meta = conn.getMetaData();
}
contents = new DbContents();
}
DatabaseMetaData getMetaData() {
return meta;
}
Connection getConnection() {
return conn;
}
DbContents getContents() {
return contents;
}
/**
* Shutdown the server when disconnecting.
*/
void setShutdownServerOnDisconnect() {
this.shutdownServerOnDisconnect = true;
}
boolean getShutdownServerOnDisconnect() {
return shutdownServerOnDisconnect;
}
/**
* Close the connection and stop the statement if one is currently
* executing.
*/
void close() {
if (executingStatement != null) {
try {
executingStatement.cancel();
} catch (Exception e) {
// ignore
}
}
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
// ignore
}
}
}
}
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<beans 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/beans_1_0.xsd" />
......@@ -5,6 +5,6 @@
xmlns:jsf="http://xmlns.jcp.org/jsf"
xmlns:ui="http://xmlns.jcp.org/jsf/facelets">
<body>
<ui:include src="/org/legrog/web/navigation.xhtml" />
<ui:include src="/navigation.xhtml" />
</body>
</html>
\ No newline at end of file
......
package org.legrog.web.xyz;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.legrog.entities.Account;
import org.legrog.entities.PublisherVersion;
import org.legrog.entities.SearchingException;
import org.legrog.test.MockitoExtension;
import org.legrog.web.account.AccountService;
import org.legrog.web.publisher.PublisherService;
import org.mockito.Mock;
import org.mockito.Mockito;
import java.util.ArrayList;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
/**
* Classe testant SearchView
*/
@RunWith(JUnitPlatform.class)
@ExtendWith(MockitoExtension.class)
@DisplayName("Searches for an indexed publisher")
public class SearchViewTest {
private SearchView searchView;
private PublisherService publisherService;
private AccountService accountService;
@BeforeEach
public void setUp(@Mock PublisherService publisherService, @Mock AccountService accountService) {
this.publisherService = publisherService;
this.accountService = accountService;
this.searchView = new SearchView(publisherService, accountService);
}
@Nested
@DisplayName("search method")
class SearchTests {
@Test
@DisplayName("when called, should delegate search to PublisherService and AccountService with same string")
public void searchUsesPublisherService(@Mock PublisherService publisherService, @Mock AccountService accountService) throws SearchingException{
searchView.setSearchString("1");
searchView.search();
Mockito.verify(publisherService).search("1");
Mockito.verify(accountService).search("1");
}
@Test
@DisplayName("when called, should return the answer it gets from PublisherService")
public void searchReturnsDataFromPublisherService(@Mock PublisherService publisherService) throws SearchingException {
List<PublisherVersion> publisherVersionList = new ArrayList<>();
when(publisherService.search("2")).thenReturn(publisherVersionList);
searchView.setSearchString("2");
searchView.search();
assertThat(searchView.getPublisherVersions()).isEqualTo(publisherVersionList);
}
@Test
@DisplayName("when called, should return the answer it gets from AccountService")
public void searchReturnsDataFromAccountService(@Mock AccountService accountService) throws SearchingException {
List<Account> publisherVersionList = new ArrayList<>();
when(accountService.search("3")).thenReturn(publisherVersionList);
searchView.setSearchString("3");
searchView.search();
assertThat(searchView.getPublisherVersions()).isEqualTo(publisherVersionList);
}
}
}
......@@ -8,7 +8,7 @@
<version>3.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>GROG root</name>
<name>**GROG**</name>
<url>http://legrog.org</url>
<description>
Le Guide du Roliste Galactique (GROG) est une encyclopedie en ligne référençant tous les jeux de rôles connus.
......@@ -17,8 +17,8 @@
<modules>
<module>grog-entities</module>
<module>webapp</module>
<module>migration/db-generator</module>
<module>grog-webapp</module>
<module>grog-db-generator</module>
</modules>
<properties>
......