` to any timeseries scraped from this config.
+ - job_name: 'prometheus'
+
+ # Override the global default and scrape targets from this job every 5 seconds.
+ scrape_interval: 5s
+
+ # scheme defaults to 'http' enable https in case your application is server via https
+ #scheme: https
+ # basic auth is not needed by default. See https://www.jhipster.tech/monitoring/#configuring-metrics-forwarding for details
+ #basic_auth:
+ # username: admin
+ # password: admin
+ metrics_path: /management/prometheus
+ static_configs:
+ - targets:
+ # On MacOS, replace localhost by host.docker.internal
+ - localhost:8080
diff --git a/src/main/docker/sonar.yml b/src/main/docker/sonar.yml
new file mode 100644
index 0000000..9619d03
--- /dev/null
+++ b/src/main/docker/sonar.yml
@@ -0,0 +1,13 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+ datasurvey-sonar:
+ image: sonarqube:8.9.1-community
+ # Authentication is turned off for out of the box experience while trying out SonarQube
+ # For real use cases delete sonar.forceAuthentication variable or set sonar.forceAuthentication=true
+ environment:
+ - sonar.forceAuthentication=false
+ # If you want to expose these ports outside your dev PC,
+ # remove the "127.0.0.1:" prefix
+ ports:
+ - 127.0.0.1:9001:9000
diff --git a/src/main/java/org/datasurvey/ApplicationWebXml.java b/src/main/java/org/datasurvey/ApplicationWebXml.java
new file mode 100644
index 0000000..ea53e85
--- /dev/null
+++ b/src/main/java/org/datasurvey/ApplicationWebXml.java
@@ -0,0 +1,19 @@
+package org.datasurvey;
+
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+import tech.jhipster.config.DefaultProfileUtil;
+
+/**
+ * This is a helper Java class that provides an alternative to creating a {@code web.xml}.
+ * This will be invoked only when the application is deployed to a Servlet container like Tomcat, JBoss etc.
+ */
+public class ApplicationWebXml extends SpringBootServletInitializer {
+
+ @Override
+ protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+ // set a default to use when no profile is configured.
+ DefaultProfileUtil.addDefaultProfile(application.application());
+ return application.sources(DataSurveyApp.class);
+ }
+}
diff --git a/src/main/java/org/datasurvey/DataSurveyApp.java b/src/main/java/org/datasurvey/DataSurveyApp.java
new file mode 100644
index 0000000..266fc47
--- /dev/null
+++ b/src/main/java/org/datasurvey/DataSurveyApp.java
@@ -0,0 +1,103 @@
+package org.datasurvey;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import javax.annotation.PostConstruct;
+import org.apache.commons.lang3.StringUtils;
+import org.datasurvey.config.ApplicationProperties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.liquibase.LiquibaseProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.core.env.Environment;
+import tech.jhipster.config.DefaultProfileUtil;
+import tech.jhipster.config.JHipsterConstants;
+
+@SpringBootApplication
+@EnableConfigurationProperties({ LiquibaseProperties.class, ApplicationProperties.class })
+public class DataSurveyApp {
+
+ private static final Logger log = LoggerFactory.getLogger(DataSurveyApp.class);
+
+ private final Environment env;
+
+ public DataSurveyApp(Environment env) {
+ this.env = env;
+ }
+
+ /**
+ * Initializes DataSurvey.
+ *
+ * Spring profiles can be configured with a program argument --spring.profiles.active=your-active-profile
+ *
+ * You can find more information on how profiles work with JHipster on https://www.jhipster.tech/profiles/.
+ */
+ @PostConstruct
+ public void initApplication() {
+ Collection activeProfiles = Arrays.asList(env.getActiveProfiles());
+ if (
+ activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT) &&
+ activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_PRODUCTION)
+ ) {
+ log.error(
+ "You have misconfigured your application! It should not run " + "with both the 'dev' and 'prod' profiles at the same time."
+ );
+ }
+ if (
+ activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT) &&
+ activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_CLOUD)
+ ) {
+ log.error(
+ "You have misconfigured your application! It should not " + "run with both the 'dev' and 'cloud' profiles at the same time."
+ );
+ }
+ }
+
+ /**
+ * Main method, used to run the application.
+ *
+ * @param args the command line arguments.
+ */
+ public static void main(String[] args) {
+ SpringApplication app = new SpringApplication(DataSurveyApp.class);
+ DefaultProfileUtil.addDefaultProfile(app);
+ Environment env = app.run(args).getEnvironment();
+ logApplicationStartup(env);
+ }
+
+ private static void logApplicationStartup(Environment env) {
+ String protocol = Optional.ofNullable(env.getProperty("server.ssl.key-store")).map(key -> "https").orElse("http");
+ String serverPort = env.getProperty("server.port");
+ String contextPath = Optional
+ .ofNullable(env.getProperty("server.servlet.context-path"))
+ .filter(StringUtils::isNotBlank)
+ .orElse("/");
+ String hostAddress = "localhost";
+ try {
+ hostAddress = InetAddress.getLocalHost().getHostAddress();
+ } catch (UnknownHostException e) {
+ log.warn("The host name could not be determined, using `localhost` as fallback");
+ }
+ log.info(
+ "\n----------------------------------------------------------\n\t" +
+ "Application '{}' is running! Access URLs:\n\t" +
+ "Local: \t\t{}://localhost:{}{}\n\t" +
+ "External: \t{}://{}:{}{}\n\t" +
+ "Profile(s): \t{}\n----------------------------------------------------------",
+ env.getProperty("spring.application.name"),
+ protocol,
+ serverPort,
+ contextPath,
+ protocol,
+ hostAddress,
+ serverPort,
+ contextPath,
+ env.getActiveProfiles()
+ );
+ }
+}
diff --git a/src/main/java/org/datasurvey/GeneratedByJHipster.java b/src/main/java/org/datasurvey/GeneratedByJHipster.java
new file mode 100644
index 0000000..05b4ced
--- /dev/null
+++ b/src/main/java/org/datasurvey/GeneratedByJHipster.java
@@ -0,0 +1,13 @@
+package org.datasurvey;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Generated;
+
+@Generated(value = "JHipster", comments = "Generated by JHipster 7.1.0")
+@Retention(RetentionPolicy.SOURCE)
+@Target({ ElementType.TYPE })
+public @interface GeneratedByJHipster {
+}
diff --git a/src/main/java/org/datasurvey/aop/logging/LoggingAspect.java b/src/main/java/org/datasurvey/aop/logging/LoggingAspect.java
new file mode 100644
index 0000000..01d5f01
--- /dev/null
+++ b/src/main/java/org/datasurvey/aop/logging/LoggingAspect.java
@@ -0,0 +1,111 @@
+package org.datasurvey.aop.logging;
+
+import java.util.Arrays;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import tech.jhipster.config.JHipsterConstants;
+
+/**
+ * Aspect for logging execution of service and repository Spring components.
+ *
+ * By default, it only runs with the "dev" profile.
+ */
+@Aspect
+public class LoggingAspect {
+
+ private final Environment env;
+
+ public LoggingAspect(Environment env) {
+ this.env = env;
+ }
+
+ /**
+ * Pointcut that matches all repositories, services and Web REST endpoints.
+ */
+ @Pointcut(
+ "within(@org.springframework.stereotype.Repository *)" +
+ " || within(@org.springframework.stereotype.Service *)" +
+ " || within(@org.springframework.web.bind.annotation.RestController *)"
+ )
+ public void springBeanPointcut() {
+ // Method is empty as this is just a Pointcut, the implementations are in the advices.
+ }
+
+ /**
+ * Pointcut that matches all Spring beans in the application's main packages.
+ */
+ @Pointcut("within(org.datasurvey.repository..*)" + " || within(org.datasurvey.service..*)" + " || within(org.datasurvey.web.rest..*)")
+ public void applicationPackagePointcut() {
+ // Method is empty as this is just a Pointcut, the implementations are in the advices.
+ }
+
+ /**
+ * Retrieves the {@link Logger} associated to the given {@link JoinPoint}.
+ *
+ * @param joinPoint join point we want the logger for.
+ * @return {@link Logger} associated to the given {@link JoinPoint}.
+ */
+ private Logger logger(JoinPoint joinPoint) {
+ return LoggerFactory.getLogger(joinPoint.getSignature().getDeclaringTypeName());
+ }
+
+ /**
+ * Advice that logs methods throwing exceptions.
+ *
+ * @param joinPoint join point for advice.
+ * @param e exception.
+ */
+ @AfterThrowing(pointcut = "applicationPackagePointcut() && springBeanPointcut()", throwing = "e")
+ public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
+ if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT))) {
+ logger(joinPoint)
+ .error(
+ "Exception in {}() with cause = \'{}\' and exception = \'{}\'",
+ joinPoint.getSignature().getName(),
+ e.getCause() != null ? e.getCause() : "NULL",
+ e.getMessage(),
+ e
+ );
+ } else {
+ logger(joinPoint)
+ .error(
+ "Exception in {}() with cause = {}",
+ joinPoint.getSignature().getName(),
+ e.getCause() != null ? e.getCause() : "NULL"
+ );
+ }
+ }
+
+ /**
+ * Advice that logs when a method is entered and exited.
+ *
+ * @param joinPoint join point for advice.
+ * @return result.
+ * @throws Throwable throws {@link IllegalArgumentException}.
+ */
+ @Around("applicationPackagePointcut() && springBeanPointcut()")
+ public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
+ Logger log = logger(joinPoint);
+ if (log.isDebugEnabled()) {
+ log.debug("Enter: {}() with argument[s] = {}", joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
+ }
+ try {
+ Object result = joinPoint.proceed();
+ if (log.isDebugEnabled()) {
+ log.debug("Exit: {}() with result = {}", joinPoint.getSignature().getName(), result);
+ }
+ return result;
+ } catch (IllegalArgumentException e) {
+ log.error("Illegal argument: {} in {}()", Arrays.toString(joinPoint.getArgs()), joinPoint.getSignature().getName());
+ throw e;
+ }
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/ApplicationProperties.java b/src/main/java/org/datasurvey/config/ApplicationProperties.java
new file mode 100644
index 0000000..86c8468
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/ApplicationProperties.java
@@ -0,0 +1,12 @@
+package org.datasurvey.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Properties specific to Data Survey.
+ *
+ * Properties are configured in the {@code application.yml} file.
+ * See {@link tech.jhipster.config.JHipsterProperties} for a good example.
+ */
+@ConfigurationProperties(prefix = "application", ignoreUnknownFields = false)
+public class ApplicationProperties {}
diff --git a/src/main/java/org/datasurvey/config/AsyncConfiguration.java b/src/main/java/org/datasurvey/config/AsyncConfiguration.java
new file mode 100644
index 0000000..c74a6e7
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/AsyncConfiguration.java
@@ -0,0 +1,46 @@
+package org.datasurvey.config;
+
+import java.util.concurrent.Executor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
+import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
+import org.springframework.boot.autoconfigure.task.TaskExecutionProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.AsyncConfigurer;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import tech.jhipster.async.ExceptionHandlingAsyncTaskExecutor;
+
+@Configuration
+@EnableAsync
+@EnableScheduling
+public class AsyncConfiguration implements AsyncConfigurer {
+
+ private final Logger log = LoggerFactory.getLogger(AsyncConfiguration.class);
+
+ private final TaskExecutionProperties taskExecutionProperties;
+
+ public AsyncConfiguration(TaskExecutionProperties taskExecutionProperties) {
+ this.taskExecutionProperties = taskExecutionProperties;
+ }
+
+ @Override
+ @Bean(name = "taskExecutor")
+ public Executor getAsyncExecutor() {
+ log.debug("Creating Async Task Executor");
+ ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+ executor.setCorePoolSize(taskExecutionProperties.getPool().getCoreSize());
+ executor.setMaxPoolSize(taskExecutionProperties.getPool().getMaxSize());
+ executor.setQueueCapacity(taskExecutionProperties.getPool().getQueueCapacity());
+ executor.setThreadNamePrefix(taskExecutionProperties.getThreadNamePrefix());
+ return new ExceptionHandlingAsyncTaskExecutor(executor);
+ }
+
+ @Override
+ public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
+ return new SimpleAsyncUncaughtExceptionHandler();
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/CacheConfiguration.java b/src/main/java/org/datasurvey/config/CacheConfiguration.java
new file mode 100644
index 0000000..0836c99
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/CacheConfiguration.java
@@ -0,0 +1,106 @@
+package org.datasurvey.config;
+
+import java.time.Duration;
+import org.ehcache.config.builders.*;
+import org.ehcache.jsr107.Eh107Configuration;
+import org.hibernate.cache.jcache.ConfigSettings;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer;
+import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
+import org.springframework.boot.info.BuildProperties;
+import org.springframework.boot.info.GitProperties;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.context.annotation.*;
+import tech.jhipster.config.JHipsterProperties;
+import tech.jhipster.config.cache.PrefixedKeyGenerator;
+
+@Configuration
+@EnableCaching
+public class CacheConfiguration {
+
+ private GitProperties gitProperties;
+ private BuildProperties buildProperties;
+ private final javax.cache.configuration.Configuration jcacheConfiguration;
+
+ public CacheConfiguration(JHipsterProperties jHipsterProperties) {
+ JHipsterProperties.Cache.Ehcache ehcache = jHipsterProperties.getCache().getEhcache();
+
+ jcacheConfiguration =
+ Eh107Configuration.fromEhcacheCacheConfiguration(
+ CacheConfigurationBuilder
+ .newCacheConfigurationBuilder(Object.class, Object.class, ResourcePoolsBuilder.heap(ehcache.getMaxEntries()))
+ .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(ehcache.getTimeToLiveSeconds())))
+ .build()
+ );
+ }
+
+ @Bean
+ public HibernatePropertiesCustomizer hibernatePropertiesCustomizer(javax.cache.CacheManager cacheManager) {
+ return hibernateProperties -> hibernateProperties.put(ConfigSettings.CACHE_MANAGER, cacheManager);
+ }
+
+ @Bean
+ public JCacheManagerCustomizer cacheManagerCustomizer() {
+ return cm -> {
+ createCache(cm, org.datasurvey.repository.UserRepository.USERS_BY_LOGIN_CACHE);
+ createCache(cm, org.datasurvey.repository.UserRepository.USERS_BY_EMAIL_CACHE);
+ createCache(cm, org.datasurvey.domain.User.class.getName());
+ createCache(cm, org.datasurvey.domain.Authority.class.getName());
+ createCache(cm, org.datasurvey.domain.User.class.getName() + ".authorities");
+ createCache(cm, org.datasurvey.domain.ParametroAplicacion.class.getName());
+ createCache(cm, org.datasurvey.domain.UsuarioExtra.class.getName());
+ createCache(cm, org.datasurvey.domain.UsuarioExtra.class.getName() + ".encuestas");
+ createCache(cm, org.datasurvey.domain.UsuarioExtra.class.getName() + ".usuarioEncuestas");
+ createCache(cm, org.datasurvey.domain.UsuarioExtra.class.getName() + ".plantillas");
+ createCache(cm, org.datasurvey.domain.Encuesta.class.getName());
+ createCache(cm, org.datasurvey.domain.Encuesta.class.getName() + ".usuarioEncuestas");
+ createCache(cm, org.datasurvey.domain.Encuesta.class.getName() + ".ePreguntaAbiertas");
+ createCache(cm, org.datasurvey.domain.Encuesta.class.getName() + ".ePreguntaCerradas");
+ createCache(cm, org.datasurvey.domain.EPreguntaAbierta.class.getName());
+ createCache(cm, org.datasurvey.domain.EPreguntaAbierta.class.getName() + ".ePreguntaAbiertaRespuestas");
+ createCache(cm, org.datasurvey.domain.EPreguntaAbiertaRespuesta.class.getName());
+ createCache(cm, org.datasurvey.domain.EPreguntaCerrada.class.getName());
+ createCache(cm, org.datasurvey.domain.EPreguntaCerrada.class.getName() + ".ePreguntaCerradaOpcions");
+ createCache(cm, org.datasurvey.domain.EPreguntaCerradaOpcion.class.getName());
+ createCache(cm, org.datasurvey.domain.UsuarioEncuesta.class.getName());
+ createCache(cm, org.datasurvey.domain.Categoria.class.getName());
+ createCache(cm, org.datasurvey.domain.Categoria.class.getName() + ".encuestas");
+ createCache(cm, org.datasurvey.domain.Categoria.class.getName() + ".plantillas");
+ createCache(cm, org.datasurvey.domain.Factura.class.getName());
+ createCache(cm, org.datasurvey.domain.Plantilla.class.getName());
+ createCache(cm, org.datasurvey.domain.Plantilla.class.getName() + ".pPreguntaCerradas");
+ createCache(cm, org.datasurvey.domain.Plantilla.class.getName() + ".pPreguntaAbiertas");
+ createCache(cm, org.datasurvey.domain.Plantilla.class.getName() + ".usuarioExtras");
+ createCache(cm, org.datasurvey.domain.PPreguntaAbierta.class.getName());
+ createCache(cm, org.datasurvey.domain.PPreguntaCerrada.class.getName());
+ createCache(cm, org.datasurvey.domain.PPreguntaCerrada.class.getName() + ".pPreguntaCerradaOpcions");
+ createCache(cm, org.datasurvey.domain.PPreguntaCerradaOpcion.class.getName());
+ // jhipster-needle-ehcache-add-entry
+ };
+ }
+
+ private void createCache(javax.cache.CacheManager cm, String cacheName) {
+ javax.cache.Cache cache = cm.getCache(cacheName);
+ if (cache != null) {
+ cache.clear();
+ } else {
+ cm.createCache(cacheName, jcacheConfiguration);
+ }
+ }
+
+ @Autowired(required = false)
+ public void setGitProperties(GitProperties gitProperties) {
+ this.gitProperties = gitProperties;
+ }
+
+ @Autowired(required = false)
+ public void setBuildProperties(BuildProperties buildProperties) {
+ this.buildProperties = buildProperties;
+ }
+
+ @Bean
+ public KeyGenerator keyGenerator() {
+ return new PrefixedKeyGenerator(this.gitProperties, this.buildProperties);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/Constants.java b/src/main/java/org/datasurvey/config/Constants.java
new file mode 100644
index 0000000..224acca
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/Constants.java
@@ -0,0 +1,15 @@
+package org.datasurvey.config;
+
+/**
+ * Application constants.
+ */
+public final class Constants {
+
+ // Regex for acceptable logins
+ public static final String LOGIN_REGEX = "^(?>[a-zA-Z0-9!$&*+=?^_`{|}~.-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)|(?>[_.@A-Za-z0-9-]+)$";
+
+ public static final String SYSTEM = "system";
+ public static final String DEFAULT_LANGUAGE = "es";
+
+ private Constants() {}
+}
diff --git a/src/main/java/org/datasurvey/config/DatabaseConfiguration.java b/src/main/java/org/datasurvey/config/DatabaseConfiguration.java
new file mode 100644
index 0000000..1c4f070
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/DatabaseConfiguration.java
@@ -0,0 +1,16 @@
+package org.datasurvey.config;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import tech.jhipster.config.JHipsterConstants;
+
+@Configuration
+@EnableJpaRepositories("org.datasurvey.repository")
+@EnableJpaAuditing(auditorAwareRef = "springSecurityAuditorAware")
+@EnableTransactionManagement
+public class DatabaseConfiguration {}
diff --git a/src/main/java/org/datasurvey/config/DateTimeFormatConfiguration.java b/src/main/java/org/datasurvey/config/DateTimeFormatConfiguration.java
new file mode 100644
index 0000000..896c607
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/DateTimeFormatConfiguration.java
@@ -0,0 +1,20 @@
+package org.datasurvey.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.format.FormatterRegistry;
+import org.springframework.format.datetime.standard.DateTimeFormatterRegistrar;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * Configure the converters to use the ISO format for dates by default.
+ */
+@Configuration
+public class DateTimeFormatConfiguration implements WebMvcConfigurer {
+
+ @Override
+ public void addFormatters(FormatterRegistry registry) {
+ DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
+ registrar.setUseIsoFormat(true);
+ registrar.registerFormatters(registry);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/JacksonConfiguration.java b/src/main/java/org/datasurvey/config/JacksonConfiguration.java
new file mode 100644
index 0000000..db9e784
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/JacksonConfiguration.java
@@ -0,0 +1,51 @@
+package org.datasurvey.config;
+
+import com.fasterxml.jackson.datatype.hibernate5.Hibernate5Module;
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.zalando.problem.ProblemModule;
+import org.zalando.problem.violations.ConstraintViolationProblemModule;
+
+@Configuration
+public class JacksonConfiguration {
+
+ /**
+ * Support for Java date and time API.
+ * @return the corresponding Jackson module.
+ */
+ @Bean
+ public JavaTimeModule javaTimeModule() {
+ return new JavaTimeModule();
+ }
+
+ @Bean
+ public Jdk8Module jdk8TimeModule() {
+ return new Jdk8Module();
+ }
+
+ /*
+ * Support for Hibernate types in Jackson.
+ */
+ @Bean
+ public Hibernate5Module hibernate5Module() {
+ return new Hibernate5Module();
+ }
+
+ /*
+ * Module for serialization/deserialization of RFC7807 Problem.
+ */
+ @Bean
+ public ProblemModule problemModule() {
+ return new ProblemModule();
+ }
+
+ /*
+ * Module for serialization/deserialization of ConstraintViolationProblem.
+ */
+ @Bean
+ public ConstraintViolationProblemModule constraintViolationProblemModule() {
+ return new ConstraintViolationProblemModule();
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/LiquibaseConfiguration.java b/src/main/java/org/datasurvey/config/LiquibaseConfiguration.java
new file mode 100644
index 0000000..0f8d0dd
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/LiquibaseConfiguration.java
@@ -0,0 +1,69 @@
+package org.datasurvey.config;
+
+import java.util.concurrent.Executor;
+import javax.sql.DataSource;
+import liquibase.integration.spring.SpringLiquibase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
+import org.springframework.boot.autoconfigure.liquibase.LiquibaseDataSource;
+import org.springframework.boot.autoconfigure.liquibase.LiquibaseProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.liquibase.SpringLiquibaseUtil;
+
+@Configuration
+public class LiquibaseConfiguration {
+
+ private final Logger log = LoggerFactory.getLogger(LiquibaseConfiguration.class);
+
+ private final Environment env;
+
+ public LiquibaseConfiguration(Environment env) {
+ this.env = env;
+ }
+
+ @Bean
+ public SpringLiquibase liquibase(
+ @Qualifier("taskExecutor") Executor executor,
+ @LiquibaseDataSource ObjectProvider liquibaseDataSource,
+ LiquibaseProperties liquibaseProperties,
+ ObjectProvider dataSource,
+ DataSourceProperties dataSourceProperties
+ ) {
+ // If you don't want Liquibase to start asynchronously, substitute by this:
+ // SpringLiquibase liquibase = SpringLiquibaseUtil.createSpringLiquibase(liquibaseDataSource.getIfAvailable(), liquibaseProperties, dataSource.getIfUnique(), dataSourceProperties);
+ SpringLiquibase liquibase = SpringLiquibaseUtil.createAsyncSpringLiquibase(
+ this.env,
+ executor,
+ liquibaseDataSource.getIfAvailable(),
+ liquibaseProperties,
+ dataSource.getIfUnique(),
+ dataSourceProperties
+ );
+ liquibase.setChangeLog("classpath:config/liquibase/master.xml");
+ liquibase.setContexts(liquibaseProperties.getContexts());
+ liquibase.setDefaultSchema(liquibaseProperties.getDefaultSchema());
+ liquibase.setLiquibaseSchema(liquibaseProperties.getLiquibaseSchema());
+ liquibase.setLiquibaseTablespace(liquibaseProperties.getLiquibaseTablespace());
+ liquibase.setDatabaseChangeLogLockTable(liquibaseProperties.getDatabaseChangeLogLockTable());
+ liquibase.setDatabaseChangeLogTable(liquibaseProperties.getDatabaseChangeLogTable());
+ liquibase.setDropFirst(liquibaseProperties.isDropFirst());
+ liquibase.setLabels(liquibaseProperties.getLabels());
+ liquibase.setChangeLogParameters(liquibaseProperties.getParameters());
+ liquibase.setRollbackFile(liquibaseProperties.getRollbackFile());
+ liquibase.setTestRollbackOnUpdate(liquibaseProperties.isTestRollbackOnUpdate());
+ if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_NO_LIQUIBASE))) {
+ liquibase.setShouldRun(false);
+ } else {
+ liquibase.setShouldRun(liquibaseProperties.isEnabled());
+ log.debug("Configuring Liquibase");
+ }
+ return liquibase;
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/LocaleConfiguration.java b/src/main/java/org/datasurvey/config/LocaleConfiguration.java
new file mode 100644
index 0000000..3150453
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/LocaleConfiguration.java
@@ -0,0 +1,26 @@
+package org.datasurvey.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.LocaleResolver;
+import org.springframework.web.servlet.config.annotation.*;
+import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
+import tech.jhipster.config.locale.AngularCookieLocaleResolver;
+
+@Configuration
+public class LocaleConfiguration implements WebMvcConfigurer {
+
+ @Bean
+ public LocaleResolver localeResolver() {
+ AngularCookieLocaleResolver cookieLocaleResolver = new AngularCookieLocaleResolver();
+ cookieLocaleResolver.setCookieName("NG_TRANSLATE_LANG_KEY");
+ return cookieLocaleResolver;
+ }
+
+ @Override
+ public void addInterceptors(InterceptorRegistry registry) {
+ LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
+ localeChangeInterceptor.setParamName("language");
+ registry.addInterceptor(localeChangeInterceptor);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/LoggingAspectConfiguration.java b/src/main/java/org/datasurvey/config/LoggingAspectConfiguration.java
new file mode 100644
index 0000000..631ee45
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/LoggingAspectConfiguration.java
@@ -0,0 +1,17 @@
+package org.datasurvey.config;
+
+import org.datasurvey.aop.logging.LoggingAspect;
+import org.springframework.context.annotation.*;
+import org.springframework.core.env.Environment;
+import tech.jhipster.config.JHipsterConstants;
+
+@Configuration
+@EnableAspectJAutoProxy
+public class LoggingAspectConfiguration {
+
+ @Bean
+ @Profile(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)
+ public LoggingAspect loggingAspect(Environment env) {
+ return new LoggingAspect(env);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/LoggingConfiguration.java b/src/main/java/org/datasurvey/config/LoggingConfiguration.java
new file mode 100644
index 0000000..16b9f6e
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/LoggingConfiguration.java
@@ -0,0 +1,47 @@
+package org.datasurvey.config;
+
+import static tech.jhipster.config.logging.LoggingUtils.*;
+
+import ch.qos.logback.classic.LoggerContext;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.Map;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import tech.jhipster.config.JHipsterProperties;
+
+/*
+ * Configures the console and Logstash log appenders from the app properties
+ */
+@Configuration
+public class LoggingConfiguration {
+
+ public LoggingConfiguration(
+ @Value("${spring.application.name}") String appName,
+ @Value("${server.port}") String serverPort,
+ JHipsterProperties jHipsterProperties,
+ ObjectMapper mapper
+ ) throws JsonProcessingException {
+ LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+
+ Map map = new HashMap<>();
+ map.put("app_name", appName);
+ map.put("app_port", serverPort);
+ String customFields = mapper.writeValueAsString(map);
+
+ JHipsterProperties.Logging loggingProperties = jHipsterProperties.getLogging();
+ JHipsterProperties.Logging.Logstash logstashProperties = loggingProperties.getLogstash();
+
+ if (loggingProperties.isUseJsonFormat()) {
+ addJsonConsoleAppender(context, customFields);
+ }
+ if (logstashProperties.isEnabled()) {
+ addLogstashTcpSocketAppender(context, customFields, logstashProperties);
+ }
+ if (loggingProperties.isUseJsonFormat() || logstashProperties.isEnabled()) {
+ addContextListener(context, customFields, loggingProperties);
+ }
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/SecurityConfiguration.java b/src/main/java/org/datasurvey/config/SecurityConfiguration.java
new file mode 100644
index 0000000..1661950
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/SecurityConfiguration.java
@@ -0,0 +1,111 @@
+package org.datasurvey.config;
+
+import org.datasurvey.security.*;
+import org.datasurvey.security.jwt.*;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Import;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.builders.WebSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.security.web.header.writers.ReferrerPolicyHeaderWriter;
+import org.springframework.web.filter.CorsFilter;
+import org.zalando.problem.spring.web.advice.security.SecurityProblemSupport;
+import tech.jhipster.config.JHipsterProperties;
+
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
+@Import(SecurityProblemSupport.class)
+public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
+
+ private final JHipsterProperties jHipsterProperties;
+
+ private final TokenProvider tokenProvider;
+
+ private final CorsFilter corsFilter;
+ private final SecurityProblemSupport problemSupport;
+
+ public SecurityConfiguration(
+ TokenProvider tokenProvider,
+ CorsFilter corsFilter,
+ JHipsterProperties jHipsterProperties,
+ SecurityProblemSupport problemSupport
+ ) {
+ this.tokenProvider = tokenProvider;
+ this.corsFilter = corsFilter;
+ this.problemSupport = problemSupport;
+ this.jHipsterProperties = jHipsterProperties;
+ }
+
+ @Bean
+ public PasswordEncoder passwordEncoder() {
+ return new BCryptPasswordEncoder();
+ }
+
+ @Override
+ public void configure(WebSecurity web) {
+ web
+ .ignoring()
+ .antMatchers(HttpMethod.OPTIONS, "/**")
+ .antMatchers("/app/**/*.{js,html}")
+ .antMatchers("/i18n/**")
+ .antMatchers("/content/**")
+ .antMatchers("/swagger-ui/**")
+ .antMatchers("/test/**");
+ }
+
+ @Override
+ public void configure(HttpSecurity http) throws Exception {
+ // @formatter:off
+ http
+ .csrf()
+ .disable()
+ .addFilterBefore(corsFilter, UsernamePasswordAuthenticationFilter.class)
+ .exceptionHandling()
+ .authenticationEntryPoint(problemSupport)
+ .accessDeniedHandler(problemSupport)
+ .and()
+ .headers()
+ .contentSecurityPolicy(jHipsterProperties.getSecurity().getContentSecurityPolicy())
+ .and()
+ .referrerPolicy(ReferrerPolicyHeaderWriter.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN)
+ .and()
+ .featurePolicy("geolocation 'none'; midi 'none'; sync-xhr 'none'; microphone 'none'; camera 'none'; magnetometer 'none'; gyroscope 'none'; fullscreen 'self'; payment 'none'")
+ .and()
+ .frameOptions()
+ .deny()
+ .and()
+ .sessionManagement()
+ .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+ .and()
+ .authorizeRequests()
+ .antMatchers("/api/authenticate").permitAll()
+ .antMatchers("/api/register").permitAll()
+ .antMatchers("/api/activate").permitAll()
+ .antMatchers("/api/account/reset-password/init").permitAll()
+ .antMatchers("/api/account/reset-password/finish").permitAll()
+ .antMatchers("/api/admin/**").hasAuthority(AuthoritiesConstants.ADMIN)
+ .antMatchers("/api/**").authenticated()
+ .antMatchers("/websocket/**").authenticated()
+ .antMatchers("/management/health").permitAll()
+ .antMatchers("/management/health/**").permitAll()
+ .antMatchers("/management/info").permitAll()
+ .antMatchers("/management/prometheus").permitAll()
+ .antMatchers("/management/**").hasAuthority(AuthoritiesConstants.ADMIN)
+ .and()
+ .httpBasic()
+ .and()
+ .apply(securityConfigurerAdapter());
+ // @formatter:on
+ }
+
+ private JWTConfigurer securityConfigurerAdapter() {
+ return new JWTConfigurer(tokenProvider);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/StaticResourcesWebConfiguration.java b/src/main/java/org/datasurvey/config/StaticResourcesWebConfiguration.java
new file mode 100644
index 0000000..dbc3a30
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/StaticResourcesWebConfiguration.java
@@ -0,0 +1,59 @@
+package org.datasurvey.config;
+
+import java.util.concurrent.TimeUnit;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.CacheControl;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistration;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.JHipsterProperties;
+
+@Configuration
+@Profile({ JHipsterConstants.SPRING_PROFILE_PRODUCTION })
+public class StaticResourcesWebConfiguration implements WebMvcConfigurer {
+
+ protected static final String[] RESOURCE_LOCATIONS = new String[] {
+ "classpath:/static/",
+ "classpath:/static/content/",
+ "classpath:/static/i18n/",
+ };
+ protected static final String[] RESOURCE_PATHS = new String[] {
+ "/*.js",
+ "/*.css",
+ "/*.svg",
+ "/*.png",
+ "*.ico",
+ "/content/**",
+ "/i18n/*",
+ };
+
+ private final JHipsterProperties jhipsterProperties;
+
+ public StaticResourcesWebConfiguration(JHipsterProperties jHipsterProperties) {
+ this.jhipsterProperties = jHipsterProperties;
+ }
+
+ @Override
+ public void addResourceHandlers(ResourceHandlerRegistry registry) {
+ ResourceHandlerRegistration resourceHandlerRegistration = appendResourceHandler(registry);
+ initializeResourceHandler(resourceHandlerRegistration);
+ }
+
+ protected ResourceHandlerRegistration appendResourceHandler(ResourceHandlerRegistry registry) {
+ return registry.addResourceHandler(RESOURCE_PATHS);
+ }
+
+ protected void initializeResourceHandler(ResourceHandlerRegistration resourceHandlerRegistration) {
+ resourceHandlerRegistration.addResourceLocations(RESOURCE_LOCATIONS).setCacheControl(getCacheControl());
+ }
+
+ protected CacheControl getCacheControl() {
+ return CacheControl.maxAge(getJHipsterHttpCacheProperty(), TimeUnit.DAYS).cachePublic();
+ }
+
+ private int getJHipsterHttpCacheProperty() {
+ return jhipsterProperties.getHttp().getCache().getTimeToLiveInDays();
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/WebConfigurer.java b/src/main/java/org/datasurvey/config/WebConfigurer.java
new file mode 100644
index 0000000..76aefc7
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/WebConfigurer.java
@@ -0,0 +1,109 @@
+package org.datasurvey.config;
+
+import static java.net.URLDecoder.decode;
+
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Paths;
+import java.util.*;
+import javax.servlet.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.web.server.*;
+import org.springframework.boot.web.servlet.ServletContextInitializer;
+import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.JHipsterProperties;
+
+/**
+ * Configuration of web application with Servlet 3.0 APIs.
+ */
+@Configuration
+public class WebConfigurer implements ServletContextInitializer, WebServerFactoryCustomizer {
+
+ private final Logger log = LoggerFactory.getLogger(WebConfigurer.class);
+
+ private final Environment env;
+
+ private final JHipsterProperties jHipsterProperties;
+
+ public WebConfigurer(Environment env, JHipsterProperties jHipsterProperties) {
+ this.env = env;
+ this.jHipsterProperties = jHipsterProperties;
+ }
+
+ @Override
+ public void onStartup(ServletContext servletContext) throws ServletException {
+ if (env.getActiveProfiles().length != 0) {
+ log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles());
+ }
+
+ log.info("Web application fully configured");
+ }
+
+ /**
+ * Customize the Servlet engine: Mime types, the document root, the cache.
+ */
+ @Override
+ public void customize(WebServerFactory server) {
+ // When running in an IDE or with ./mvnw spring-boot:run, set location of the static web assets.
+ setLocationForStaticAssets(server);
+ }
+
+ private void setLocationForStaticAssets(WebServerFactory server) {
+ if (server instanceof ConfigurableServletWebServerFactory) {
+ ConfigurableServletWebServerFactory servletWebServer = (ConfigurableServletWebServerFactory) server;
+ File root;
+ String prefixPath = resolvePathPrefix();
+ root = new File(prefixPath + "target/classes/static/");
+ if (root.exists() && root.isDirectory()) {
+ servletWebServer.setDocumentRoot(root);
+ }
+ }
+ }
+
+ /**
+ * Resolve path prefix to static resources.
+ */
+ private String resolvePathPrefix() {
+ String fullExecutablePath;
+ try {
+ fullExecutablePath = decode(this.getClass().getResource("").getPath(), StandardCharsets.UTF_8.name());
+ } catch (UnsupportedEncodingException e) {
+ /* try without decoding if this ever happens */
+ fullExecutablePath = this.getClass().getResource("").getPath();
+ }
+ String rootPath = Paths.get(".").toUri().normalize().getPath();
+ String extractedPath = fullExecutablePath.replace(rootPath, "");
+ int extractionEndIndex = extractedPath.indexOf("target/");
+ if (extractionEndIndex <= 0) {
+ return "";
+ }
+ return extractedPath.substring(0, extractionEndIndex);
+ }
+
+ @Bean
+ public CorsFilter corsFilter() {
+ UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+ CorsConfiguration config = jHipsterProperties.getCors();
+ if (!CollectionUtils.isEmpty(config.getAllowedOrigins()) || !CollectionUtils.isEmpty(config.getAllowedOriginPatterns())) {
+ log.debug("Registering CORS filter");
+ source.registerCorsConfiguration("/api/**", config);
+ source.registerCorsConfiguration("/management/**", config);
+ source.registerCorsConfiguration("/v2/api-docs", config);
+ source.registerCorsConfiguration("/v3/api-docs", config);
+ source.registerCorsConfiguration("/swagger-resources", config);
+ source.registerCorsConfiguration("/swagger-ui/**", config);
+ }
+ return new CorsFilter(source);
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/WebsocketConfiguration.java b/src/main/java/org/datasurvey/config/WebsocketConfiguration.java
new file mode 100644
index 0000000..500d2bf
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/WebsocketConfiguration.java
@@ -0,0 +1,90 @@
+package org.datasurvey.config;
+
+import java.security.Principal;
+import java.util.*;
+import org.datasurvey.security.AuthoritiesConstants;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.server.*;
+import org.springframework.messaging.simp.config.MessageBrokerRegistry;
+import org.springframework.security.authentication.AnonymousAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.web.socket.WebSocketHandler;
+import org.springframework.web.socket.config.annotation.*;
+import org.springframework.web.socket.server.HandshakeInterceptor;
+import org.springframework.web.socket.server.support.DefaultHandshakeHandler;
+import tech.jhipster.config.JHipsterProperties;
+
+@Configuration
+@EnableWebSocketMessageBroker
+public class WebsocketConfiguration implements WebSocketMessageBrokerConfigurer {
+
+ public static final String IP_ADDRESS = "IP_ADDRESS";
+
+ private final JHipsterProperties jHipsterProperties;
+
+ public WebsocketConfiguration(JHipsterProperties jHipsterProperties) {
+ this.jHipsterProperties = jHipsterProperties;
+ }
+
+ @Override
+ public void configureMessageBroker(MessageBrokerRegistry config) {
+ config.enableSimpleBroker("/topic");
+ }
+
+ @Override
+ public void registerStompEndpoints(StompEndpointRegistry registry) {
+ String[] allowedOrigins = Optional
+ .ofNullable(jHipsterProperties.getCors().getAllowedOrigins())
+ .map(origins -> origins.toArray(new String[0]))
+ .orElse(new String[0]);
+ registry
+ .addEndpoint("/websocket/tracker")
+ .setHandshakeHandler(defaultHandshakeHandler())
+ .setAllowedOrigins(allowedOrigins)
+ .withSockJS()
+ .setInterceptors(httpSessionHandshakeInterceptor());
+ }
+
+ @Bean
+ public HandshakeInterceptor httpSessionHandshakeInterceptor() {
+ return new HandshakeInterceptor() {
+ @Override
+ public boolean beforeHandshake(
+ ServerHttpRequest request,
+ ServerHttpResponse response,
+ WebSocketHandler wsHandler,
+ Map attributes
+ ) throws Exception {
+ if (request instanceof ServletServerHttpRequest) {
+ ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
+ attributes.put(IP_ADDRESS, servletRequest.getRemoteAddress());
+ }
+ return true;
+ }
+
+ @Override
+ public void afterHandshake(
+ ServerHttpRequest request,
+ ServerHttpResponse response,
+ WebSocketHandler wsHandler,
+ Exception exception
+ ) {}
+ };
+ }
+
+ private DefaultHandshakeHandler defaultHandshakeHandler() {
+ return new DefaultHandshakeHandler() {
+ @Override
+ protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map attributes) {
+ Principal principal = request.getPrincipal();
+ if (principal == null) {
+ Collection authorities = new ArrayList<>();
+ authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.ANONYMOUS));
+ principal = new AnonymousAuthenticationToken("WebsocketConfiguration", "anonymous", authorities);
+ }
+ return principal;
+ }
+ };
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/WebsocketSecurityConfiguration.java b/src/main/java/org/datasurvey/config/WebsocketSecurityConfiguration.java
new file mode 100644
index 0000000..b3d0ecc
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/WebsocketSecurityConfiguration.java
@@ -0,0 +1,40 @@
+package org.datasurvey.config;
+
+import org.datasurvey.security.AuthoritiesConstants;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.simp.SimpMessageType;
+import org.springframework.security.config.annotation.web.messaging.MessageSecurityMetadataSourceRegistry;
+import org.springframework.security.config.annotation.web.socket.AbstractSecurityWebSocketMessageBrokerConfigurer;
+
+@Configuration
+public class WebsocketSecurityConfiguration extends AbstractSecurityWebSocketMessageBrokerConfigurer {
+
+ @Override
+ protected void configureInbound(MessageSecurityMetadataSourceRegistry messages) {
+ messages
+ .nullDestMatcher()
+ .authenticated()
+ .simpDestMatchers("/topic/tracker")
+ .hasAuthority(AuthoritiesConstants.ADMIN)
+ // matches any destination that starts with /topic/
+ // (i.e. cannot send messages directly to /topic/)
+ // (i.e. cannot subscribe to /topic/messages/* to get messages sent to
+ // /topic/messages-user)
+ .simpDestMatchers("/topic/**")
+ .authenticated()
+ // message types other than MESSAGE and SUBSCRIBE
+ .simpTypeMatchers(SimpMessageType.MESSAGE, SimpMessageType.SUBSCRIBE)
+ .denyAll()
+ // catch all
+ .anyMessage()
+ .denyAll();
+ }
+
+ /**
+ * Disables CSRF for Websockets.
+ */
+ @Override
+ protected boolean sameOriginDisabled() {
+ return true;
+ }
+}
diff --git a/src/main/java/org/datasurvey/config/package-info.java b/src/main/java/org/datasurvey/config/package-info.java
new file mode 100644
index 0000000..a71fd8e
--- /dev/null
+++ b/src/main/java/org/datasurvey/config/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Spring Framework configuration files.
+ */
+package org.datasurvey.config;
diff --git a/src/main/java/org/datasurvey/domain/AbstractAuditingEntity.java b/src/main/java/org/datasurvey/domain/AbstractAuditingEntity.java
new file mode 100644
index 0000000..ffc2131
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/AbstractAuditingEntity.java
@@ -0,0 +1,76 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java.io.Serializable;
+import java.time.Instant;
+import javax.persistence.Column;
+import javax.persistence.EntityListeners;
+import javax.persistence.MappedSuperclass;
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedBy;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+/**
+ * Base abstract class for entities which will hold definitions for created, last modified, created by,
+ * last modified by attributes.
+ */
+@MappedSuperclass
+@EntityListeners(AuditingEntityListener.class)
+public abstract class AbstractAuditingEntity implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @CreatedBy
+ @Column(name = "created_by", nullable = false, length = 50, updatable = false)
+ @JsonIgnore
+ private String createdBy;
+
+ @CreatedDate
+ @Column(name = "created_date", updatable = false)
+ @JsonIgnore
+ private Instant createdDate = Instant.now();
+
+ @LastModifiedBy
+ @Column(name = "last_modified_by", length = 50)
+ @JsonIgnore
+ private String lastModifiedBy;
+
+ @LastModifiedDate
+ @Column(name = "last_modified_date")
+ @JsonIgnore
+ private Instant lastModifiedDate = Instant.now();
+
+ public String getCreatedBy() {
+ return createdBy;
+ }
+
+ public void setCreatedBy(String createdBy) {
+ this.createdBy = createdBy;
+ }
+
+ public Instant getCreatedDate() {
+ return createdDate;
+ }
+
+ public void setCreatedDate(Instant createdDate) {
+ this.createdDate = createdDate;
+ }
+
+ public String getLastModifiedBy() {
+ return lastModifiedBy;
+ }
+
+ public void setLastModifiedBy(String lastModifiedBy) {
+ this.lastModifiedBy = lastModifiedBy;
+ }
+
+ public Instant getLastModifiedDate() {
+ return lastModifiedDate;
+ }
+
+ public void setLastModifiedDate(Instant lastModifiedDate) {
+ this.lastModifiedDate = lastModifiedDate;
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/Authority.java b/src/main/java/org/datasurvey/domain/Authority.java
new file mode 100644
index 0000000..c63b10b
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/Authority.java
@@ -0,0 +1,61 @@
+package org.datasurvey.domain;
+
+import java.io.Serializable;
+import java.util.Objects;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * An authority (a security role) used by Spring Security.
+ */
+@Entity
+@Table(name = "jhi_authority")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class Authority implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @NotNull
+ @Size(max = 50)
+ @Id
+ @Column(length = 50)
+ private String name;
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Authority)) {
+ return false;
+ }
+ return Objects.equals(name, ((Authority) o).name);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(name);
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "Authority{" +
+ "name='" + name + '\'' +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/Categoria.java b/src/main/java/org/datasurvey/domain/Categoria.java
new file mode 100644
index 0000000..a2a2ff8
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/Categoria.java
@@ -0,0 +1,179 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.EstadoCategoria;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A Categoria.
+ */
+@Entity
+@Table(name = "categoria")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class Categoria implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Column(name = "nombre", nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "estado", nullable = false)
+ private EstadoCategoria estado;
+
+ @OneToMany(mappedBy = "categoria")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(
+ value = { "usuarioEncuestas", "ePreguntaAbiertas", "ePreguntaCerradas", "categoria", "usuarioExtra" },
+ allowSetters = true
+ )
+ private Set encuestas = new HashSet<>();
+
+ @OneToMany(mappedBy = "categoria")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "pPreguntaCerradas", "pPreguntaAbiertas", "categoria", "usuarioExtras" }, allowSetters = true)
+ private Set plantillas = new HashSet<>();
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public Categoria id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public Categoria nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public EstadoCategoria getEstado() {
+ return this.estado;
+ }
+
+ public Categoria estado(EstadoCategoria estado) {
+ this.estado = estado;
+ return this;
+ }
+
+ public void setEstado(EstadoCategoria estado) {
+ this.estado = estado;
+ }
+
+ public Set getEncuestas() {
+ return this.encuestas;
+ }
+
+ public Categoria encuestas(Set encuestas) {
+ this.setEncuestas(encuestas);
+ return this;
+ }
+
+ public Categoria addEncuesta(Encuesta encuesta) {
+ this.encuestas.add(encuesta);
+ encuesta.setCategoria(this);
+ return this;
+ }
+
+ public Categoria removeEncuesta(Encuesta encuesta) {
+ this.encuestas.remove(encuesta);
+ encuesta.setCategoria(null);
+ return this;
+ }
+
+ public void setEncuestas(Set encuestas) {
+ if (this.encuestas != null) {
+ this.encuestas.forEach(i -> i.setCategoria(null));
+ }
+ if (encuestas != null) {
+ encuestas.forEach(i -> i.setCategoria(this));
+ }
+ this.encuestas = encuestas;
+ }
+
+ public Set getPlantillas() {
+ return this.plantillas;
+ }
+
+ public Categoria plantillas(Set plantillas) {
+ this.setPlantillas(plantillas);
+ return this;
+ }
+
+ public Categoria addPlantilla(Plantilla plantilla) {
+ this.plantillas.add(plantilla);
+ plantilla.setCategoria(this);
+ return this;
+ }
+
+ public Categoria removePlantilla(Plantilla plantilla) {
+ this.plantillas.remove(plantilla);
+ plantilla.setCategoria(null);
+ return this;
+ }
+
+ public void setPlantillas(Set plantillas) {
+ if (this.plantillas != null) {
+ this.plantillas.forEach(i -> i.setCategoria(null));
+ }
+ if (plantillas != null) {
+ plantillas.forEach(i -> i.setCategoria(this));
+ }
+ this.plantillas = plantillas;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Categoria)) {
+ return false;
+ }
+ return id != null && id.equals(((Categoria) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "Categoria{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", estado='" + getEstado() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/EPreguntaAbierta.java b/src/main/java/org/datasurvey/domain/EPreguntaAbierta.java
new file mode 100644
index 0000000..be07bcc
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/EPreguntaAbierta.java
@@ -0,0 +1,177 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A EPreguntaAbierta.
+ */
+@Entity
+@Table(name = "e_pregunta_abierta")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class EPreguntaAbierta implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Column(name = "opcional", nullable = false)
+ private Boolean opcional;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @OneToMany(mappedBy = "ePreguntaAbierta")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "ePreguntaAbierta" }, allowSetters = true)
+ private Set ePreguntaAbiertaRespuestas = new HashSet<>();
+
+ @ManyToOne
+ @JsonIgnoreProperties(
+ value = { "usuarioEncuestas", "ePreguntaAbiertas", "ePreguntaCerradas", "categoria", "usuarioExtra" },
+ allowSetters = true
+ )
+ private Encuesta encuesta;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public EPreguntaAbierta id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public EPreguntaAbierta nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public Boolean getOpcional() {
+ return this.opcional;
+ }
+
+ public EPreguntaAbierta opcional(Boolean opcional) {
+ this.opcional = opcional;
+ return this;
+ }
+
+ public void setOpcional(Boolean opcional) {
+ this.opcional = opcional;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public EPreguntaAbierta orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public Set getEPreguntaAbiertaRespuestas() {
+ return this.ePreguntaAbiertaRespuestas;
+ }
+
+ public EPreguntaAbierta ePreguntaAbiertaRespuestas(Set ePreguntaAbiertaRespuestas) {
+ this.setEPreguntaAbiertaRespuestas(ePreguntaAbiertaRespuestas);
+ return this;
+ }
+
+ public EPreguntaAbierta addEPreguntaAbiertaRespuesta(EPreguntaAbiertaRespuesta ePreguntaAbiertaRespuesta) {
+ this.ePreguntaAbiertaRespuestas.add(ePreguntaAbiertaRespuesta);
+ ePreguntaAbiertaRespuesta.setEPreguntaAbierta(this);
+ return this;
+ }
+
+ public EPreguntaAbierta removeEPreguntaAbiertaRespuesta(EPreguntaAbiertaRespuesta ePreguntaAbiertaRespuesta) {
+ this.ePreguntaAbiertaRespuestas.remove(ePreguntaAbiertaRespuesta);
+ ePreguntaAbiertaRespuesta.setEPreguntaAbierta(null);
+ return this;
+ }
+
+ public void setEPreguntaAbiertaRespuestas(Set ePreguntaAbiertaRespuestas) {
+ if (this.ePreguntaAbiertaRespuestas != null) {
+ this.ePreguntaAbiertaRespuestas.forEach(i -> i.setEPreguntaAbierta(null));
+ }
+ if (ePreguntaAbiertaRespuestas != null) {
+ ePreguntaAbiertaRespuestas.forEach(i -> i.setEPreguntaAbierta(this));
+ }
+ this.ePreguntaAbiertaRespuestas = ePreguntaAbiertaRespuestas;
+ }
+
+ public Encuesta getEncuesta() {
+ return this.encuesta;
+ }
+
+ public EPreguntaAbierta encuesta(Encuesta encuesta) {
+ this.setEncuesta(encuesta);
+ return this;
+ }
+
+ public void setEncuesta(Encuesta encuesta) {
+ this.encuesta = encuesta;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof EPreguntaAbierta)) {
+ return false;
+ }
+ return id != null && id.equals(((EPreguntaAbierta) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "EPreguntaAbierta{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", opcional='" + getOpcional() + "'" +
+ ", orden=" + getOrden() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/EPreguntaAbiertaRespuesta.java b/src/main/java/org/datasurvey/domain/EPreguntaAbiertaRespuesta.java
new file mode 100644
index 0000000..4fe4b57
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/EPreguntaAbiertaRespuesta.java
@@ -0,0 +1,99 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A EPreguntaAbiertaRespuesta.
+ */
+@Entity
+@Table(name = "e_pregunta_abierta_respuesta")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class EPreguntaAbiertaRespuesta implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Column(name = "respuesta", nullable = false)
+ private String respuesta;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "ePreguntaAbiertaRespuestas", "encuesta" }, allowSetters = true)
+ private EPreguntaAbierta ePreguntaAbierta;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public EPreguntaAbiertaRespuesta id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getRespuesta() {
+ return this.respuesta;
+ }
+
+ public EPreguntaAbiertaRespuesta respuesta(String respuesta) {
+ this.respuesta = respuesta;
+ return this;
+ }
+
+ public void setRespuesta(String respuesta) {
+ this.respuesta = respuesta;
+ }
+
+ public EPreguntaAbierta getEPreguntaAbierta() {
+ return this.ePreguntaAbierta;
+ }
+
+ public EPreguntaAbiertaRespuesta ePreguntaAbierta(EPreguntaAbierta ePreguntaAbierta) {
+ this.setEPreguntaAbierta(ePreguntaAbierta);
+ return this;
+ }
+
+ public void setEPreguntaAbierta(EPreguntaAbierta ePreguntaAbierta) {
+ this.ePreguntaAbierta = ePreguntaAbierta;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof EPreguntaAbiertaRespuesta)) {
+ return false;
+ }
+ return id != null && id.equals(((EPreguntaAbiertaRespuesta) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "EPreguntaAbiertaRespuesta{" +
+ "id=" + getId() +
+ ", respuesta='" + getRespuesta() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/EPreguntaCerrada.java b/src/main/java/org/datasurvey/domain/EPreguntaCerrada.java
new file mode 100644
index 0000000..d0c49d9
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/EPreguntaCerrada.java
@@ -0,0 +1,197 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.PreguntaCerradaTipo;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A EPreguntaCerrada.
+ */
+@Entity
+@Table(name = "e_pregunta_cerrada")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class EPreguntaCerrada implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "tipo", nullable = false)
+ private PreguntaCerradaTipo tipo;
+
+ @NotNull
+ @Column(name = "opcional", nullable = false)
+ private Boolean opcional;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @OneToMany(mappedBy = "ePreguntaCerrada")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "ePreguntaCerrada" }, allowSetters = true)
+ private Set ePreguntaCerradaOpcions = new HashSet<>();
+
+ @ManyToOne
+ @JsonIgnoreProperties(
+ value = { "usuarioEncuestas", "ePreguntaAbiertas", "ePreguntaCerradas", "categoria", "usuarioExtra" },
+ allowSetters = true
+ )
+ private Encuesta encuesta;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public EPreguntaCerrada id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public EPreguntaCerrada nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public PreguntaCerradaTipo getTipo() {
+ return this.tipo;
+ }
+
+ public EPreguntaCerrada tipo(PreguntaCerradaTipo tipo) {
+ this.tipo = tipo;
+ return this;
+ }
+
+ public void setTipo(PreguntaCerradaTipo tipo) {
+ this.tipo = tipo;
+ }
+
+ public Boolean getOpcional() {
+ return this.opcional;
+ }
+
+ public EPreguntaCerrada opcional(Boolean opcional) {
+ this.opcional = opcional;
+ return this;
+ }
+
+ public void setOpcional(Boolean opcional) {
+ this.opcional = opcional;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public EPreguntaCerrada orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public Set getEPreguntaCerradaOpcions() {
+ return this.ePreguntaCerradaOpcions;
+ }
+
+ public EPreguntaCerrada ePreguntaCerradaOpcions(Set ePreguntaCerradaOpcions) {
+ this.setEPreguntaCerradaOpcions(ePreguntaCerradaOpcions);
+ return this;
+ }
+
+ public EPreguntaCerrada addEPreguntaCerradaOpcion(EPreguntaCerradaOpcion ePreguntaCerradaOpcion) {
+ this.ePreguntaCerradaOpcions.add(ePreguntaCerradaOpcion);
+ ePreguntaCerradaOpcion.setEPreguntaCerrada(this);
+ return this;
+ }
+
+ public EPreguntaCerrada removeEPreguntaCerradaOpcion(EPreguntaCerradaOpcion ePreguntaCerradaOpcion) {
+ this.ePreguntaCerradaOpcions.remove(ePreguntaCerradaOpcion);
+ ePreguntaCerradaOpcion.setEPreguntaCerrada(null);
+ return this;
+ }
+
+ public void setEPreguntaCerradaOpcions(Set ePreguntaCerradaOpcions) {
+ if (this.ePreguntaCerradaOpcions != null) {
+ this.ePreguntaCerradaOpcions.forEach(i -> i.setEPreguntaCerrada(null));
+ }
+ if (ePreguntaCerradaOpcions != null) {
+ ePreguntaCerradaOpcions.forEach(i -> i.setEPreguntaCerrada(this));
+ }
+ this.ePreguntaCerradaOpcions = ePreguntaCerradaOpcions;
+ }
+
+ public Encuesta getEncuesta() {
+ return this.encuesta;
+ }
+
+ public EPreguntaCerrada encuesta(Encuesta encuesta) {
+ this.setEncuesta(encuesta);
+ return this;
+ }
+
+ public void setEncuesta(Encuesta encuesta) {
+ this.encuesta = encuesta;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof EPreguntaCerrada)) {
+ return false;
+ }
+ return id != null && id.equals(((EPreguntaCerrada) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "EPreguntaCerrada{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", tipo='" + getTipo() + "'" +
+ ", opcional='" + getOpcional() + "'" +
+ ", orden=" + getOrden() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/EPreguntaCerradaOpcion.java b/src/main/java/org/datasurvey/domain/EPreguntaCerradaOpcion.java
new file mode 100644
index 0000000..3cccb95
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/EPreguntaCerradaOpcion.java
@@ -0,0 +1,136 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A EPreguntaCerradaOpcion.
+ */
+@Entity
+@Table(name = "e_pregunta_cerrada_opcion")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class EPreguntaCerradaOpcion implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @NotNull
+ @Column(name = "cantidad", nullable = false)
+ private Integer cantidad;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "ePreguntaCerradaOpcions", "encuesta" }, allowSetters = true)
+ private EPreguntaCerrada ePreguntaCerrada;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public EPreguntaCerradaOpcion id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public EPreguntaCerradaOpcion nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public EPreguntaCerradaOpcion orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public Integer getCantidad() {
+ return this.cantidad;
+ }
+
+ public EPreguntaCerradaOpcion cantidad(Integer cantidad) {
+ this.cantidad = cantidad;
+ return this;
+ }
+
+ public void setCantidad(Integer cantidad) {
+ this.cantidad = cantidad;
+ }
+
+ public EPreguntaCerrada getEPreguntaCerrada() {
+ return this.ePreguntaCerrada;
+ }
+
+ public EPreguntaCerradaOpcion ePreguntaCerrada(EPreguntaCerrada ePreguntaCerrada) {
+ this.setEPreguntaCerrada(ePreguntaCerrada);
+ return this;
+ }
+
+ public void setEPreguntaCerrada(EPreguntaCerrada ePreguntaCerrada) {
+ this.ePreguntaCerrada = ePreguntaCerrada;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof EPreguntaCerradaOpcion)) {
+ return false;
+ }
+ return id != null && id.equals(((EPreguntaCerradaOpcion) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "EPreguntaCerradaOpcion{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", orden=" + getOrden() +
+ ", cantidad=" + getCantidad() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/Encuesta.java b/src/main/java/org/datasurvey/domain/Encuesta.java
new file mode 100644
index 0000000..b2532c6
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/Encuesta.java
@@ -0,0 +1,389 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.AccesoEncuesta;
+import org.datasurvey.domain.enumeration.EstadoEncuesta;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A Encuesta.
+ */
+@Entity
+@Table(name = "encuesta")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class Encuesta implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 50)
+ @Column(name = "nombre", length = 50, nullable = false)
+ private String nombre;
+
+ @Column(name = "descripcion")
+ private String descripcion;
+
+ @NotNull
+ @Column(name = "fecha_creacion", nullable = false)
+ private ZonedDateTime fechaCreacion;
+
+ @Column(name = "fecha_publicacion")
+ private ZonedDateTime fechaPublicacion;
+
+ @Column(name = "fecha_finalizar")
+ private ZonedDateTime fechaFinalizar;
+
+ @Column(name = "fecha_finalizada")
+ private ZonedDateTime fechaFinalizada;
+
+ @NotNull
+ @Column(name = "calificacion", nullable = false)
+ private Double calificacion;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "acceso", nullable = false)
+ private AccesoEncuesta acceso;
+
+ @Column(name = "contrasenna")
+ private String contrasenna;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "estado", nullable = false)
+ private EstadoEncuesta estado;
+
+ @OneToMany(mappedBy = "encuesta")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "usuarioExtra", "encuesta" }, allowSetters = true)
+ private Set usuarioEncuestas = new HashSet<>();
+
+ @OneToMany(mappedBy = "encuesta")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "ePreguntaAbiertaRespuestas", "encuesta" }, allowSetters = true)
+ private Set ePreguntaAbiertas = new HashSet<>();
+
+ @OneToMany(mappedBy = "encuesta")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "ePreguntaCerradaOpcions", "encuesta" }, allowSetters = true)
+ private Set ePreguntaCerradas = new HashSet<>();
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "encuestas", "plantillas" }, allowSetters = true)
+ private Categoria categoria;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "user", "encuestas", "usuarioEncuestas", "plantillas" }, allowSetters = true)
+ private UsuarioExtra usuarioExtra;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public Encuesta id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public Encuesta nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public String getDescripcion() {
+ return this.descripcion;
+ }
+
+ public Encuesta descripcion(String descripcion) {
+ this.descripcion = descripcion;
+ return this;
+ }
+
+ public void setDescripcion(String descripcion) {
+ this.descripcion = descripcion;
+ }
+
+ public ZonedDateTime getFechaCreacion() {
+ return this.fechaCreacion;
+ }
+
+ public Encuesta fechaCreacion(ZonedDateTime fechaCreacion) {
+ this.fechaCreacion = fechaCreacion;
+ return this;
+ }
+
+ public void setFechaCreacion(ZonedDateTime fechaCreacion) {
+ this.fechaCreacion = fechaCreacion;
+ }
+
+ public ZonedDateTime getFechaPublicacion() {
+ return this.fechaPublicacion;
+ }
+
+ public Encuesta fechaPublicacion(ZonedDateTime fechaPublicacion) {
+ this.fechaPublicacion = fechaPublicacion;
+ return this;
+ }
+
+ public void setFechaPublicacion(ZonedDateTime fechaPublicacion) {
+ this.fechaPublicacion = fechaPublicacion;
+ }
+
+ public ZonedDateTime getFechaFinalizar() {
+ return this.fechaFinalizar;
+ }
+
+ public Encuesta fechaFinalizar(ZonedDateTime fechaFinalizar) {
+ this.fechaFinalizar = fechaFinalizar;
+ return this;
+ }
+
+ public void setFechaFinalizar(ZonedDateTime fechaFinalizar) {
+ this.fechaFinalizar = fechaFinalizar;
+ }
+
+ public ZonedDateTime getFechaFinalizada() {
+ return this.fechaFinalizada;
+ }
+
+ public Encuesta fechaFinalizada(ZonedDateTime fechaFinalizada) {
+ this.fechaFinalizada = fechaFinalizada;
+ return this;
+ }
+
+ public void setFechaFinalizada(ZonedDateTime fechaFinalizada) {
+ this.fechaFinalizada = fechaFinalizada;
+ }
+
+ public Double getCalificacion() {
+ return this.calificacion;
+ }
+
+ public Encuesta calificacion(Double calificacion) {
+ this.calificacion = calificacion;
+ return this;
+ }
+
+ public void setCalificacion(Double calificacion) {
+ this.calificacion = calificacion;
+ }
+
+ public AccesoEncuesta getAcceso() {
+ return this.acceso;
+ }
+
+ public Encuesta acceso(AccesoEncuesta acceso) {
+ this.acceso = acceso;
+ return this;
+ }
+
+ public void setAcceso(AccesoEncuesta acceso) {
+ this.acceso = acceso;
+ }
+
+ public String getContrasenna() {
+ return this.contrasenna;
+ }
+
+ public Encuesta contrasenna(String contrasenna) {
+ this.contrasenna = contrasenna;
+ return this;
+ }
+
+ public void setContrasenna(String contrasenna) {
+ this.contrasenna = contrasenna;
+ }
+
+ public EstadoEncuesta getEstado() {
+ return this.estado;
+ }
+
+ public Encuesta estado(EstadoEncuesta estado) {
+ this.estado = estado;
+ return this;
+ }
+
+ public void setEstado(EstadoEncuesta estado) {
+ this.estado = estado;
+ }
+
+ public Set getUsuarioEncuestas() {
+ return this.usuarioEncuestas;
+ }
+
+ public Encuesta usuarioEncuestas(Set usuarioEncuestas) {
+ this.setUsuarioEncuestas(usuarioEncuestas);
+ return this;
+ }
+
+ public Encuesta addUsuarioEncuesta(UsuarioEncuesta usuarioEncuesta) {
+ this.usuarioEncuestas.add(usuarioEncuesta);
+ usuarioEncuesta.setEncuesta(this);
+ return this;
+ }
+
+ public Encuesta removeUsuarioEncuesta(UsuarioEncuesta usuarioEncuesta) {
+ this.usuarioEncuestas.remove(usuarioEncuesta);
+ usuarioEncuesta.setEncuesta(null);
+ return this;
+ }
+
+ public void setUsuarioEncuestas(Set usuarioEncuestas) {
+ if (this.usuarioEncuestas != null) {
+ this.usuarioEncuestas.forEach(i -> i.setEncuesta(null));
+ }
+ if (usuarioEncuestas != null) {
+ usuarioEncuestas.forEach(i -> i.setEncuesta(this));
+ }
+ this.usuarioEncuestas = usuarioEncuestas;
+ }
+
+ public Set getEPreguntaAbiertas() {
+ return this.ePreguntaAbiertas;
+ }
+
+ public Encuesta ePreguntaAbiertas(Set ePreguntaAbiertas) {
+ this.setEPreguntaAbiertas(ePreguntaAbiertas);
+ return this;
+ }
+
+ public Encuesta addEPreguntaAbierta(EPreguntaAbierta ePreguntaAbierta) {
+ this.ePreguntaAbiertas.add(ePreguntaAbierta);
+ ePreguntaAbierta.setEncuesta(this);
+ return this;
+ }
+
+ public Encuesta removeEPreguntaAbierta(EPreguntaAbierta ePreguntaAbierta) {
+ this.ePreguntaAbiertas.remove(ePreguntaAbierta);
+ ePreguntaAbierta.setEncuesta(null);
+ return this;
+ }
+
+ public void setEPreguntaAbiertas(Set ePreguntaAbiertas) {
+ if (this.ePreguntaAbiertas != null) {
+ this.ePreguntaAbiertas.forEach(i -> i.setEncuesta(null));
+ }
+ if (ePreguntaAbiertas != null) {
+ ePreguntaAbiertas.forEach(i -> i.setEncuesta(this));
+ }
+ this.ePreguntaAbiertas = ePreguntaAbiertas;
+ }
+
+ public Set getEPreguntaCerradas() {
+ return this.ePreguntaCerradas;
+ }
+
+ public Encuesta ePreguntaCerradas(Set ePreguntaCerradas) {
+ this.setEPreguntaCerradas(ePreguntaCerradas);
+ return this;
+ }
+
+ public Encuesta addEPreguntaCerrada(EPreguntaCerrada ePreguntaCerrada) {
+ this.ePreguntaCerradas.add(ePreguntaCerrada);
+ ePreguntaCerrada.setEncuesta(this);
+ return this;
+ }
+
+ public Encuesta removeEPreguntaCerrada(EPreguntaCerrada ePreguntaCerrada) {
+ this.ePreguntaCerradas.remove(ePreguntaCerrada);
+ ePreguntaCerrada.setEncuesta(null);
+ return this;
+ }
+
+ public void setEPreguntaCerradas(Set ePreguntaCerradas) {
+ if (this.ePreguntaCerradas != null) {
+ this.ePreguntaCerradas.forEach(i -> i.setEncuesta(null));
+ }
+ if (ePreguntaCerradas != null) {
+ ePreguntaCerradas.forEach(i -> i.setEncuesta(this));
+ }
+ this.ePreguntaCerradas = ePreguntaCerradas;
+ }
+
+ public Categoria getCategoria() {
+ return this.categoria;
+ }
+
+ public Encuesta categoria(Categoria categoria) {
+ this.setCategoria(categoria);
+ return this;
+ }
+
+ public void setCategoria(Categoria categoria) {
+ this.categoria = categoria;
+ }
+
+ public UsuarioExtra getUsuarioExtra() {
+ return this.usuarioExtra;
+ }
+
+ public Encuesta usuarioExtra(UsuarioExtra usuarioExtra) {
+ this.setUsuarioExtra(usuarioExtra);
+ return this;
+ }
+
+ public void setUsuarioExtra(UsuarioExtra usuarioExtra) {
+ this.usuarioExtra = usuarioExtra;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Encuesta)) {
+ return false;
+ }
+ return id != null && id.equals(((Encuesta) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "Encuesta{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", descripcion='" + getDescripcion() + "'" +
+ ", fechaCreacion='" + getFechaCreacion() + "'" +
+ ", fechaPublicacion='" + getFechaPublicacion() + "'" +
+ ", fechaFinalizar='" + getFechaFinalizar() + "'" +
+ ", fechaFinalizada='" + getFechaFinalizada() + "'" +
+ ", calificacion=" + getCalificacion() +
+ ", acceso='" + getAcceso() + "'" +
+ ", contrasenna='" + getContrasenna() + "'" +
+ ", estado='" + getEstado() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/Factura.java b/src/main/java/org/datasurvey/domain/Factura.java
new file mode 100644
index 0000000..43df411
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/Factura.java
@@ -0,0 +1,136 @@
+package org.datasurvey.domain;
+
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A Factura.
+ */
+@Entity
+@Table(name = "factura")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class Factura implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Column(name = "nombre_usuario", nullable = false)
+ private String nombreUsuario;
+
+ @NotNull
+ @Column(name = "nombre_plantilla", nullable = false)
+ private String nombrePlantilla;
+
+ @NotNull
+ @Column(name = "costo", nullable = false)
+ private Double costo;
+
+ @NotNull
+ @Column(name = "fecha", nullable = false)
+ private ZonedDateTime fecha;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public Factura id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombreUsuario() {
+ return this.nombreUsuario;
+ }
+
+ public Factura nombreUsuario(String nombreUsuario) {
+ this.nombreUsuario = nombreUsuario;
+ return this;
+ }
+
+ public void setNombreUsuario(String nombreUsuario) {
+ this.nombreUsuario = nombreUsuario;
+ }
+
+ public String getNombrePlantilla() {
+ return this.nombrePlantilla;
+ }
+
+ public Factura nombrePlantilla(String nombrePlantilla) {
+ this.nombrePlantilla = nombrePlantilla;
+ return this;
+ }
+
+ public void setNombrePlantilla(String nombrePlantilla) {
+ this.nombrePlantilla = nombrePlantilla;
+ }
+
+ public Double getCosto() {
+ return this.costo;
+ }
+
+ public Factura costo(Double costo) {
+ this.costo = costo;
+ return this;
+ }
+
+ public void setCosto(Double costo) {
+ this.costo = costo;
+ }
+
+ public ZonedDateTime getFecha() {
+ return this.fecha;
+ }
+
+ public Factura fecha(ZonedDateTime fecha) {
+ this.fecha = fecha;
+ return this;
+ }
+
+ public void setFecha(ZonedDateTime fecha) {
+ this.fecha = fecha;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Factura)) {
+ return false;
+ }
+ return id != null && id.equals(((Factura) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "Factura{" +
+ "id=" + getId() +
+ ", nombreUsuario='" + getNombreUsuario() + "'" +
+ ", nombrePlantilla='" + getNombrePlantilla() + "'" +
+ ", costo=" + getCosto() +
+ ", fecha='" + getFecha() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/PPreguntaAbierta.java b/src/main/java/org/datasurvey/domain/PPreguntaAbierta.java
new file mode 100644
index 0000000..926b934
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/PPreguntaAbierta.java
@@ -0,0 +1,136 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A PPreguntaAbierta.
+ */
+@Entity
+@Table(name = "p_pregunta_abierta")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class PPreguntaAbierta implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Column(name = "opcional", nullable = false)
+ private Boolean opcional;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "pPreguntaCerradas", "pPreguntaAbiertas", "categoria", "usuarioExtras" }, allowSetters = true)
+ private Plantilla plantilla;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public PPreguntaAbierta id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public PPreguntaAbierta nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public Boolean getOpcional() {
+ return this.opcional;
+ }
+
+ public PPreguntaAbierta opcional(Boolean opcional) {
+ this.opcional = opcional;
+ return this;
+ }
+
+ public void setOpcional(Boolean opcional) {
+ this.opcional = opcional;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public PPreguntaAbierta orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public Plantilla getPlantilla() {
+ return this.plantilla;
+ }
+
+ public PPreguntaAbierta plantilla(Plantilla plantilla) {
+ this.setPlantilla(plantilla);
+ return this;
+ }
+
+ public void setPlantilla(Plantilla plantilla) {
+ this.plantilla = plantilla;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof PPreguntaAbierta)) {
+ return false;
+ }
+ return id != null && id.equals(((PPreguntaAbierta) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "PPreguntaAbierta{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", opcional='" + getOpcional() + "'" +
+ ", orden=" + getOrden() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/PPreguntaCerrada.java b/src/main/java/org/datasurvey/domain/PPreguntaCerrada.java
new file mode 100644
index 0000000..21f4b8a
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/PPreguntaCerrada.java
@@ -0,0 +1,194 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.PreguntaCerradaTipo;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A PPreguntaCerrada.
+ */
+@Entity
+@Table(name = "p_pregunta_cerrada")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class PPreguntaCerrada implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "tipo", nullable = false)
+ private PreguntaCerradaTipo tipo;
+
+ @NotNull
+ @Column(name = "opcional", nullable = false)
+ private Boolean opcional;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @OneToMany(mappedBy = "pPreguntaCerrada")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "pPreguntaCerrada" }, allowSetters = true)
+ private Set pPreguntaCerradaOpcions = new HashSet<>();
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "pPreguntaCerradas", "pPreguntaAbiertas", "categoria", "usuarioExtras" }, allowSetters = true)
+ private Plantilla plantilla;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public PPreguntaCerrada id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public PPreguntaCerrada nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public PreguntaCerradaTipo getTipo() {
+ return this.tipo;
+ }
+
+ public PPreguntaCerrada tipo(PreguntaCerradaTipo tipo) {
+ this.tipo = tipo;
+ return this;
+ }
+
+ public void setTipo(PreguntaCerradaTipo tipo) {
+ this.tipo = tipo;
+ }
+
+ public Boolean getOpcional() {
+ return this.opcional;
+ }
+
+ public PPreguntaCerrada opcional(Boolean opcional) {
+ this.opcional = opcional;
+ return this;
+ }
+
+ public void setOpcional(Boolean opcional) {
+ this.opcional = opcional;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public PPreguntaCerrada orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public Set getPPreguntaCerradaOpcions() {
+ return this.pPreguntaCerradaOpcions;
+ }
+
+ public PPreguntaCerrada pPreguntaCerradaOpcions(Set pPreguntaCerradaOpcions) {
+ this.setPPreguntaCerradaOpcions(pPreguntaCerradaOpcions);
+ return this;
+ }
+
+ public PPreguntaCerrada addPPreguntaCerradaOpcion(PPreguntaCerradaOpcion pPreguntaCerradaOpcion) {
+ this.pPreguntaCerradaOpcions.add(pPreguntaCerradaOpcion);
+ pPreguntaCerradaOpcion.setPPreguntaCerrada(this);
+ return this;
+ }
+
+ public PPreguntaCerrada removePPreguntaCerradaOpcion(PPreguntaCerradaOpcion pPreguntaCerradaOpcion) {
+ this.pPreguntaCerradaOpcions.remove(pPreguntaCerradaOpcion);
+ pPreguntaCerradaOpcion.setPPreguntaCerrada(null);
+ return this;
+ }
+
+ public void setPPreguntaCerradaOpcions(Set pPreguntaCerradaOpcions) {
+ if (this.pPreguntaCerradaOpcions != null) {
+ this.pPreguntaCerradaOpcions.forEach(i -> i.setPPreguntaCerrada(null));
+ }
+ if (pPreguntaCerradaOpcions != null) {
+ pPreguntaCerradaOpcions.forEach(i -> i.setPPreguntaCerrada(this));
+ }
+ this.pPreguntaCerradaOpcions = pPreguntaCerradaOpcions;
+ }
+
+ public Plantilla getPlantilla() {
+ return this.plantilla;
+ }
+
+ public PPreguntaCerrada plantilla(Plantilla plantilla) {
+ this.setPlantilla(plantilla);
+ return this;
+ }
+
+ public void setPlantilla(Plantilla plantilla) {
+ this.plantilla = plantilla;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof PPreguntaCerrada)) {
+ return false;
+ }
+ return id != null && id.equals(((PPreguntaCerrada) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "PPreguntaCerrada{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", tipo='" + getTipo() + "'" +
+ ", opcional='" + getOpcional() + "'" +
+ ", orden=" + getOrden() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/PPreguntaCerradaOpcion.java b/src/main/java/org/datasurvey/domain/PPreguntaCerradaOpcion.java
new file mode 100644
index 0000000..162eaa7
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/PPreguntaCerradaOpcion.java
@@ -0,0 +1,118 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A PPreguntaCerradaOpcion.
+ */
+@Entity
+@Table(name = "p_pregunta_cerrada_opcion")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class PPreguntaCerradaOpcion implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Size(min = 1, max = 500)
+ @Column(name = "nombre", length = 500, nullable = false)
+ private String nombre;
+
+ @NotNull
+ @Column(name = "orden", nullable = false)
+ private Integer orden;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "pPreguntaCerradaOpcions", "plantilla" }, allowSetters = true)
+ private PPreguntaCerrada pPreguntaCerrada;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public PPreguntaCerradaOpcion id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public PPreguntaCerradaOpcion nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public Integer getOrden() {
+ return this.orden;
+ }
+
+ public PPreguntaCerradaOpcion orden(Integer orden) {
+ this.orden = orden;
+ return this;
+ }
+
+ public void setOrden(Integer orden) {
+ this.orden = orden;
+ }
+
+ public PPreguntaCerrada getPPreguntaCerrada() {
+ return this.pPreguntaCerrada;
+ }
+
+ public PPreguntaCerradaOpcion pPreguntaCerrada(PPreguntaCerrada pPreguntaCerrada) {
+ this.setPPreguntaCerrada(pPreguntaCerrada);
+ return this;
+ }
+
+ public void setPPreguntaCerrada(PPreguntaCerrada pPreguntaCerrada) {
+ this.pPreguntaCerrada = pPreguntaCerrada;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof PPreguntaCerradaOpcion)) {
+ return false;
+ }
+ return id != null && id.equals(((PPreguntaCerradaOpcion) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "PPreguntaCerradaOpcion{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", orden=" + getOrden() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/ParametroAplicacion.java b/src/main/java/org/datasurvey/domain/ParametroAplicacion.java
new file mode 100644
index 0000000..ceb3ccb
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/ParametroAplicacion.java
@@ -0,0 +1,135 @@
+package org.datasurvey.domain;
+
+import java.io.Serializable;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A ParametroAplicacion.
+ */
+@Entity
+@Table(name = "parametro_aplicacion")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class ParametroAplicacion implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Column(name = "max_dias_encuesta", nullable = false)
+ private Integer maxDiasEncuesta;
+
+ @NotNull
+ @Column(name = "min_dias_encuesta", nullable = false)
+ private Integer minDiasEncuesta;
+
+ @NotNull
+ @Column(name = "max_cantidad_preguntas", nullable = false)
+ private Integer maxCantidadPreguntas;
+
+ @NotNull
+ @Column(name = "min_cantidad_preguntas", nullable = false)
+ private Integer minCantidadPreguntas;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public ParametroAplicacion id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public Integer getMaxDiasEncuesta() {
+ return this.maxDiasEncuesta;
+ }
+
+ public ParametroAplicacion maxDiasEncuesta(Integer maxDiasEncuesta) {
+ this.maxDiasEncuesta = maxDiasEncuesta;
+ return this;
+ }
+
+ public void setMaxDiasEncuesta(Integer maxDiasEncuesta) {
+ this.maxDiasEncuesta = maxDiasEncuesta;
+ }
+
+ public Integer getMinDiasEncuesta() {
+ return this.minDiasEncuesta;
+ }
+
+ public ParametroAplicacion minDiasEncuesta(Integer minDiasEncuesta) {
+ this.minDiasEncuesta = minDiasEncuesta;
+ return this;
+ }
+
+ public void setMinDiasEncuesta(Integer minDiasEncuesta) {
+ this.minDiasEncuesta = minDiasEncuesta;
+ }
+
+ public Integer getMaxCantidadPreguntas() {
+ return this.maxCantidadPreguntas;
+ }
+
+ public ParametroAplicacion maxCantidadPreguntas(Integer maxCantidadPreguntas) {
+ this.maxCantidadPreguntas = maxCantidadPreguntas;
+ return this;
+ }
+
+ public void setMaxCantidadPreguntas(Integer maxCantidadPreguntas) {
+ this.maxCantidadPreguntas = maxCantidadPreguntas;
+ }
+
+ public Integer getMinCantidadPreguntas() {
+ return this.minCantidadPreguntas;
+ }
+
+ public ParametroAplicacion minCantidadPreguntas(Integer minCantidadPreguntas) {
+ this.minCantidadPreguntas = minCantidadPreguntas;
+ return this;
+ }
+
+ public void setMinCantidadPreguntas(Integer minCantidadPreguntas) {
+ this.minCantidadPreguntas = minCantidadPreguntas;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof ParametroAplicacion)) {
+ return false;
+ }
+ return id != null && id.equals(((ParametroAplicacion) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "ParametroAplicacion{" +
+ "id=" + getId() +
+ ", maxDiasEncuesta=" + getMaxDiasEncuesta() +
+ ", minDiasEncuesta=" + getMinDiasEncuesta() +
+ ", maxCantidadPreguntas=" + getMaxCantidadPreguntas() +
+ ", minCantidadPreguntas=" + getMinCantidadPreguntas() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/Plantilla.java b/src/main/java/org/datasurvey/domain/Plantilla.java
new file mode 100644
index 0000000..4f6df9c
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/Plantilla.java
@@ -0,0 +1,300 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.EstadoPlantilla;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A Plantilla.
+ */
+@Entity
+@Table(name = "plantilla")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class Plantilla implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Size(min = 1, max = 50)
+ @Column(name = "nombre", length = 50)
+ private String nombre;
+
+ @Column(name = "descripcion")
+ private String descripcion;
+
+ @NotNull
+ @Column(name = "fecha_creacion", nullable = false)
+ private ZonedDateTime fechaCreacion;
+
+ @Column(name = "fecha_publicacion_tienda")
+ private ZonedDateTime fechaPublicacionTienda;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "estado", nullable = false)
+ private EstadoPlantilla estado;
+
+ @NotNull
+ @Column(name = "precio", nullable = false)
+ private Double precio;
+
+ @OneToMany(mappedBy = "plantilla")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "pPreguntaCerradaOpcions", "plantilla" }, allowSetters = true)
+ private Set pPreguntaCerradas = new HashSet<>();
+
+ @OneToMany(mappedBy = "plantilla")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "plantilla" }, allowSetters = true)
+ private Set pPreguntaAbiertas = new HashSet<>();
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "encuestas", "plantillas" }, allowSetters = true)
+ private Categoria categoria;
+
+ @ManyToMany(mappedBy = "plantillas")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "user", "encuestas", "usuarioEncuestas", "plantillas" }, allowSetters = true)
+ private Set usuarioExtras = new HashSet<>();
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public Plantilla id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public Plantilla nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public String getDescripcion() {
+ return this.descripcion;
+ }
+
+ public Plantilla descripcion(String descripcion) {
+ this.descripcion = descripcion;
+ return this;
+ }
+
+ public void setDescripcion(String descripcion) {
+ this.descripcion = descripcion;
+ }
+
+ public ZonedDateTime getFechaCreacion() {
+ return this.fechaCreacion;
+ }
+
+ public Plantilla fechaCreacion(ZonedDateTime fechaCreacion) {
+ this.fechaCreacion = fechaCreacion;
+ return this;
+ }
+
+ public void setFechaCreacion(ZonedDateTime fechaCreacion) {
+ this.fechaCreacion = fechaCreacion;
+ }
+
+ public ZonedDateTime getFechaPublicacionTienda() {
+ return this.fechaPublicacionTienda;
+ }
+
+ public Plantilla fechaPublicacionTienda(ZonedDateTime fechaPublicacionTienda) {
+ this.fechaPublicacionTienda = fechaPublicacionTienda;
+ return this;
+ }
+
+ public void setFechaPublicacionTienda(ZonedDateTime fechaPublicacionTienda) {
+ this.fechaPublicacionTienda = fechaPublicacionTienda;
+ }
+
+ public EstadoPlantilla getEstado() {
+ return this.estado;
+ }
+
+ public Plantilla estado(EstadoPlantilla estado) {
+ this.estado = estado;
+ return this;
+ }
+
+ public void setEstado(EstadoPlantilla estado) {
+ this.estado = estado;
+ }
+
+ public Double getPrecio() {
+ return this.precio;
+ }
+
+ public Plantilla precio(Double precio) {
+ this.precio = precio;
+ return this;
+ }
+
+ public void setPrecio(Double precio) {
+ this.precio = precio;
+ }
+
+ public Set getPPreguntaCerradas() {
+ return this.pPreguntaCerradas;
+ }
+
+ public Plantilla pPreguntaCerradas(Set pPreguntaCerradas) {
+ this.setPPreguntaCerradas(pPreguntaCerradas);
+ return this;
+ }
+
+ public Plantilla addPPreguntaCerrada(PPreguntaCerrada pPreguntaCerrada) {
+ this.pPreguntaCerradas.add(pPreguntaCerrada);
+ pPreguntaCerrada.setPlantilla(this);
+ return this;
+ }
+
+ public Plantilla removePPreguntaCerrada(PPreguntaCerrada pPreguntaCerrada) {
+ this.pPreguntaCerradas.remove(pPreguntaCerrada);
+ pPreguntaCerrada.setPlantilla(null);
+ return this;
+ }
+
+ public void setPPreguntaCerradas(Set pPreguntaCerradas) {
+ if (this.pPreguntaCerradas != null) {
+ this.pPreguntaCerradas.forEach(i -> i.setPlantilla(null));
+ }
+ if (pPreguntaCerradas != null) {
+ pPreguntaCerradas.forEach(i -> i.setPlantilla(this));
+ }
+ this.pPreguntaCerradas = pPreguntaCerradas;
+ }
+
+ public Set getPPreguntaAbiertas() {
+ return this.pPreguntaAbiertas;
+ }
+
+ public Plantilla pPreguntaAbiertas(Set pPreguntaAbiertas) {
+ this.setPPreguntaAbiertas(pPreguntaAbiertas);
+ return this;
+ }
+
+ public Plantilla addPPreguntaAbierta(PPreguntaAbierta pPreguntaAbierta) {
+ this.pPreguntaAbiertas.add(pPreguntaAbierta);
+ pPreguntaAbierta.setPlantilla(this);
+ return this;
+ }
+
+ public Plantilla removePPreguntaAbierta(PPreguntaAbierta pPreguntaAbierta) {
+ this.pPreguntaAbiertas.remove(pPreguntaAbierta);
+ pPreguntaAbierta.setPlantilla(null);
+ return this;
+ }
+
+ public void setPPreguntaAbiertas(Set pPreguntaAbiertas) {
+ if (this.pPreguntaAbiertas != null) {
+ this.pPreguntaAbiertas.forEach(i -> i.setPlantilla(null));
+ }
+ if (pPreguntaAbiertas != null) {
+ pPreguntaAbiertas.forEach(i -> i.setPlantilla(this));
+ }
+ this.pPreguntaAbiertas = pPreguntaAbiertas;
+ }
+
+ public Categoria getCategoria() {
+ return this.categoria;
+ }
+
+ public Plantilla categoria(Categoria categoria) {
+ this.setCategoria(categoria);
+ return this;
+ }
+
+ public void setCategoria(Categoria categoria) {
+ this.categoria = categoria;
+ }
+
+ public Set getUsuarioExtras() {
+ return this.usuarioExtras;
+ }
+
+ public Plantilla usuarioExtras(Set usuarioExtras) {
+ this.setUsuarioExtras(usuarioExtras);
+ return this;
+ }
+
+ public Plantilla addUsuarioExtra(UsuarioExtra usuarioExtra) {
+ this.usuarioExtras.add(usuarioExtra);
+ usuarioExtra.getPlantillas().add(this);
+ return this;
+ }
+
+ public Plantilla removeUsuarioExtra(UsuarioExtra usuarioExtra) {
+ this.usuarioExtras.remove(usuarioExtra);
+ usuarioExtra.getPlantillas().remove(this);
+ return this;
+ }
+
+ public void setUsuarioExtras(Set usuarioExtras) {
+ if (this.usuarioExtras != null) {
+ this.usuarioExtras.forEach(i -> i.removePlantilla(this));
+ }
+ if (usuarioExtras != null) {
+ usuarioExtras.forEach(i -> i.addPlantilla(this));
+ }
+ this.usuarioExtras = usuarioExtras;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof Plantilla)) {
+ return false;
+ }
+ return id != null && id.equals(((Plantilla) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "Plantilla{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", descripcion='" + getDescripcion() + "'" +
+ ", fechaCreacion='" + getFechaCreacion() + "'" +
+ ", fechaPublicacionTienda='" + getFechaPublicacionTienda() + "'" +
+ ", estado='" + getEstado() + "'" +
+ ", precio=" + getPrecio() +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/User.java b/src/main/java/org/datasurvey/domain/User.java
new file mode 100644
index 0000000..52ee1a3
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/User.java
@@ -0,0 +1,231 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import java.io.Serializable;
+import java.time.Instant;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Pattern;
+import javax.validation.constraints.Size;
+import org.apache.commons.lang3.StringUtils;
+import org.datasurvey.config.Constants;
+import org.hibernate.annotations.BatchSize;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A user.
+ */
+@Entity
+@Table(name = "jhi_user")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+public class User extends AbstractAuditingEntity implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Pattern(regexp = Constants.LOGIN_REGEX)
+ @Size(min = 1, max = 50)
+ @Column(length = 50, unique = true, nullable = false)
+ private String login;
+
+ @JsonIgnore
+ @NotNull
+ @Size(min = 60, max = 60)
+ @Column(name = "password_hash", length = 60, nullable = false)
+ private String password;
+
+ @Size(max = 50)
+ @Column(name = "first_name", length = 50)
+ private String firstName;
+
+ @Size(max = 50)
+ @Column(name = "last_name", length = 50)
+ private String lastName;
+
+ @Email
+ @Size(min = 5, max = 254)
+ @Column(length = 254, unique = true)
+ private String email;
+
+ @NotNull
+ @Column(nullable = false)
+ private boolean activated = false;
+
+ @Size(min = 2, max = 10)
+ @Column(name = "lang_key", length = 10)
+ private String langKey;
+
+ @Size(max = 256)
+ @Column(name = "image_url", length = 256)
+ private String imageUrl;
+
+ @Size(max = 20)
+ @Column(name = "activation_key", length = 20)
+ @JsonIgnore
+ private String activationKey;
+
+ @Size(max = 20)
+ @Column(name = "reset_key", length = 20)
+ @JsonIgnore
+ private String resetKey;
+
+ @Column(name = "reset_date")
+ private Instant resetDate = null;
+
+ @JsonIgnore
+ @ManyToMany
+ @JoinTable(
+ name = "jhi_user_authority",
+ joinColumns = { @JoinColumn(name = "user_id", referencedColumnName = "id") },
+ inverseJoinColumns = { @JoinColumn(name = "authority_name", referencedColumnName = "name") }
+ )
+ @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+ @BatchSize(size = 20)
+ private Set authorities = new HashSet<>();
+
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public String getLogin() {
+ return login;
+ }
+
+ // Lowercase the login before saving it in database
+ public void setLogin(String login) {
+ this.login = StringUtils.lowerCase(login, Locale.ENGLISH);
+ }
+
+ public String getPassword() {
+ return password;
+ }
+
+ public void setPassword(String password) {
+ this.password = password;
+ }
+
+ public String getFirstName() {
+ return firstName;
+ }
+
+ public void setFirstName(String firstName) {
+ this.firstName = firstName;
+ }
+
+ public String getLastName() {
+ return lastName;
+ }
+
+ public void setLastName(String lastName) {
+ this.lastName = lastName;
+ }
+
+ public String getEmail() {
+ return email;
+ }
+
+ public void setEmail(String email) {
+ this.email = email;
+ }
+
+ public String getImageUrl() {
+ return imageUrl;
+ }
+
+ public void setImageUrl(String imageUrl) {
+ this.imageUrl = imageUrl;
+ }
+
+ public boolean isActivated() {
+ return activated;
+ }
+
+ public void setActivated(boolean activated) {
+ this.activated = activated;
+ }
+
+ public String getActivationKey() {
+ return activationKey;
+ }
+
+ public void setActivationKey(String activationKey) {
+ this.activationKey = activationKey;
+ }
+
+ public String getResetKey() {
+ return resetKey;
+ }
+
+ public void setResetKey(String resetKey) {
+ this.resetKey = resetKey;
+ }
+
+ public Instant getResetDate() {
+ return resetDate;
+ }
+
+ public void setResetDate(Instant resetDate) {
+ this.resetDate = resetDate;
+ }
+
+ public String getLangKey() {
+ return langKey;
+ }
+
+ public void setLangKey(String langKey) {
+ this.langKey = langKey;
+ }
+
+ public Set getAuthorities() {
+ return authorities;
+ }
+
+ public void setAuthorities(Set authorities) {
+ this.authorities = authorities;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof User)) {
+ return false;
+ }
+ return id != null && id.equals(((User) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "User{" +
+ "login='" + login + '\'' +
+ ", firstName='" + firstName + '\'' +
+ ", lastName='" + lastName + '\'' +
+ ", email='" + email + '\'' +
+ ", imageUrl='" + imageUrl + '\'' +
+ ", activated='" + activated + '\'' +
+ ", langKey='" + langKey + '\'' +
+ ", activationKey='" + activationKey + '\'' +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/UsuarioEncuesta.java b/src/main/java/org/datasurvey/domain/UsuarioEncuesta.java
new file mode 100644
index 0000000..d1522eb
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/UsuarioEncuesta.java
@@ -0,0 +1,160 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.EstadoColaborador;
+import org.datasurvey.domain.enumeration.RolColaborador;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A UsuarioEncuesta.
+ */
+@Entity
+@Table(name = "usuario_encuesta")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class UsuarioEncuesta implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "rol", nullable = false)
+ private RolColaborador rol;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "estado", nullable = false)
+ private EstadoColaborador estado;
+
+ @NotNull
+ @Column(name = "fecha_agregado", nullable = false)
+ private ZonedDateTime fechaAgregado;
+
+ @ManyToOne
+ @JsonIgnoreProperties(value = { "user", "encuestas", "usuarioEncuestas", "plantillas" }, allowSetters = true)
+ private UsuarioExtra usuarioExtra;
+
+ @ManyToOne
+ @JsonIgnoreProperties(
+ value = { "usuarioEncuestas", "ePreguntaAbiertas", "ePreguntaCerradas", "categoria", "usuarioExtra" },
+ allowSetters = true
+ )
+ private Encuesta encuesta;
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public UsuarioEncuesta id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public RolColaborador getRol() {
+ return this.rol;
+ }
+
+ public UsuarioEncuesta rol(RolColaborador rol) {
+ this.rol = rol;
+ return this;
+ }
+
+ public void setRol(RolColaborador rol) {
+ this.rol = rol;
+ }
+
+ public EstadoColaborador getEstado() {
+ return this.estado;
+ }
+
+ public UsuarioEncuesta estado(EstadoColaborador estado) {
+ this.estado = estado;
+ return this;
+ }
+
+ public void setEstado(EstadoColaborador estado) {
+ this.estado = estado;
+ }
+
+ public ZonedDateTime getFechaAgregado() {
+ return this.fechaAgregado;
+ }
+
+ public UsuarioEncuesta fechaAgregado(ZonedDateTime fechaAgregado) {
+ this.fechaAgregado = fechaAgregado;
+ return this;
+ }
+
+ public void setFechaAgregado(ZonedDateTime fechaAgregado) {
+ this.fechaAgregado = fechaAgregado;
+ }
+
+ public UsuarioExtra getUsuarioExtra() {
+ return this.usuarioExtra;
+ }
+
+ public UsuarioEncuesta usuarioExtra(UsuarioExtra usuarioExtra) {
+ this.setUsuarioExtra(usuarioExtra);
+ return this;
+ }
+
+ public void setUsuarioExtra(UsuarioExtra usuarioExtra) {
+ this.usuarioExtra = usuarioExtra;
+ }
+
+ public Encuesta getEncuesta() {
+ return this.encuesta;
+ }
+
+ public UsuarioEncuesta encuesta(Encuesta encuesta) {
+ this.setEncuesta(encuesta);
+ return this;
+ }
+
+ public void setEncuesta(Encuesta encuesta) {
+ this.encuesta = encuesta;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof UsuarioEncuesta)) {
+ return false;
+ }
+ return id != null && id.equals(((UsuarioEncuesta) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "UsuarioEncuesta{" +
+ "id=" + getId() +
+ ", rol='" + getRol() + "'" +
+ ", estado='" + getEstado() + "'" +
+ ", fechaAgregado='" + getFechaAgregado() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/UsuarioExtra.java b/src/main/java/org/datasurvey/domain/UsuarioExtra.java
new file mode 100644
index 0000000..95597cc
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/UsuarioExtra.java
@@ -0,0 +1,266 @@
+package org.datasurvey.domain;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import java.io.Serializable;
+import java.time.ZonedDateTime;
+import java.util.HashSet;
+import java.util.Set;
+import javax.persistence.*;
+import javax.validation.constraints.*;
+import org.datasurvey.domain.enumeration.EstadoUsuario;
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+/**
+ * A UsuarioExtra.
+ */
+@Entity
+@Table(name = "usuario_extra")
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+public class UsuarioExtra implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @NotNull
+ @Column(name = "nombre", nullable = false)
+ private String nombre;
+
+ @Column(name = "icono_perfil")
+ private String iconoPerfil;
+
+ @Column(name = "fecha_nacimiento")
+ private ZonedDateTime fechaNacimiento;
+
+ @NotNull
+ @Enumerated(EnumType.STRING)
+ @Column(name = "estado", nullable = false)
+ private EstadoUsuario estado;
+
+ @OneToOne
+ @JoinColumn(unique = true)
+ private User user;
+
+ @OneToMany(mappedBy = "usuarioExtra")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(
+ value = { "usuarioEncuestas", "ePreguntaAbiertas", "ePreguntaCerradas", "categoria", "usuarioExtra" },
+ allowSetters = true
+ )
+ private Set encuestas = new HashSet<>();
+
+ @OneToMany(mappedBy = "usuarioExtra")
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JsonIgnoreProperties(value = { "usuarioExtra", "encuesta" }, allowSetters = true)
+ private Set usuarioEncuestas = new HashSet<>();
+
+ @ManyToMany
+ @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+ @JoinTable(
+ name = "rel_usuario_extra__plantilla",
+ joinColumns = @JoinColumn(name = "usuario_extra_id"),
+ inverseJoinColumns = @JoinColumn(name = "plantilla_id")
+ )
+ @JsonIgnoreProperties(value = { "pPreguntaCerradas", "pPreguntaAbiertas", "categoria", "usuarioExtras" }, allowSetters = true)
+ private Set plantillas = new HashSet<>();
+
+ // jhipster-needle-entity-add-field - JHipster will add fields here
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public UsuarioExtra id(Long id) {
+ this.id = id;
+ return this;
+ }
+
+ public String getNombre() {
+ return this.nombre;
+ }
+
+ public UsuarioExtra nombre(String nombre) {
+ this.nombre = nombre;
+ return this;
+ }
+
+ public void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ public String getIconoPerfil() {
+ return this.iconoPerfil;
+ }
+
+ public UsuarioExtra iconoPerfil(String iconoPerfil) {
+ this.iconoPerfil = iconoPerfil;
+ return this;
+ }
+
+ public void setIconoPerfil(String iconoPerfil) {
+ this.iconoPerfil = iconoPerfil;
+ }
+
+ public ZonedDateTime getFechaNacimiento() {
+ return this.fechaNacimiento;
+ }
+
+ public UsuarioExtra fechaNacimiento(ZonedDateTime fechaNacimiento) {
+ this.fechaNacimiento = fechaNacimiento;
+ return this;
+ }
+
+ public void setFechaNacimiento(ZonedDateTime fechaNacimiento) {
+ this.fechaNacimiento = fechaNacimiento;
+ }
+
+ public EstadoUsuario getEstado() {
+ return this.estado;
+ }
+
+ public UsuarioExtra estado(EstadoUsuario estado) {
+ this.estado = estado;
+ return this;
+ }
+
+ public void setEstado(EstadoUsuario estado) {
+ this.estado = estado;
+ }
+
+ public User getUser() {
+ return this.user;
+ }
+
+ public UsuarioExtra user(User user) {
+ this.setUser(user);
+ return this;
+ }
+
+ public void setUser(User user) {
+ this.user = user;
+ }
+
+ public Set getEncuestas() {
+ return this.encuestas;
+ }
+
+ public UsuarioExtra encuestas(Set encuestas) {
+ this.setEncuestas(encuestas);
+ return this;
+ }
+
+ public UsuarioExtra addEncuesta(Encuesta encuesta) {
+ this.encuestas.add(encuesta);
+ encuesta.setUsuarioExtra(this);
+ return this;
+ }
+
+ public UsuarioExtra removeEncuesta(Encuesta encuesta) {
+ this.encuestas.remove(encuesta);
+ encuesta.setUsuarioExtra(null);
+ return this;
+ }
+
+ public void setEncuestas(Set encuestas) {
+ if (this.encuestas != null) {
+ this.encuestas.forEach(i -> i.setUsuarioExtra(null));
+ }
+ if (encuestas != null) {
+ encuestas.forEach(i -> i.setUsuarioExtra(this));
+ }
+ this.encuestas = encuestas;
+ }
+
+ public Set getUsuarioEncuestas() {
+ return this.usuarioEncuestas;
+ }
+
+ public UsuarioExtra usuarioEncuestas(Set usuarioEncuestas) {
+ this.setUsuarioEncuestas(usuarioEncuestas);
+ return this;
+ }
+
+ public UsuarioExtra addUsuarioEncuesta(UsuarioEncuesta usuarioEncuesta) {
+ this.usuarioEncuestas.add(usuarioEncuesta);
+ usuarioEncuesta.setUsuarioExtra(this);
+ return this;
+ }
+
+ public UsuarioExtra removeUsuarioEncuesta(UsuarioEncuesta usuarioEncuesta) {
+ this.usuarioEncuestas.remove(usuarioEncuesta);
+ usuarioEncuesta.setUsuarioExtra(null);
+ return this;
+ }
+
+ public void setUsuarioEncuestas(Set usuarioEncuestas) {
+ if (this.usuarioEncuestas != null) {
+ this.usuarioEncuestas.forEach(i -> i.setUsuarioExtra(null));
+ }
+ if (usuarioEncuestas != null) {
+ usuarioEncuestas.forEach(i -> i.setUsuarioExtra(this));
+ }
+ this.usuarioEncuestas = usuarioEncuestas;
+ }
+
+ public Set getPlantillas() {
+ return this.plantillas;
+ }
+
+ public UsuarioExtra plantillas(Set plantillas) {
+ this.setPlantillas(plantillas);
+ return this;
+ }
+
+ public UsuarioExtra addPlantilla(Plantilla plantilla) {
+ this.plantillas.add(plantilla);
+ plantilla.getUsuarioExtras().add(this);
+ return this;
+ }
+
+ public UsuarioExtra removePlantilla(Plantilla plantilla) {
+ this.plantillas.remove(plantilla);
+ plantilla.getUsuarioExtras().remove(this);
+ return this;
+ }
+
+ public void setPlantillas(Set plantillas) {
+ this.plantillas = plantillas;
+ }
+
+ // jhipster-needle-entity-add-getters-setters - JHipster will add getters and setters here
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (!(o instanceof UsuarioExtra)) {
+ return false;
+ }
+ return id != null && id.equals(((UsuarioExtra) o).id);
+ }
+
+ @Override
+ public int hashCode() {
+ // see https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/
+ return getClass().hashCode();
+ }
+
+ // prettier-ignore
+ @Override
+ public String toString() {
+ return "UsuarioExtra{" +
+ "id=" + getId() +
+ ", nombre='" + getNombre() + "'" +
+ ", iconoPerfil='" + getIconoPerfil() + "'" +
+ ", fechaNacimiento='" + getFechaNacimiento() + "'" +
+ ", estado='" + getEstado() + "'" +
+ "}";
+ }
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/AccesoEncuesta.java b/src/main/java/org/datasurvey/domain/enumeration/AccesoEncuesta.java
new file mode 100644
index 0000000..e26470a
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/AccesoEncuesta.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The AccesoEncuesta enumeration.
+ */
+public enum AccesoEncuesta {
+ PUBLIC,
+ PRIVATE,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/EstadoCategoria.java b/src/main/java/org/datasurvey/domain/enumeration/EstadoCategoria.java
new file mode 100644
index 0000000..3482d43
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/EstadoCategoria.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The EstadoCategoria enumeration.
+ */
+public enum EstadoCategoria {
+ ACTIVE,
+ INACTIVE,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/EstadoColaborador.java b/src/main/java/org/datasurvey/domain/enumeration/EstadoColaborador.java
new file mode 100644
index 0000000..bfd4c5c
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/EstadoColaborador.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The EstadoColaborador enumeration.
+ */
+public enum EstadoColaborador {
+ PENDING,
+ ACTIVE,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/EstadoEncuesta.java b/src/main/java/org/datasurvey/domain/enumeration/EstadoEncuesta.java
new file mode 100644
index 0000000..aec71ab
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/EstadoEncuesta.java
@@ -0,0 +1,11 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The EstadoEncuesta enumeration.
+ */
+public enum EstadoEncuesta {
+ DRAFT,
+ ACTIVE,
+ FINISHED,
+ DELETED,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/EstadoPlantilla.java b/src/main/java/org/datasurvey/domain/enumeration/EstadoPlantilla.java
new file mode 100644
index 0000000..e070807
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/EstadoPlantilla.java
@@ -0,0 +1,11 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The EstadoPlantilla enumeration.
+ */
+public enum EstadoPlantilla {
+ DRAFT,
+ ACTIVE,
+ DELETED,
+ DISABLED,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/EstadoUsuario.java b/src/main/java/org/datasurvey/domain/enumeration/EstadoUsuario.java
new file mode 100644
index 0000000..78bbf12
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/EstadoUsuario.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The EstadoUsuario enumeration.
+ */
+public enum EstadoUsuario {
+ ACTIVE,
+ SUSPENDED,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/PreguntaCerradaTipo.java b/src/main/java/org/datasurvey/domain/enumeration/PreguntaCerradaTipo.java
new file mode 100644
index 0000000..9780d06
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/PreguntaCerradaTipo.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The PreguntaCerradaTipo enumeration.
+ */
+public enum PreguntaCerradaTipo {
+ SINGLE,
+ MULTIPLE,
+}
diff --git a/src/main/java/org/datasurvey/domain/enumeration/RolColaborador.java b/src/main/java/org/datasurvey/domain/enumeration/RolColaborador.java
new file mode 100644
index 0000000..9fef157
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/enumeration/RolColaborador.java
@@ -0,0 +1,9 @@
+package org.datasurvey.domain.enumeration;
+
+/**
+ * The RolColaborador enumeration.
+ */
+public enum RolColaborador {
+ READ,
+ WRITE,
+}
diff --git a/src/main/java/org/datasurvey/domain/package-info.java b/src/main/java/org/datasurvey/domain/package-info.java
new file mode 100644
index 0000000..41498c6
--- /dev/null
+++ b/src/main/java/org/datasurvey/domain/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * JPA domain objects.
+ */
+package org.datasurvey.domain;
diff --git a/src/main/java/org/datasurvey/repository/AuthorityRepository.java b/src/main/java/org/datasurvey/repository/AuthorityRepository.java
new file mode 100644
index 0000000..941da55
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/AuthorityRepository.java
@@ -0,0 +1,9 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.Authority;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+/**
+ * Spring Data JPA repository for the {@link Authority} entity.
+ */
+public interface AuthorityRepository extends JpaRepository {}
diff --git a/src/main/java/org/datasurvey/repository/CategoriaRepository.java b/src/main/java/org/datasurvey/repository/CategoriaRepository.java
new file mode 100644
index 0000000..66368c1
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/CategoriaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.Categoria;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the Categoria entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface CategoriaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRepository.java b/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRepository.java
new file mode 100644
index 0000000..82cd91d
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.EPreguntaAbierta;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the EPreguntaAbierta entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface EPreguntaAbiertaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRespuestaRepository.java b/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRespuestaRepository.java
new file mode 100644
index 0000000..ba3c92b
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/EPreguntaAbiertaRespuestaRepository.java
@@ -0,0 +1,13 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.EPreguntaAbiertaRespuesta;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the EPreguntaAbiertaRespuesta entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface EPreguntaAbiertaRespuestaRepository
+ extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/EPreguntaCerradaOpcionRepository.java b/src/main/java/org/datasurvey/repository/EPreguntaCerradaOpcionRepository.java
new file mode 100644
index 0000000..5878bd9
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/EPreguntaCerradaOpcionRepository.java
@@ -0,0 +1,13 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.EPreguntaCerradaOpcion;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the EPreguntaCerradaOpcion entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface EPreguntaCerradaOpcionRepository
+ extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/EPreguntaCerradaRepository.java b/src/main/java/org/datasurvey/repository/EPreguntaCerradaRepository.java
new file mode 100644
index 0000000..a793b4f
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/EPreguntaCerradaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.EPreguntaCerrada;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the EPreguntaCerrada entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface EPreguntaCerradaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/EncuestaRepository.java b/src/main/java/org/datasurvey/repository/EncuestaRepository.java
new file mode 100644
index 0000000..7e89fcc
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/EncuestaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.Encuesta;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the Encuesta entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface EncuestaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/FacturaRepository.java b/src/main/java/org/datasurvey/repository/FacturaRepository.java
new file mode 100644
index 0000000..7f3601d
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/FacturaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.Factura;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the Factura entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface FacturaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/PPreguntaAbiertaRepository.java b/src/main/java/org/datasurvey/repository/PPreguntaAbiertaRepository.java
new file mode 100644
index 0000000..d53eb76
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/PPreguntaAbiertaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.PPreguntaAbierta;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the PPreguntaAbierta entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PPreguntaAbiertaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/PPreguntaCerradaOpcionRepository.java b/src/main/java/org/datasurvey/repository/PPreguntaCerradaOpcionRepository.java
new file mode 100644
index 0000000..cf2054c
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/PPreguntaCerradaOpcionRepository.java
@@ -0,0 +1,13 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.PPreguntaCerradaOpcion;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the PPreguntaCerradaOpcion entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PPreguntaCerradaOpcionRepository
+ extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/PPreguntaCerradaRepository.java b/src/main/java/org/datasurvey/repository/PPreguntaCerradaRepository.java
new file mode 100644
index 0000000..59d2d06
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/PPreguntaCerradaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.PPreguntaCerrada;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the PPreguntaCerrada entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PPreguntaCerradaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/ParametroAplicacionRepository.java b/src/main/java/org/datasurvey/repository/ParametroAplicacionRepository.java
new file mode 100644
index 0000000..e083048
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/ParametroAplicacionRepository.java
@@ -0,0 +1,13 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.ParametroAplicacion;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the ParametroAplicacion entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface ParametroAplicacionRepository
+ extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/PlantillaRepository.java b/src/main/java/org/datasurvey/repository/PlantillaRepository.java
new file mode 100644
index 0000000..7339aa7
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/PlantillaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.Plantilla;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the Plantilla entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface PlantillaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/UserRepository.java b/src/main/java/org/datasurvey/repository/UserRepository.java
new file mode 100644
index 0000000..3f929fb
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/UserRepository.java
@@ -0,0 +1,42 @@
+package org.datasurvey.repository;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.User;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.EntityGraph;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data JPA repository for the {@link User} entity.
+ */
+@Repository
+public interface UserRepository extends JpaRepository {
+ String USERS_BY_LOGIN_CACHE = "usersByLogin";
+
+ String USERS_BY_EMAIL_CACHE = "usersByEmail";
+
+ Optional findOneByActivationKey(String activationKey);
+
+ List findAllByActivatedIsFalseAndActivationKeyIsNotNullAndCreatedDateBefore(Instant dateTime);
+
+ Optional findOneByResetKey(String resetKey);
+
+ Optional findOneByEmailIgnoreCase(String email);
+
+ Optional findOneByLogin(String login);
+
+ @EntityGraph(attributePaths = "authorities")
+ @Cacheable(cacheNames = USERS_BY_LOGIN_CACHE)
+ Optional findOneWithAuthoritiesByLogin(String login);
+
+ @EntityGraph(attributePaths = "authorities")
+ @Cacheable(cacheNames = USERS_BY_EMAIL_CACHE)
+ Optional findOneWithAuthoritiesByEmailIgnoreCase(String email);
+
+ Page findAllByIdNotNullAndActivatedIsTrue(Pageable pageable);
+}
diff --git a/src/main/java/org/datasurvey/repository/UsuarioEncuestaRepository.java b/src/main/java/org/datasurvey/repository/UsuarioEncuestaRepository.java
new file mode 100644
index 0000000..4a05507
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/UsuarioEncuestaRepository.java
@@ -0,0 +1,12 @@
+package org.datasurvey.repository;
+
+import org.datasurvey.domain.UsuarioEncuesta;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the UsuarioEncuesta entity.
+ */
+@SuppressWarnings("unused")
+@Repository
+public interface UsuarioEncuestaRepository extends JpaRepository, JpaSpecificationExecutor {}
diff --git a/src/main/java/org/datasurvey/repository/UsuarioExtraRepository.java b/src/main/java/org/datasurvey/repository/UsuarioExtraRepository.java
new file mode 100644
index 0000000..2497fe5
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/UsuarioExtraRepository.java
@@ -0,0 +1,28 @@
+package org.datasurvey.repository;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.UsuarioExtra;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.*;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+/**
+ * Spring Data SQL repository for the UsuarioExtra entity.
+ */
+@Repository
+public interface UsuarioExtraRepository extends JpaRepository, JpaSpecificationExecutor {
+ @Query(
+ value = "select distinct usuarioExtra from UsuarioExtra usuarioExtra left join fetch usuarioExtra.plantillas",
+ countQuery = "select count(distinct usuarioExtra) from UsuarioExtra usuarioExtra"
+ )
+ Page findAllWithEagerRelationships(Pageable pageable);
+
+ @Query("select distinct usuarioExtra from UsuarioExtra usuarioExtra left join fetch usuarioExtra.plantillas")
+ List findAllWithEagerRelationships();
+
+ @Query("select usuarioExtra from UsuarioExtra usuarioExtra left join fetch usuarioExtra.plantillas where usuarioExtra.id =:id")
+ Optional findOneWithEagerRelationships(@Param("id") Long id);
+}
diff --git a/src/main/java/org/datasurvey/repository/package-info.java b/src/main/java/org/datasurvey/repository/package-info.java
new file mode 100644
index 0000000..f427885
--- /dev/null
+++ b/src/main/java/org/datasurvey/repository/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Spring Data JPA repositories.
+ */
+package org.datasurvey.repository;
diff --git a/src/main/java/org/datasurvey/security/AuthoritiesConstants.java b/src/main/java/org/datasurvey/security/AuthoritiesConstants.java
new file mode 100644
index 0000000..b781cbe
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/AuthoritiesConstants.java
@@ -0,0 +1,15 @@
+package org.datasurvey.security;
+
+/**
+ * Constants for Spring Security authorities.
+ */
+public final class AuthoritiesConstants {
+
+ public static final String ADMIN = "ROLE_ADMIN";
+
+ public static final String USER = "ROLE_USER";
+
+ public static final String ANONYMOUS = "ROLE_ANONYMOUS";
+
+ private AuthoritiesConstants() {}
+}
diff --git a/src/main/java/org/datasurvey/security/DomainUserDetailsService.java b/src/main/java/org/datasurvey/security/DomainUserDetailsService.java
new file mode 100644
index 0000000..4e8511d
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/DomainUserDetailsService.java
@@ -0,0 +1,62 @@
+package org.datasurvey.security;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import org.datasurvey.domain.User;
+import org.datasurvey.repository.UserRepository;
+import org.hibernate.validator.internal.constraintvalidators.hv.EmailValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Authenticate a user from the database.
+ */
+@Component("userDetailsService")
+public class DomainUserDetailsService implements UserDetailsService {
+
+ private final Logger log = LoggerFactory.getLogger(DomainUserDetailsService.class);
+
+ private final UserRepository userRepository;
+
+ public DomainUserDetailsService(UserRepository userRepository) {
+ this.userRepository = userRepository;
+ }
+
+ @Override
+ @Transactional
+ public UserDetails loadUserByUsername(final String login) {
+ log.debug("Authenticating {}", login);
+
+ if (new EmailValidator().isValid(login, null)) {
+ return userRepository
+ .findOneWithAuthoritiesByEmailIgnoreCase(login)
+ .map(user -> createSpringSecurityUser(login, user))
+ .orElseThrow(() -> new UsernameNotFoundException("User with email " + login + " was not found in the database"));
+ }
+
+ String lowercaseLogin = login.toLowerCase(Locale.ENGLISH);
+ return userRepository
+ .findOneWithAuthoritiesByLogin(lowercaseLogin)
+ .map(user -> createSpringSecurityUser(lowercaseLogin, user))
+ .orElseThrow(() -> new UsernameNotFoundException("User " + lowercaseLogin + " was not found in the database"));
+ }
+
+ private org.springframework.security.core.userdetails.User createSpringSecurityUser(String lowercaseLogin, User user) {
+ if (!user.isActivated()) {
+ throw new UserNotActivatedException("User " + lowercaseLogin + " was not activated");
+ }
+ List grantedAuthorities = user
+ .getAuthorities()
+ .stream()
+ .map(authority -> new SimpleGrantedAuthority(authority.getName()))
+ .collect(Collectors.toList());
+ return new org.springframework.security.core.userdetails.User(user.getLogin(), user.getPassword(), grantedAuthorities);
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/SecurityUtils.java b/src/main/java/org/datasurvey/security/SecurityUtils.java
new file mode 100644
index 0000000..fd5f050
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/SecurityUtils.java
@@ -0,0 +1,77 @@
+package org.datasurvey.security;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+
+/**
+ * Utility class for Spring Security.
+ */
+public final class SecurityUtils {
+
+ private SecurityUtils() {}
+
+ /**
+ * Get the login of the current user.
+ *
+ * @return the login of the current user.
+ */
+ public static Optional getCurrentUserLogin() {
+ SecurityContext securityContext = SecurityContextHolder.getContext();
+ return Optional.ofNullable(extractPrincipal(securityContext.getAuthentication()));
+ }
+
+ private static String extractPrincipal(Authentication authentication) {
+ if (authentication == null) {
+ return null;
+ } else if (authentication.getPrincipal() instanceof UserDetails) {
+ UserDetails springSecurityUser = (UserDetails) authentication.getPrincipal();
+ return springSecurityUser.getUsername();
+ } else if (authentication.getPrincipal() instanceof String) {
+ return (String) authentication.getPrincipal();
+ }
+ return null;
+ }
+
+ /**
+ * Get the JWT of the current user.
+ *
+ * @return the JWT of the current user.
+ */
+ public static Optional getCurrentUserJWT() {
+ SecurityContext securityContext = SecurityContextHolder.getContext();
+ return Optional
+ .ofNullable(securityContext.getAuthentication())
+ .filter(authentication -> authentication.getCredentials() instanceof String)
+ .map(authentication -> (String) authentication.getCredentials());
+ }
+
+ /**
+ * Check if a user is authenticated.
+ *
+ * @return true if the user is authenticated, false otherwise.
+ */
+ public static boolean isAuthenticated() {
+ Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+ return authentication != null && getAuthorities(authentication).noneMatch(AuthoritiesConstants.ANONYMOUS::equals);
+ }
+
+ /**
+ * Checks if the current user has a specific authority.
+ *
+ * @param authority the authority to check.
+ * @return true if the current user has the authority, false otherwise.
+ */
+ public static boolean hasCurrentUserThisAuthority(String authority) {
+ Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+ return authentication != null && getAuthorities(authentication).anyMatch(authority::equals);
+ }
+
+ private static Stream getAuthorities(Authentication authentication) {
+ return authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority);
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/SpringSecurityAuditorAware.java b/src/main/java/org/datasurvey/security/SpringSecurityAuditorAware.java
new file mode 100644
index 0000000..6bc970f
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/SpringSecurityAuditorAware.java
@@ -0,0 +1,18 @@
+package org.datasurvey.security;
+
+import java.util.Optional;
+import org.datasurvey.config.Constants;
+import org.springframework.data.domain.AuditorAware;
+import org.springframework.stereotype.Component;
+
+/**
+ * Implementation of {@link AuditorAware} based on Spring Security.
+ */
+@Component
+public class SpringSecurityAuditorAware implements AuditorAware {
+
+ @Override
+ public Optional getCurrentAuditor() {
+ return Optional.of(SecurityUtils.getCurrentUserLogin().orElse(Constants.SYSTEM));
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/UserNotActivatedException.java b/src/main/java/org/datasurvey/security/UserNotActivatedException.java
new file mode 100644
index 0000000..b8738e1
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/UserNotActivatedException.java
@@ -0,0 +1,19 @@
+package org.datasurvey.security;
+
+import org.springframework.security.core.AuthenticationException;
+
+/**
+ * This exception is thrown in case of a not activated user trying to authenticate.
+ */
+public class UserNotActivatedException extends AuthenticationException {
+
+ private static final long serialVersionUID = 1L;
+
+ public UserNotActivatedException(String message) {
+ super(message);
+ }
+
+ public UserNotActivatedException(String message, Throwable t) {
+ super(message, t);
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/jwt/JWTConfigurer.java b/src/main/java/org/datasurvey/security/jwt/JWTConfigurer.java
new file mode 100644
index 0000000..24f2279
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/jwt/JWTConfigurer.java
@@ -0,0 +1,21 @@
+package org.datasurvey.security.jwt;
+
+import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.web.DefaultSecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+public class JWTConfigurer extends SecurityConfigurerAdapter {
+
+ private final TokenProvider tokenProvider;
+
+ public JWTConfigurer(TokenProvider tokenProvider) {
+ this.tokenProvider = tokenProvider;
+ }
+
+ @Override
+ public void configure(HttpSecurity http) {
+ JWTFilter customFilter = new JWTFilter(tokenProvider);
+ http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/jwt/JWTFilter.java b/src/main/java/org/datasurvey/security/jwt/JWTFilter.java
new file mode 100644
index 0000000..8941b96
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/jwt/JWTFilter.java
@@ -0,0 +1,53 @@
+package org.datasurvey.security.jwt;
+
+import java.io.IOException;
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.util.StringUtils;
+import org.springframework.web.filter.GenericFilterBean;
+
+/**
+ * Filters incoming requests and installs a Spring Security principal if a header corresponding to a valid user is
+ * found.
+ */
+public class JWTFilter extends GenericFilterBean {
+
+ public static final String AUTHORIZATION_HEADER = "Authorization";
+
+ public static final String AUTHORIZATION_TOKEN = "access_token";
+
+ private final TokenProvider tokenProvider;
+
+ public JWTFilter(TokenProvider tokenProvider) {
+ this.tokenProvider = tokenProvider;
+ }
+
+ @Override
+ public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
+ throws IOException, ServletException {
+ HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
+ String jwt = resolveToken(httpServletRequest);
+ if (StringUtils.hasText(jwt) && this.tokenProvider.validateToken(jwt)) {
+ Authentication authentication = this.tokenProvider.getAuthentication(jwt);
+ SecurityContextHolder.getContext().setAuthentication(authentication);
+ }
+ filterChain.doFilter(servletRequest, servletResponse);
+ }
+
+ private String resolveToken(HttpServletRequest request) {
+ String bearerToken = request.getHeader(AUTHORIZATION_HEADER);
+ if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
+ return bearerToken.substring(7);
+ }
+ String jwt = request.getParameter(AUTHORIZATION_TOKEN);
+ if (StringUtils.hasText(jwt)) {
+ return jwt;
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/jwt/TokenProvider.java b/src/main/java/org/datasurvey/security/jwt/TokenProvider.java
new file mode 100644
index 0000000..85d3d9c
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/jwt/TokenProvider.java
@@ -0,0 +1,101 @@
+package org.datasurvey.security.jwt;
+
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.util.*;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ObjectUtils;
+import tech.jhipster.config.JHipsterProperties;
+
+@Component
+public class TokenProvider {
+
+ private final Logger log = LoggerFactory.getLogger(TokenProvider.class);
+
+ private static final String AUTHORITIES_KEY = "auth";
+
+ private final Key key;
+
+ private final JwtParser jwtParser;
+
+ private final long tokenValidityInMilliseconds;
+
+ private final long tokenValidityInMillisecondsForRememberMe;
+
+ public TokenProvider(JHipsterProperties jHipsterProperties) {
+ byte[] keyBytes;
+ String secret = jHipsterProperties.getSecurity().getAuthentication().getJwt().getBase64Secret();
+ if (!ObjectUtils.isEmpty(secret)) {
+ log.debug("Using a Base64-encoded JWT secret key");
+ keyBytes = Decoders.BASE64.decode(secret);
+ } else {
+ log.warn(
+ "Warning: the JWT key used is not Base64-encoded. " +
+ "We recommend using the `jhipster.security.authentication.jwt.base64-secret` key for optimum security."
+ );
+ secret = jHipsterProperties.getSecurity().getAuthentication().getJwt().getSecret();
+ keyBytes = secret.getBytes(StandardCharsets.UTF_8);
+ }
+ key = Keys.hmacShaKeyFor(keyBytes);
+ jwtParser = Jwts.parserBuilder().setSigningKey(key).build();
+ this.tokenValidityInMilliseconds = 1000 * jHipsterProperties.getSecurity().getAuthentication().getJwt().getTokenValidityInSeconds();
+ this.tokenValidityInMillisecondsForRememberMe =
+ 1000 * jHipsterProperties.getSecurity().getAuthentication().getJwt().getTokenValidityInSecondsForRememberMe();
+ }
+
+ public String createToken(Authentication authentication, boolean rememberMe) {
+ String authorities = authentication.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.joining(","));
+
+ long now = (new Date()).getTime();
+ Date validity;
+ if (rememberMe) {
+ validity = new Date(now + this.tokenValidityInMillisecondsForRememberMe);
+ } else {
+ validity = new Date(now + this.tokenValidityInMilliseconds);
+ }
+
+ return Jwts
+ .builder()
+ .setSubject(authentication.getName())
+ .claim(AUTHORITIES_KEY, authorities)
+ .signWith(key, SignatureAlgorithm.HS512)
+ .setExpiration(validity)
+ .compact();
+ }
+
+ public Authentication getAuthentication(String token) {
+ Claims claims = jwtParser.parseClaimsJws(token).getBody();
+
+ Collection authorities = Arrays
+ .stream(claims.get(AUTHORITIES_KEY).toString().split(","))
+ .filter(auth -> !auth.trim().isEmpty())
+ .map(SimpleGrantedAuthority::new)
+ .collect(Collectors.toList());
+
+ User principal = new User(claims.getSubject(), "", authorities);
+
+ return new UsernamePasswordAuthenticationToken(principal, token, authorities);
+ }
+
+ public boolean validateToken(String authToken) {
+ try {
+ jwtParser.parseClaimsJws(authToken);
+ return true;
+ } catch (JwtException | IllegalArgumentException e) {
+ log.info("Invalid JWT token.");
+ log.trace("Invalid JWT token trace.", e);
+ }
+ return false;
+ }
+}
diff --git a/src/main/java/org/datasurvey/security/package-info.java b/src/main/java/org/datasurvey/security/package-info.java
new file mode 100644
index 0000000..8a8f4c1
--- /dev/null
+++ b/src/main/java/org/datasurvey/security/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Spring Security configuration.
+ */
+package org.datasurvey.security;
diff --git a/src/main/java/org/datasurvey/service/CategoriaQueryService.java b/src/main/java/org/datasurvey/service/CategoriaQueryService.java
new file mode 100644
index 0000000..4d865cb
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/CategoriaQueryService.java
@@ -0,0 +1,111 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.Categoria;
+import org.datasurvey.repository.CategoriaRepository;
+import org.datasurvey.service.criteria.CategoriaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link Categoria} entities in the database.
+ * The main input is a {@link CategoriaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link Categoria} or a {@link Page} of {@link Categoria} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class CategoriaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(CategoriaQueryService.class);
+
+ private final CategoriaRepository categoriaRepository;
+
+ public CategoriaQueryService(CategoriaRepository categoriaRepository) {
+ this.categoriaRepository = categoriaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link Categoria} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(CategoriaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return categoriaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link Categoria} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(CategoriaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return categoriaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(CategoriaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return categoriaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link CategoriaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(CategoriaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), Categoria_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), Categoria_.nombre));
+ }
+ if (criteria.getEstado() != null) {
+ specification = specification.and(buildSpecification(criteria.getEstado(), Categoria_.estado));
+ }
+ if (criteria.getEncuestaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEncuestaId(),
+ root -> root.join(Categoria_.encuestas, JoinType.LEFT).get(Encuesta_.id)
+ )
+ );
+ }
+ if (criteria.getPlantillaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getPlantillaId(),
+ root -> root.join(Categoria_.plantillas, JoinType.LEFT).get(Plantilla_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/CategoriaService.java b/src/main/java/org/datasurvey/service/CategoriaService.java
new file mode 100644
index 0000000..03adb4e
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/CategoriaService.java
@@ -0,0 +1,96 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.Categoria;
+import org.datasurvey.repository.CategoriaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link Categoria}.
+ */
+@Service
+@Transactional
+public class CategoriaService {
+
+ private final Logger log = LoggerFactory.getLogger(CategoriaService.class);
+
+ private final CategoriaRepository categoriaRepository;
+
+ public CategoriaService(CategoriaRepository categoriaRepository) {
+ this.categoriaRepository = categoriaRepository;
+ }
+
+ /**
+ * Save a categoria.
+ *
+ * @param categoria the entity to save.
+ * @return the persisted entity.
+ */
+ public Categoria save(Categoria categoria) {
+ log.debug("Request to save Categoria : {}", categoria);
+ return categoriaRepository.save(categoria);
+ }
+
+ /**
+ * Partially update a categoria.
+ *
+ * @param categoria the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(Categoria categoria) {
+ log.debug("Request to partially update Categoria : {}", categoria);
+
+ return categoriaRepository
+ .findById(categoria.getId())
+ .map(
+ existingCategoria -> {
+ if (categoria.getNombre() != null) {
+ existingCategoria.setNombre(categoria.getNombre());
+ }
+ if (categoria.getEstado() != null) {
+ existingCategoria.setEstado(categoria.getEstado());
+ }
+
+ return existingCategoria;
+ }
+ )
+ .map(categoriaRepository::save);
+ }
+
+ /**
+ * Get all the categorias.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all Categorias");
+ return categoriaRepository.findAll();
+ }
+
+ /**
+ * Get one categoria by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get Categoria : {}", id);
+ return categoriaRepository.findById(id);
+ }
+
+ /**
+ * Delete the categoria by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete Categoria : {}", id);
+ categoriaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaAbiertaQueryService.java b/src/main/java/org/datasurvey/service/EPreguntaAbiertaQueryService.java
new file mode 100644
index 0000000..1fa8ced
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaAbiertaQueryService.java
@@ -0,0 +1,115 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.EPreguntaAbierta;
+import org.datasurvey.repository.EPreguntaAbiertaRepository;
+import org.datasurvey.service.criteria.EPreguntaAbiertaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link EPreguntaAbierta} entities in the database.
+ * The main input is a {@link EPreguntaAbiertaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link EPreguntaAbierta} or a {@link Page} of {@link EPreguntaAbierta} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class EPreguntaAbiertaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaAbiertaQueryService.class);
+
+ private final EPreguntaAbiertaRepository ePreguntaAbiertaRepository;
+
+ public EPreguntaAbiertaQueryService(EPreguntaAbiertaRepository ePreguntaAbiertaRepository) {
+ this.ePreguntaAbiertaRepository = ePreguntaAbiertaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link EPreguntaAbierta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(EPreguntaAbiertaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link EPreguntaAbierta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(EPreguntaAbiertaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(EPreguntaAbiertaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link EPreguntaAbiertaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(EPreguntaAbiertaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), EPreguntaAbierta_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), EPreguntaAbierta_.nombre));
+ }
+ if (criteria.getOpcional() != null) {
+ specification = specification.and(buildSpecification(criteria.getOpcional(), EPreguntaAbierta_.opcional));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), EPreguntaAbierta_.orden));
+ }
+ if (criteria.getEPreguntaAbiertaRespuestaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaAbiertaRespuestaId(),
+ root ->
+ root.join(EPreguntaAbierta_.ePreguntaAbiertaRespuestas, JoinType.LEFT).get(EPreguntaAbiertaRespuesta_.id)
+ )
+ );
+ }
+ if (criteria.getEncuestaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEncuestaId(),
+ root -> root.join(EPreguntaAbierta_.encuesta, JoinType.LEFT).get(Encuesta_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaQueryService.java b/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaQueryService.java
new file mode 100644
index 0000000..08a69c4
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaQueryService.java
@@ -0,0 +1,99 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.EPreguntaAbiertaRespuesta;
+import org.datasurvey.repository.EPreguntaAbiertaRespuestaRepository;
+import org.datasurvey.service.criteria.EPreguntaAbiertaRespuestaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link EPreguntaAbiertaRespuesta} entities in the database.
+ * The main input is a {@link EPreguntaAbiertaRespuestaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link EPreguntaAbiertaRespuesta} or a {@link Page} of {@link EPreguntaAbiertaRespuesta} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class EPreguntaAbiertaRespuestaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaAbiertaRespuestaQueryService.class);
+
+ private final EPreguntaAbiertaRespuestaRepository ePreguntaAbiertaRespuestaRepository;
+
+ public EPreguntaAbiertaRespuestaQueryService(EPreguntaAbiertaRespuestaRepository ePreguntaAbiertaRespuestaRepository) {
+ this.ePreguntaAbiertaRespuestaRepository = ePreguntaAbiertaRespuestaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link EPreguntaAbiertaRespuesta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(EPreguntaAbiertaRespuestaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRespuestaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link EPreguntaAbiertaRespuesta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(EPreguntaAbiertaRespuestaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRespuestaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(EPreguntaAbiertaRespuestaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaAbiertaRespuestaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link EPreguntaAbiertaRespuestaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(EPreguntaAbiertaRespuestaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), EPreguntaAbiertaRespuesta_.id));
+ }
+ if (criteria.getRespuesta() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getRespuesta(), EPreguntaAbiertaRespuesta_.respuesta));
+ }
+ if (criteria.getEPreguntaAbiertaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaAbiertaId(),
+ root -> root.join(EPreguntaAbiertaRespuesta_.ePreguntaAbierta, JoinType.LEFT).get(EPreguntaAbierta_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaService.java b/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaService.java
new file mode 100644
index 0000000..323fd79
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaAbiertaRespuestaService.java
@@ -0,0 +1,93 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.EPreguntaAbiertaRespuesta;
+import org.datasurvey.repository.EPreguntaAbiertaRespuestaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link EPreguntaAbiertaRespuesta}.
+ */
+@Service
+@Transactional
+public class EPreguntaAbiertaRespuestaService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaAbiertaRespuestaService.class);
+
+ private final EPreguntaAbiertaRespuestaRepository ePreguntaAbiertaRespuestaRepository;
+
+ public EPreguntaAbiertaRespuestaService(EPreguntaAbiertaRespuestaRepository ePreguntaAbiertaRespuestaRepository) {
+ this.ePreguntaAbiertaRespuestaRepository = ePreguntaAbiertaRespuestaRepository;
+ }
+
+ /**
+ * Save a ePreguntaAbiertaRespuesta.
+ *
+ * @param ePreguntaAbiertaRespuesta the entity to save.
+ * @return the persisted entity.
+ */
+ public EPreguntaAbiertaRespuesta save(EPreguntaAbiertaRespuesta ePreguntaAbiertaRespuesta) {
+ log.debug("Request to save EPreguntaAbiertaRespuesta : {}", ePreguntaAbiertaRespuesta);
+ return ePreguntaAbiertaRespuestaRepository.save(ePreguntaAbiertaRespuesta);
+ }
+
+ /**
+ * Partially update a ePreguntaAbiertaRespuesta.
+ *
+ * @param ePreguntaAbiertaRespuesta the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(EPreguntaAbiertaRespuesta ePreguntaAbiertaRespuesta) {
+ log.debug("Request to partially update EPreguntaAbiertaRespuesta : {}", ePreguntaAbiertaRespuesta);
+
+ return ePreguntaAbiertaRespuestaRepository
+ .findById(ePreguntaAbiertaRespuesta.getId())
+ .map(
+ existingEPreguntaAbiertaRespuesta -> {
+ if (ePreguntaAbiertaRespuesta.getRespuesta() != null) {
+ existingEPreguntaAbiertaRespuesta.setRespuesta(ePreguntaAbiertaRespuesta.getRespuesta());
+ }
+
+ return existingEPreguntaAbiertaRespuesta;
+ }
+ )
+ .map(ePreguntaAbiertaRespuestaRepository::save);
+ }
+
+ /**
+ * Get all the ePreguntaAbiertaRespuestas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all EPreguntaAbiertaRespuestas");
+ return ePreguntaAbiertaRespuestaRepository.findAll();
+ }
+
+ /**
+ * Get one ePreguntaAbiertaRespuesta by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get EPreguntaAbiertaRespuesta : {}", id);
+ return ePreguntaAbiertaRespuestaRepository.findById(id);
+ }
+
+ /**
+ * Delete the ePreguntaAbiertaRespuesta by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete EPreguntaAbiertaRespuesta : {}", id);
+ ePreguntaAbiertaRespuestaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaAbiertaService.java b/src/main/java/org/datasurvey/service/EPreguntaAbiertaService.java
new file mode 100644
index 0000000..f90fa0c
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaAbiertaService.java
@@ -0,0 +1,99 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.EPreguntaAbierta;
+import org.datasurvey.repository.EPreguntaAbiertaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link EPreguntaAbierta}.
+ */
+@Service
+@Transactional
+public class EPreguntaAbiertaService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaAbiertaService.class);
+
+ private final EPreguntaAbiertaRepository ePreguntaAbiertaRepository;
+
+ public EPreguntaAbiertaService(EPreguntaAbiertaRepository ePreguntaAbiertaRepository) {
+ this.ePreguntaAbiertaRepository = ePreguntaAbiertaRepository;
+ }
+
+ /**
+ * Save a ePreguntaAbierta.
+ *
+ * @param ePreguntaAbierta the entity to save.
+ * @return the persisted entity.
+ */
+ public EPreguntaAbierta save(EPreguntaAbierta ePreguntaAbierta) {
+ log.debug("Request to save EPreguntaAbierta : {}", ePreguntaAbierta);
+ return ePreguntaAbiertaRepository.save(ePreguntaAbierta);
+ }
+
+ /**
+ * Partially update a ePreguntaAbierta.
+ *
+ * @param ePreguntaAbierta the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(EPreguntaAbierta ePreguntaAbierta) {
+ log.debug("Request to partially update EPreguntaAbierta : {}", ePreguntaAbierta);
+
+ return ePreguntaAbiertaRepository
+ .findById(ePreguntaAbierta.getId())
+ .map(
+ existingEPreguntaAbierta -> {
+ if (ePreguntaAbierta.getNombre() != null) {
+ existingEPreguntaAbierta.setNombre(ePreguntaAbierta.getNombre());
+ }
+ if (ePreguntaAbierta.getOpcional() != null) {
+ existingEPreguntaAbierta.setOpcional(ePreguntaAbierta.getOpcional());
+ }
+ if (ePreguntaAbierta.getOrden() != null) {
+ existingEPreguntaAbierta.setOrden(ePreguntaAbierta.getOrden());
+ }
+
+ return existingEPreguntaAbierta;
+ }
+ )
+ .map(ePreguntaAbiertaRepository::save);
+ }
+
+ /**
+ * Get all the ePreguntaAbiertas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all EPreguntaAbiertas");
+ return ePreguntaAbiertaRepository.findAll();
+ }
+
+ /**
+ * Get one ePreguntaAbierta by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get EPreguntaAbierta : {}", id);
+ return ePreguntaAbiertaRepository.findById(id);
+ }
+
+ /**
+ * Delete the ePreguntaAbierta by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete EPreguntaAbierta : {}", id);
+ ePreguntaAbiertaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionQueryService.java b/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionQueryService.java
new file mode 100644
index 0000000..7af3d17
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionQueryService.java
@@ -0,0 +1,105 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.EPreguntaCerradaOpcion;
+import org.datasurvey.repository.EPreguntaCerradaOpcionRepository;
+import org.datasurvey.service.criteria.EPreguntaCerradaOpcionCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link EPreguntaCerradaOpcion} entities in the database.
+ * The main input is a {@link EPreguntaCerradaOpcionCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link EPreguntaCerradaOpcion} or a {@link Page} of {@link EPreguntaCerradaOpcion} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class EPreguntaCerradaOpcionQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaCerradaOpcionQueryService.class);
+
+ private final EPreguntaCerradaOpcionRepository ePreguntaCerradaOpcionRepository;
+
+ public EPreguntaCerradaOpcionQueryService(EPreguntaCerradaOpcionRepository ePreguntaCerradaOpcionRepository) {
+ this.ePreguntaCerradaOpcionRepository = ePreguntaCerradaOpcionRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link EPreguntaCerradaOpcion} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(EPreguntaCerradaOpcionCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaOpcionRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link EPreguntaCerradaOpcion} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(EPreguntaCerradaOpcionCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaOpcionRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(EPreguntaCerradaOpcionCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaOpcionRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link EPreguntaCerradaOpcionCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(EPreguntaCerradaOpcionCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), EPreguntaCerradaOpcion_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), EPreguntaCerradaOpcion_.nombre));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), EPreguntaCerradaOpcion_.orden));
+ }
+ if (criteria.getCantidad() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getCantidad(), EPreguntaCerradaOpcion_.cantidad));
+ }
+ if (criteria.getEPreguntaCerradaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaCerradaId(),
+ root -> root.join(EPreguntaCerradaOpcion_.ePreguntaCerrada, JoinType.LEFT).get(EPreguntaCerrada_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionService.java b/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionService.java
new file mode 100644
index 0000000..bba3ae7
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaCerradaOpcionService.java
@@ -0,0 +1,99 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.EPreguntaCerradaOpcion;
+import org.datasurvey.repository.EPreguntaCerradaOpcionRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link EPreguntaCerradaOpcion}.
+ */
+@Service
+@Transactional
+public class EPreguntaCerradaOpcionService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaCerradaOpcionService.class);
+
+ private final EPreguntaCerradaOpcionRepository ePreguntaCerradaOpcionRepository;
+
+ public EPreguntaCerradaOpcionService(EPreguntaCerradaOpcionRepository ePreguntaCerradaOpcionRepository) {
+ this.ePreguntaCerradaOpcionRepository = ePreguntaCerradaOpcionRepository;
+ }
+
+ /**
+ * Save a ePreguntaCerradaOpcion.
+ *
+ * @param ePreguntaCerradaOpcion the entity to save.
+ * @return the persisted entity.
+ */
+ public EPreguntaCerradaOpcion save(EPreguntaCerradaOpcion ePreguntaCerradaOpcion) {
+ log.debug("Request to save EPreguntaCerradaOpcion : {}", ePreguntaCerradaOpcion);
+ return ePreguntaCerradaOpcionRepository.save(ePreguntaCerradaOpcion);
+ }
+
+ /**
+ * Partially update a ePreguntaCerradaOpcion.
+ *
+ * @param ePreguntaCerradaOpcion the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(EPreguntaCerradaOpcion ePreguntaCerradaOpcion) {
+ log.debug("Request to partially update EPreguntaCerradaOpcion : {}", ePreguntaCerradaOpcion);
+
+ return ePreguntaCerradaOpcionRepository
+ .findById(ePreguntaCerradaOpcion.getId())
+ .map(
+ existingEPreguntaCerradaOpcion -> {
+ if (ePreguntaCerradaOpcion.getNombre() != null) {
+ existingEPreguntaCerradaOpcion.setNombre(ePreguntaCerradaOpcion.getNombre());
+ }
+ if (ePreguntaCerradaOpcion.getOrden() != null) {
+ existingEPreguntaCerradaOpcion.setOrden(ePreguntaCerradaOpcion.getOrden());
+ }
+ if (ePreguntaCerradaOpcion.getCantidad() != null) {
+ existingEPreguntaCerradaOpcion.setCantidad(ePreguntaCerradaOpcion.getCantidad());
+ }
+
+ return existingEPreguntaCerradaOpcion;
+ }
+ )
+ .map(ePreguntaCerradaOpcionRepository::save);
+ }
+
+ /**
+ * Get all the ePreguntaCerradaOpcions.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all EPreguntaCerradaOpcions");
+ return ePreguntaCerradaOpcionRepository.findAll();
+ }
+
+ /**
+ * Get one ePreguntaCerradaOpcion by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get EPreguntaCerradaOpcion : {}", id);
+ return ePreguntaCerradaOpcionRepository.findById(id);
+ }
+
+ /**
+ * Delete the ePreguntaCerradaOpcion by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete EPreguntaCerradaOpcion : {}", id);
+ ePreguntaCerradaOpcionRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaCerradaQueryService.java b/src/main/java/org/datasurvey/service/EPreguntaCerradaQueryService.java
new file mode 100644
index 0000000..a5075b1
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaCerradaQueryService.java
@@ -0,0 +1,117 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.EPreguntaCerrada;
+import org.datasurvey.repository.EPreguntaCerradaRepository;
+import org.datasurvey.service.criteria.EPreguntaCerradaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link EPreguntaCerrada} entities in the database.
+ * The main input is a {@link EPreguntaCerradaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link EPreguntaCerrada} or a {@link Page} of {@link EPreguntaCerrada} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class EPreguntaCerradaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaCerradaQueryService.class);
+
+ private final EPreguntaCerradaRepository ePreguntaCerradaRepository;
+
+ public EPreguntaCerradaQueryService(EPreguntaCerradaRepository ePreguntaCerradaRepository) {
+ this.ePreguntaCerradaRepository = ePreguntaCerradaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link EPreguntaCerrada} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(EPreguntaCerradaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link EPreguntaCerrada} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(EPreguntaCerradaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(EPreguntaCerradaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return ePreguntaCerradaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link EPreguntaCerradaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(EPreguntaCerradaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), EPreguntaCerrada_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), EPreguntaCerrada_.nombre));
+ }
+ if (criteria.getTipo() != null) {
+ specification = specification.and(buildSpecification(criteria.getTipo(), EPreguntaCerrada_.tipo));
+ }
+ if (criteria.getOpcional() != null) {
+ specification = specification.and(buildSpecification(criteria.getOpcional(), EPreguntaCerrada_.opcional));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), EPreguntaCerrada_.orden));
+ }
+ if (criteria.getEPreguntaCerradaOpcionId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaCerradaOpcionId(),
+ root -> root.join(EPreguntaCerrada_.ePreguntaCerradaOpcions, JoinType.LEFT).get(EPreguntaCerradaOpcion_.id)
+ )
+ );
+ }
+ if (criteria.getEncuestaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEncuestaId(),
+ root -> root.join(EPreguntaCerrada_.encuesta, JoinType.LEFT).get(Encuesta_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EPreguntaCerradaService.java b/src/main/java/org/datasurvey/service/EPreguntaCerradaService.java
new file mode 100644
index 0000000..fb39398
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EPreguntaCerradaService.java
@@ -0,0 +1,102 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.EPreguntaCerrada;
+import org.datasurvey.repository.EPreguntaCerradaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link EPreguntaCerrada}.
+ */
+@Service
+@Transactional
+public class EPreguntaCerradaService {
+
+ private final Logger log = LoggerFactory.getLogger(EPreguntaCerradaService.class);
+
+ private final EPreguntaCerradaRepository ePreguntaCerradaRepository;
+
+ public EPreguntaCerradaService(EPreguntaCerradaRepository ePreguntaCerradaRepository) {
+ this.ePreguntaCerradaRepository = ePreguntaCerradaRepository;
+ }
+
+ /**
+ * Save a ePreguntaCerrada.
+ *
+ * @param ePreguntaCerrada the entity to save.
+ * @return the persisted entity.
+ */
+ public EPreguntaCerrada save(EPreguntaCerrada ePreguntaCerrada) {
+ log.debug("Request to save EPreguntaCerrada : {}", ePreguntaCerrada);
+ return ePreguntaCerradaRepository.save(ePreguntaCerrada);
+ }
+
+ /**
+ * Partially update a ePreguntaCerrada.
+ *
+ * @param ePreguntaCerrada the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(EPreguntaCerrada ePreguntaCerrada) {
+ log.debug("Request to partially update EPreguntaCerrada : {}", ePreguntaCerrada);
+
+ return ePreguntaCerradaRepository
+ .findById(ePreguntaCerrada.getId())
+ .map(
+ existingEPreguntaCerrada -> {
+ if (ePreguntaCerrada.getNombre() != null) {
+ existingEPreguntaCerrada.setNombre(ePreguntaCerrada.getNombre());
+ }
+ if (ePreguntaCerrada.getTipo() != null) {
+ existingEPreguntaCerrada.setTipo(ePreguntaCerrada.getTipo());
+ }
+ if (ePreguntaCerrada.getOpcional() != null) {
+ existingEPreguntaCerrada.setOpcional(ePreguntaCerrada.getOpcional());
+ }
+ if (ePreguntaCerrada.getOrden() != null) {
+ existingEPreguntaCerrada.setOrden(ePreguntaCerrada.getOrden());
+ }
+
+ return existingEPreguntaCerrada;
+ }
+ )
+ .map(ePreguntaCerradaRepository::save);
+ }
+
+ /**
+ * Get all the ePreguntaCerradas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all EPreguntaCerradas");
+ return ePreguntaCerradaRepository.findAll();
+ }
+
+ /**
+ * Get one ePreguntaCerrada by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get EPreguntaCerrada : {}", id);
+ return ePreguntaCerradaRepository.findById(id);
+ }
+
+ /**
+ * Delete the ePreguntaCerrada by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete EPreguntaCerrada : {}", id);
+ ePreguntaCerradaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EmailAlreadyUsedException.java b/src/main/java/org/datasurvey/service/EmailAlreadyUsedException.java
new file mode 100644
index 0000000..d2cefea
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EmailAlreadyUsedException.java
@@ -0,0 +1,10 @@
+package org.datasurvey.service;
+
+public class EmailAlreadyUsedException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ public EmailAlreadyUsedException() {
+ super("Email is already in use!");
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EncuestaQueryService.java b/src/main/java/org/datasurvey/service/EncuestaQueryService.java
new file mode 100644
index 0000000..055eee5
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EncuestaQueryService.java
@@ -0,0 +1,162 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.Encuesta;
+import org.datasurvey.repository.EncuestaRepository;
+import org.datasurvey.service.criteria.EncuestaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link Encuesta} entities in the database.
+ * The main input is a {@link EncuestaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link Encuesta} or a {@link Page} of {@link Encuesta} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class EncuestaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(EncuestaQueryService.class);
+
+ private final EncuestaRepository encuestaRepository;
+
+ public EncuestaQueryService(EncuestaRepository encuestaRepository) {
+ this.encuestaRepository = encuestaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link Encuesta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(EncuestaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return encuestaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link Encuesta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(EncuestaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return encuestaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(EncuestaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return encuestaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link EncuestaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(EncuestaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), Encuesta_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), Encuesta_.nombre));
+ }
+ if (criteria.getDescripcion() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getDescripcion(), Encuesta_.descripcion));
+ }
+ if (criteria.getFechaCreacion() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getFechaCreacion(), Encuesta_.fechaCreacion));
+ }
+ if (criteria.getFechaPublicacion() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getFechaPublicacion(), Encuesta_.fechaPublicacion));
+ }
+ if (criteria.getFechaFinalizar() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getFechaFinalizar(), Encuesta_.fechaFinalizar));
+ }
+ if (criteria.getFechaFinalizada() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getFechaFinalizada(), Encuesta_.fechaFinalizada));
+ }
+ if (criteria.getCalificacion() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getCalificacion(), Encuesta_.calificacion));
+ }
+ if (criteria.getAcceso() != null) {
+ specification = specification.and(buildSpecification(criteria.getAcceso(), Encuesta_.acceso));
+ }
+ if (criteria.getContrasenna() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getContrasenna(), Encuesta_.contrasenna));
+ }
+ if (criteria.getEstado() != null) {
+ specification = specification.and(buildSpecification(criteria.getEstado(), Encuesta_.estado));
+ }
+ if (criteria.getUsuarioEncuestaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getUsuarioEncuestaId(),
+ root -> root.join(Encuesta_.usuarioEncuestas, JoinType.LEFT).get(UsuarioEncuesta_.id)
+ )
+ );
+ }
+ if (criteria.getEPreguntaAbiertaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaAbiertaId(),
+ root -> root.join(Encuesta_.ePreguntaAbiertas, JoinType.LEFT).get(EPreguntaAbierta_.id)
+ )
+ );
+ }
+ if (criteria.getEPreguntaCerradaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getEPreguntaCerradaId(),
+ root -> root.join(Encuesta_.ePreguntaCerradas, JoinType.LEFT).get(EPreguntaCerrada_.id)
+ )
+ );
+ }
+ if (criteria.getCategoriaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getCategoriaId(),
+ root -> root.join(Encuesta_.categoria, JoinType.LEFT).get(Categoria_.id)
+ )
+ );
+ }
+ if (criteria.getUsuarioExtraId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getUsuarioExtraId(),
+ root -> root.join(Encuesta_.usuarioExtra, JoinType.LEFT).get(UsuarioExtra_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/EncuestaService.java b/src/main/java/org/datasurvey/service/EncuestaService.java
new file mode 100644
index 0000000..3ac10a5
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/EncuestaService.java
@@ -0,0 +1,120 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.Encuesta;
+import org.datasurvey.repository.EncuestaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link Encuesta}.
+ */
+@Service
+@Transactional
+public class EncuestaService {
+
+ private final Logger log = LoggerFactory.getLogger(EncuestaService.class);
+
+ private final EncuestaRepository encuestaRepository;
+
+ public EncuestaService(EncuestaRepository encuestaRepository) {
+ this.encuestaRepository = encuestaRepository;
+ }
+
+ /**
+ * Save a encuesta.
+ *
+ * @param encuesta the entity to save.
+ * @return the persisted entity.
+ */
+ public Encuesta save(Encuesta encuesta) {
+ log.debug("Request to save Encuesta : {}", encuesta);
+ return encuestaRepository.save(encuesta);
+ }
+
+ /**
+ * Partially update a encuesta.
+ *
+ * @param encuesta the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(Encuesta encuesta) {
+ log.debug("Request to partially update Encuesta : {}", encuesta);
+
+ return encuestaRepository
+ .findById(encuesta.getId())
+ .map(
+ existingEncuesta -> {
+ if (encuesta.getNombre() != null) {
+ existingEncuesta.setNombre(encuesta.getNombre());
+ }
+ if (encuesta.getDescripcion() != null) {
+ existingEncuesta.setDescripcion(encuesta.getDescripcion());
+ }
+ if (encuesta.getFechaCreacion() != null) {
+ existingEncuesta.setFechaCreacion(encuesta.getFechaCreacion());
+ }
+ if (encuesta.getFechaPublicacion() != null) {
+ existingEncuesta.setFechaPublicacion(encuesta.getFechaPublicacion());
+ }
+ if (encuesta.getFechaFinalizar() != null) {
+ existingEncuesta.setFechaFinalizar(encuesta.getFechaFinalizar());
+ }
+ if (encuesta.getFechaFinalizada() != null) {
+ existingEncuesta.setFechaFinalizada(encuesta.getFechaFinalizada());
+ }
+ if (encuesta.getCalificacion() != null) {
+ existingEncuesta.setCalificacion(encuesta.getCalificacion());
+ }
+ if (encuesta.getAcceso() != null) {
+ existingEncuesta.setAcceso(encuesta.getAcceso());
+ }
+ if (encuesta.getContrasenna() != null) {
+ existingEncuesta.setContrasenna(encuesta.getContrasenna());
+ }
+ if (encuesta.getEstado() != null) {
+ existingEncuesta.setEstado(encuesta.getEstado());
+ }
+
+ return existingEncuesta;
+ }
+ )
+ .map(encuestaRepository::save);
+ }
+
+ /**
+ * Get all the encuestas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all Encuestas");
+ return encuestaRepository.findAll();
+ }
+
+ /**
+ * Get one encuesta by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get Encuesta : {}", id);
+ return encuestaRepository.findById(id);
+ }
+
+ /**
+ * Delete the encuesta by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete Encuesta : {}", id);
+ encuestaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/FacturaQueryService.java b/src/main/java/org/datasurvey/service/FacturaQueryService.java
new file mode 100644
index 0000000..7cf06ac
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/FacturaQueryService.java
@@ -0,0 +1,99 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.Factura;
+import org.datasurvey.repository.FacturaRepository;
+import org.datasurvey.service.criteria.FacturaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link Factura} entities in the database.
+ * The main input is a {@link FacturaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link Factura} or a {@link Page} of {@link Factura} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class FacturaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(FacturaQueryService.class);
+
+ private final FacturaRepository facturaRepository;
+
+ public FacturaQueryService(FacturaRepository facturaRepository) {
+ this.facturaRepository = facturaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link Factura} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(FacturaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return facturaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link Factura} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(FacturaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return facturaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(FacturaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return facturaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link FacturaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(FacturaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), Factura_.id));
+ }
+ if (criteria.getNombreUsuario() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombreUsuario(), Factura_.nombreUsuario));
+ }
+ if (criteria.getNombrePlantilla() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombrePlantilla(), Factura_.nombrePlantilla));
+ }
+ if (criteria.getCosto() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getCosto(), Factura_.costo));
+ }
+ if (criteria.getFecha() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getFecha(), Factura_.fecha));
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/FacturaService.java b/src/main/java/org/datasurvey/service/FacturaService.java
new file mode 100644
index 0000000..75c244c
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/FacturaService.java
@@ -0,0 +1,102 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.Factura;
+import org.datasurvey.repository.FacturaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link Factura}.
+ */
+@Service
+@Transactional
+public class FacturaService {
+
+ private final Logger log = LoggerFactory.getLogger(FacturaService.class);
+
+ private final FacturaRepository facturaRepository;
+
+ public FacturaService(FacturaRepository facturaRepository) {
+ this.facturaRepository = facturaRepository;
+ }
+
+ /**
+ * Save a factura.
+ *
+ * @param factura the entity to save.
+ * @return the persisted entity.
+ */
+ public Factura save(Factura factura) {
+ log.debug("Request to save Factura : {}", factura);
+ return facturaRepository.save(factura);
+ }
+
+ /**
+ * Partially update a factura.
+ *
+ * @param factura the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(Factura factura) {
+ log.debug("Request to partially update Factura : {}", factura);
+
+ return facturaRepository
+ .findById(factura.getId())
+ .map(
+ existingFactura -> {
+ if (factura.getNombreUsuario() != null) {
+ existingFactura.setNombreUsuario(factura.getNombreUsuario());
+ }
+ if (factura.getNombrePlantilla() != null) {
+ existingFactura.setNombrePlantilla(factura.getNombrePlantilla());
+ }
+ if (factura.getCosto() != null) {
+ existingFactura.setCosto(factura.getCosto());
+ }
+ if (factura.getFecha() != null) {
+ existingFactura.setFecha(factura.getFecha());
+ }
+
+ return existingFactura;
+ }
+ )
+ .map(facturaRepository::save);
+ }
+
+ /**
+ * Get all the facturas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all Facturas");
+ return facturaRepository.findAll();
+ }
+
+ /**
+ * Get one factura by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get Factura : {}", id);
+ return facturaRepository.findById(id);
+ }
+
+ /**
+ * Delete the factura by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete Factura : {}", id);
+ facturaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/InvalidPasswordException.java b/src/main/java/org/datasurvey/service/InvalidPasswordException.java
new file mode 100644
index 0000000..f63b9e9
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/InvalidPasswordException.java
@@ -0,0 +1,10 @@
+package org.datasurvey.service;
+
+public class InvalidPasswordException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ public InvalidPasswordException() {
+ super("Incorrect password");
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/MailService.java b/src/main/java/org/datasurvey/service/MailService.java
new file mode 100644
index 0000000..0575e3d
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/MailService.java
@@ -0,0 +1,112 @@
+package org.datasurvey.service;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeMessage;
+import org.datasurvey.domain.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.MessageSource;
+import org.springframework.mail.MailException;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.mail.javamail.MimeMessageHelper;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.thymeleaf.context.Context;
+import org.thymeleaf.spring5.SpringTemplateEngine;
+import tech.jhipster.config.JHipsterProperties;
+
+/**
+ * Service for sending emails.
+ *
+ * We use the {@link Async} annotation to send emails asynchronously.
+ */
+@Service
+public class MailService {
+
+ private final Logger log = LoggerFactory.getLogger(MailService.class);
+
+ private static final String USER = "user";
+
+ private static final String BASE_URL = "baseUrl";
+
+ private final JHipsterProperties jHipsterProperties;
+
+ private final JavaMailSender javaMailSender;
+
+ private final MessageSource messageSource;
+
+ private final SpringTemplateEngine templateEngine;
+
+ public MailService(
+ JHipsterProperties jHipsterProperties,
+ JavaMailSender javaMailSender,
+ MessageSource messageSource,
+ SpringTemplateEngine templateEngine
+ ) {
+ this.jHipsterProperties = jHipsterProperties;
+ this.javaMailSender = javaMailSender;
+ this.messageSource = messageSource;
+ this.templateEngine = templateEngine;
+ }
+
+ @Async
+ public void sendEmail(String to, String subject, String content, boolean isMultipart, boolean isHtml) {
+ log.debug(
+ "Send email[multipart '{}' and html '{}'] to '{}' with subject '{}' and content={}",
+ isMultipart,
+ isHtml,
+ to,
+ subject,
+ content
+ );
+
+ // Prepare message using a Spring helper
+ MimeMessage mimeMessage = javaMailSender.createMimeMessage();
+ try {
+ MimeMessageHelper message = new MimeMessageHelper(mimeMessage, isMultipart, StandardCharsets.UTF_8.name());
+ message.setTo(to);
+ message.setFrom(jHipsterProperties.getMail().getFrom());
+ message.setSubject(subject);
+ message.setText(content, isHtml);
+ javaMailSender.send(mimeMessage);
+ log.debug("Sent email to User '{}'", to);
+ } catch (MailException | MessagingException e) {
+ log.warn("Email could not be sent to user '{}'", to, e);
+ }
+ }
+
+ @Async
+ public void sendEmailFromTemplate(User user, String templateName, String titleKey) {
+ if (user.getEmail() == null) {
+ log.debug("Email doesn't exist for user '{}'", user.getLogin());
+ return;
+ }
+ Locale locale = Locale.forLanguageTag(user.getLangKey());
+ Context context = new Context(locale);
+ context.setVariable(USER, user);
+ context.setVariable(BASE_URL, jHipsterProperties.getMail().getBaseUrl());
+ String content = templateEngine.process(templateName, context);
+ String subject = messageSource.getMessage(titleKey, null, locale);
+ sendEmail(user.getEmail(), subject, content, false, true);
+ }
+
+ @Async
+ public void sendActivationEmail(User user) {
+ log.debug("Sending activation email to '{}'", user.getEmail());
+ sendEmailFromTemplate(user, "mail/activationEmail", "email.activation.title");
+ }
+
+ @Async
+ public void sendCreationEmail(User user) {
+ log.debug("Sending creation email to '{}'", user.getEmail());
+ sendEmailFromTemplate(user, "mail/creationEmail", "email.activation.title");
+ }
+
+ @Async
+ public void sendPasswordResetMail(User user) {
+ log.debug("Sending password reset email to '{}'", user.getEmail());
+ sendEmailFromTemplate(user, "mail/passwordResetEmail", "email.reset.title");
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaAbiertaQueryService.java b/src/main/java/org/datasurvey/service/PPreguntaAbiertaQueryService.java
new file mode 100644
index 0000000..1e3a2d7
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaAbiertaQueryService.java
@@ -0,0 +1,105 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.PPreguntaAbierta;
+import org.datasurvey.repository.PPreguntaAbiertaRepository;
+import org.datasurvey.service.criteria.PPreguntaAbiertaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link PPreguntaAbierta} entities in the database.
+ * The main input is a {@link PPreguntaAbiertaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link PPreguntaAbierta} or a {@link Page} of {@link PPreguntaAbierta} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class PPreguntaAbiertaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaAbiertaQueryService.class);
+
+ private final PPreguntaAbiertaRepository pPreguntaAbiertaRepository;
+
+ public PPreguntaAbiertaQueryService(PPreguntaAbiertaRepository pPreguntaAbiertaRepository) {
+ this.pPreguntaAbiertaRepository = pPreguntaAbiertaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link PPreguntaAbierta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(PPreguntaAbiertaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaAbiertaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link PPreguntaAbierta} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(PPreguntaAbiertaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaAbiertaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(PPreguntaAbiertaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaAbiertaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link PPreguntaAbiertaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(PPreguntaAbiertaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), PPreguntaAbierta_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), PPreguntaAbierta_.nombre));
+ }
+ if (criteria.getOpcional() != null) {
+ specification = specification.and(buildSpecification(criteria.getOpcional(), PPreguntaAbierta_.opcional));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), PPreguntaAbierta_.orden));
+ }
+ if (criteria.getPlantillaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getPlantillaId(),
+ root -> root.join(PPreguntaAbierta_.plantilla, JoinType.LEFT).get(Plantilla_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaAbiertaService.java b/src/main/java/org/datasurvey/service/PPreguntaAbiertaService.java
new file mode 100644
index 0000000..c9c1c58
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaAbiertaService.java
@@ -0,0 +1,99 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.PPreguntaAbierta;
+import org.datasurvey.repository.PPreguntaAbiertaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link PPreguntaAbierta}.
+ */
+@Service
+@Transactional
+public class PPreguntaAbiertaService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaAbiertaService.class);
+
+ private final PPreguntaAbiertaRepository pPreguntaAbiertaRepository;
+
+ public PPreguntaAbiertaService(PPreguntaAbiertaRepository pPreguntaAbiertaRepository) {
+ this.pPreguntaAbiertaRepository = pPreguntaAbiertaRepository;
+ }
+
+ /**
+ * Save a pPreguntaAbierta.
+ *
+ * @param pPreguntaAbierta the entity to save.
+ * @return the persisted entity.
+ */
+ public PPreguntaAbierta save(PPreguntaAbierta pPreguntaAbierta) {
+ log.debug("Request to save PPreguntaAbierta : {}", pPreguntaAbierta);
+ return pPreguntaAbiertaRepository.save(pPreguntaAbierta);
+ }
+
+ /**
+ * Partially update a pPreguntaAbierta.
+ *
+ * @param pPreguntaAbierta the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(PPreguntaAbierta pPreguntaAbierta) {
+ log.debug("Request to partially update PPreguntaAbierta : {}", pPreguntaAbierta);
+
+ return pPreguntaAbiertaRepository
+ .findById(pPreguntaAbierta.getId())
+ .map(
+ existingPPreguntaAbierta -> {
+ if (pPreguntaAbierta.getNombre() != null) {
+ existingPPreguntaAbierta.setNombre(pPreguntaAbierta.getNombre());
+ }
+ if (pPreguntaAbierta.getOpcional() != null) {
+ existingPPreguntaAbierta.setOpcional(pPreguntaAbierta.getOpcional());
+ }
+ if (pPreguntaAbierta.getOrden() != null) {
+ existingPPreguntaAbierta.setOrden(pPreguntaAbierta.getOrden());
+ }
+
+ return existingPPreguntaAbierta;
+ }
+ )
+ .map(pPreguntaAbiertaRepository::save);
+ }
+
+ /**
+ * Get all the pPreguntaAbiertas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all PPreguntaAbiertas");
+ return pPreguntaAbiertaRepository.findAll();
+ }
+
+ /**
+ * Get one pPreguntaAbierta by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get PPreguntaAbierta : {}", id);
+ return pPreguntaAbiertaRepository.findById(id);
+ }
+
+ /**
+ * Delete the pPreguntaAbierta by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete PPreguntaAbierta : {}", id);
+ pPreguntaAbiertaRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionQueryService.java b/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionQueryService.java
new file mode 100644
index 0000000..f6e021b
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionQueryService.java
@@ -0,0 +1,102 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.PPreguntaCerradaOpcion;
+import org.datasurvey.repository.PPreguntaCerradaOpcionRepository;
+import org.datasurvey.service.criteria.PPreguntaCerradaOpcionCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link PPreguntaCerradaOpcion} entities in the database.
+ * The main input is a {@link PPreguntaCerradaOpcionCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link PPreguntaCerradaOpcion} or a {@link Page} of {@link PPreguntaCerradaOpcion} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class PPreguntaCerradaOpcionQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaCerradaOpcionQueryService.class);
+
+ private final PPreguntaCerradaOpcionRepository pPreguntaCerradaOpcionRepository;
+
+ public PPreguntaCerradaOpcionQueryService(PPreguntaCerradaOpcionRepository pPreguntaCerradaOpcionRepository) {
+ this.pPreguntaCerradaOpcionRepository = pPreguntaCerradaOpcionRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link PPreguntaCerradaOpcion} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(PPreguntaCerradaOpcionCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaOpcionRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link PPreguntaCerradaOpcion} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(PPreguntaCerradaOpcionCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaOpcionRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(PPreguntaCerradaOpcionCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaOpcionRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link PPreguntaCerradaOpcionCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(PPreguntaCerradaOpcionCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), PPreguntaCerradaOpcion_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), PPreguntaCerradaOpcion_.nombre));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), PPreguntaCerradaOpcion_.orden));
+ }
+ if (criteria.getPPreguntaCerradaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getPPreguntaCerradaId(),
+ root -> root.join(PPreguntaCerradaOpcion_.pPreguntaCerrada, JoinType.LEFT).get(PPreguntaCerrada_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionService.java b/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionService.java
new file mode 100644
index 0000000..ffa290a
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaCerradaOpcionService.java
@@ -0,0 +1,96 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.PPreguntaCerradaOpcion;
+import org.datasurvey.repository.PPreguntaCerradaOpcionRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link PPreguntaCerradaOpcion}.
+ */
+@Service
+@Transactional
+public class PPreguntaCerradaOpcionService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaCerradaOpcionService.class);
+
+ private final PPreguntaCerradaOpcionRepository pPreguntaCerradaOpcionRepository;
+
+ public PPreguntaCerradaOpcionService(PPreguntaCerradaOpcionRepository pPreguntaCerradaOpcionRepository) {
+ this.pPreguntaCerradaOpcionRepository = pPreguntaCerradaOpcionRepository;
+ }
+
+ /**
+ * Save a pPreguntaCerradaOpcion.
+ *
+ * @param pPreguntaCerradaOpcion the entity to save.
+ * @return the persisted entity.
+ */
+ public PPreguntaCerradaOpcion save(PPreguntaCerradaOpcion pPreguntaCerradaOpcion) {
+ log.debug("Request to save PPreguntaCerradaOpcion : {}", pPreguntaCerradaOpcion);
+ return pPreguntaCerradaOpcionRepository.save(pPreguntaCerradaOpcion);
+ }
+
+ /**
+ * Partially update a pPreguntaCerradaOpcion.
+ *
+ * @param pPreguntaCerradaOpcion the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(PPreguntaCerradaOpcion pPreguntaCerradaOpcion) {
+ log.debug("Request to partially update PPreguntaCerradaOpcion : {}", pPreguntaCerradaOpcion);
+
+ return pPreguntaCerradaOpcionRepository
+ .findById(pPreguntaCerradaOpcion.getId())
+ .map(
+ existingPPreguntaCerradaOpcion -> {
+ if (pPreguntaCerradaOpcion.getNombre() != null) {
+ existingPPreguntaCerradaOpcion.setNombre(pPreguntaCerradaOpcion.getNombre());
+ }
+ if (pPreguntaCerradaOpcion.getOrden() != null) {
+ existingPPreguntaCerradaOpcion.setOrden(pPreguntaCerradaOpcion.getOrden());
+ }
+
+ return existingPPreguntaCerradaOpcion;
+ }
+ )
+ .map(pPreguntaCerradaOpcionRepository::save);
+ }
+
+ /**
+ * Get all the pPreguntaCerradaOpcions.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List findAll() {
+ log.debug("Request to get all PPreguntaCerradaOpcions");
+ return pPreguntaCerradaOpcionRepository.findAll();
+ }
+
+ /**
+ * Get one pPreguntaCerradaOpcion by id.
+ *
+ * @param id the id of the entity.
+ * @return the entity.
+ */
+ @Transactional(readOnly = true)
+ public Optional findOne(Long id) {
+ log.debug("Request to get PPreguntaCerradaOpcion : {}", id);
+ return pPreguntaCerradaOpcionRepository.findById(id);
+ }
+
+ /**
+ * Delete the pPreguntaCerradaOpcion by id.
+ *
+ * @param id the id of the entity.
+ */
+ public void delete(Long id) {
+ log.debug("Request to delete PPreguntaCerradaOpcion : {}", id);
+ pPreguntaCerradaOpcionRepository.deleteById(id);
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaCerradaQueryService.java b/src/main/java/org/datasurvey/service/PPreguntaCerradaQueryService.java
new file mode 100644
index 0000000..e840fd7
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaCerradaQueryService.java
@@ -0,0 +1,117 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import javax.persistence.criteria.JoinType;
+import org.datasurvey.domain.*; // for static metamodels
+import org.datasurvey.domain.PPreguntaCerrada;
+import org.datasurvey.repository.PPreguntaCerradaRepository;
+import org.datasurvey.service.criteria.PPreguntaCerradaCriteria;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import tech.jhipster.service.QueryService;
+
+/**
+ * Service for executing complex queries for {@link PPreguntaCerrada} entities in the database.
+ * The main input is a {@link PPreguntaCerradaCriteria} which gets converted to {@link Specification},
+ * in a way that all the filters must apply.
+ * It returns a {@link List} of {@link PPreguntaCerrada} or a {@link Page} of {@link PPreguntaCerrada} which fulfills the criteria.
+ */
+@Service
+@Transactional(readOnly = true)
+public class PPreguntaCerradaQueryService extends QueryService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaCerradaQueryService.class);
+
+ private final PPreguntaCerradaRepository pPreguntaCerradaRepository;
+
+ public PPreguntaCerradaQueryService(PPreguntaCerradaRepository pPreguntaCerradaRepository) {
+ this.pPreguntaCerradaRepository = pPreguntaCerradaRepository;
+ }
+
+ /**
+ * Return a {@link List} of {@link PPreguntaCerrada} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public List findByCriteria(PPreguntaCerradaCriteria criteria) {
+ log.debug("find by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaRepository.findAll(specification);
+ }
+
+ /**
+ * Return a {@link Page} of {@link PPreguntaCerrada} which matches the criteria from the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @param page The page, which should be returned.
+ * @return the matching entities.
+ */
+ @Transactional(readOnly = true)
+ public Page findByCriteria(PPreguntaCerradaCriteria criteria, Pageable page) {
+ log.debug("find by criteria : {}, page: {}", criteria, page);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaRepository.findAll(specification, page);
+ }
+
+ /**
+ * Return the number of matching entities in the database.
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the number of matching entities.
+ */
+ @Transactional(readOnly = true)
+ public long countByCriteria(PPreguntaCerradaCriteria criteria) {
+ log.debug("count by criteria : {}", criteria);
+ final Specification specification = createSpecification(criteria);
+ return pPreguntaCerradaRepository.count(specification);
+ }
+
+ /**
+ * Function to convert {@link PPreguntaCerradaCriteria} to a {@link Specification}
+ * @param criteria The object which holds all the filters, which the entities should match.
+ * @return the matching {@link Specification} of the entity.
+ */
+ protected Specification createSpecification(PPreguntaCerradaCriteria criteria) {
+ Specification specification = Specification.where(null);
+ if (criteria != null) {
+ if (criteria.getId() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getId(), PPreguntaCerrada_.id));
+ }
+ if (criteria.getNombre() != null) {
+ specification = specification.and(buildStringSpecification(criteria.getNombre(), PPreguntaCerrada_.nombre));
+ }
+ if (criteria.getTipo() != null) {
+ specification = specification.and(buildSpecification(criteria.getTipo(), PPreguntaCerrada_.tipo));
+ }
+ if (criteria.getOpcional() != null) {
+ specification = specification.and(buildSpecification(criteria.getOpcional(), PPreguntaCerrada_.opcional));
+ }
+ if (criteria.getOrden() != null) {
+ specification = specification.and(buildRangeSpecification(criteria.getOrden(), PPreguntaCerrada_.orden));
+ }
+ if (criteria.getPPreguntaCerradaOpcionId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getPPreguntaCerradaOpcionId(),
+ root -> root.join(PPreguntaCerrada_.pPreguntaCerradaOpcions, JoinType.LEFT).get(PPreguntaCerradaOpcion_.id)
+ )
+ );
+ }
+ if (criteria.getPlantillaId() != null) {
+ specification =
+ specification.and(
+ buildSpecification(
+ criteria.getPlantillaId(),
+ root -> root.join(PPreguntaCerrada_.plantilla, JoinType.LEFT).get(Plantilla_.id)
+ )
+ );
+ }
+ }
+ return specification;
+ }
+}
diff --git a/src/main/java/org/datasurvey/service/PPreguntaCerradaService.java b/src/main/java/org/datasurvey/service/PPreguntaCerradaService.java
new file mode 100644
index 0000000..bc27a58
--- /dev/null
+++ b/src/main/java/org/datasurvey/service/PPreguntaCerradaService.java
@@ -0,0 +1,102 @@
+package org.datasurvey.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.datasurvey.domain.PPreguntaCerrada;
+import org.datasurvey.repository.PPreguntaCerradaRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Service Implementation for managing {@link PPreguntaCerrada}.
+ */
+@Service
+@Transactional
+public class PPreguntaCerradaService {
+
+ private final Logger log = LoggerFactory.getLogger(PPreguntaCerradaService.class);
+
+ private final PPreguntaCerradaRepository pPreguntaCerradaRepository;
+
+ public PPreguntaCerradaService(PPreguntaCerradaRepository pPreguntaCerradaRepository) {
+ this.pPreguntaCerradaRepository = pPreguntaCerradaRepository;
+ }
+
+ /**
+ * Save a pPreguntaCerrada.
+ *
+ * @param pPreguntaCerrada the entity to save.
+ * @return the persisted entity.
+ */
+ public PPreguntaCerrada save(PPreguntaCerrada pPreguntaCerrada) {
+ log.debug("Request to save PPreguntaCerrada : {}", pPreguntaCerrada);
+ return pPreguntaCerradaRepository.save(pPreguntaCerrada);
+ }
+
+ /**
+ * Partially update a pPreguntaCerrada.
+ *
+ * @param pPreguntaCerrada the entity to update partially.
+ * @return the persisted entity.
+ */
+ public Optional partialUpdate(PPreguntaCerrada pPreguntaCerrada) {
+ log.debug("Request to partially update PPreguntaCerrada : {}", pPreguntaCerrada);
+
+ return pPreguntaCerradaRepository
+ .findById(pPreguntaCerrada.getId())
+ .map(
+ existingPPreguntaCerrada -> {
+ if (pPreguntaCerrada.getNombre() != null) {
+ existingPPreguntaCerrada.setNombre(pPreguntaCerrada.getNombre());
+ }
+ if (pPreguntaCerrada.getTipo() != null) {
+ existingPPreguntaCerrada.setTipo(pPreguntaCerrada.getTipo());
+ }
+ if (pPreguntaCerrada.getOpcional() != null) {
+ existingPPreguntaCerrada.setOpcional(pPreguntaCerrada.getOpcional());
+ }
+ if (pPreguntaCerrada.getOrden() != null) {
+ existingPPreguntaCerrada.setOrden(pPreguntaCerrada.getOrden());
+ }
+
+ return existingPPreguntaCerrada;
+ }
+ )
+ .map(pPreguntaCerradaRepository::save);
+ }
+
+ /**
+ * Get all the pPreguntaCerradas.
+ *
+ * @return the list of entities.
+ */
+ @Transactional(readOnly = true)
+ public List