generator-jhipster 7.1.0 → 7.4.0

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/CustomCouchbaseRepositoryFactory.java.ejs

@@ -0,0 +1,83 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config.couchbase;
+
+import java.lang.reflect.Method;
+import java.util.Optional;
+import org.springframework.data.couchbase.core.CouchbaseOperations;
+import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
+import org.springframework.data.couchbase.repository.query.CouchbaseQueryMethod;
+import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactory;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.projection.ProjectionFactory;
+import org.springframework.data.repository.core.NamedQueries;
+import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.repository.query.QueryLookupStrategy;
+import org.springframework.data.repository.query.QueryMethodEvaluationContextProvider;
+import org.springframework.data.repository.query.RepositoryQuery;
+
+public class CustomCouchbaseRepositoryFactory extends CouchbaseRepositoryFactory {
+
+    private MappingContext mappingContext;
+    private RepositoryOperationsMapping couchbaseOperationsMapping;
+
+    /**
+     * Create a new factory.
+     *
+     * @param couchbaseOperationsMapping the template for the underlying actions.
+     */
+    public CustomCouchbaseRepositoryFactory(RepositoryOperationsMapping couchbaseOperationsMapping) {
+        super(couchbaseOperationsMapping);
+        this.couchbaseOperationsMapping = couchbaseOperationsMapping;
+        this.mappingContext = this.couchbaseOperationsMapping.getMappingContext();
+    }
+
+    @Override
+    protected Optional<QueryLookupStrategy> getQueryLookupStrategy(
+        QueryLookupStrategy.Key key,
+        QueryMethodEvaluationContextProvider contextProvider
+    ) {
+        return Optional.of(new CustomCouchbaseQueryLookupStrategy(contextProvider));
+    }
+
+    private class CustomCouchbaseQueryLookupStrategy implements QueryLookupStrategy {
+
+        private final QueryMethodEvaluationContextProvider evaluationContextProvider;
+
+        public CustomCouchbaseQueryLookupStrategy(QueryMethodEvaluationContextProvider evaluationContextProvider) {
+            this.evaluationContextProvider = evaluationContextProvider;
+        }
+
+        @Override
+        public RepositoryQuery resolveQuery(
+            final Method method,
+            final RepositoryMetadata metadata,
+            final ProjectionFactory factory,
+            final NamedQueries namedQueries
+        ) {
+            final CouchbaseOperations couchbaseOperations = couchbaseOperationsMapping.resolve(
+                metadata.getRepositoryInterface(),
+                metadata.getDomainType()
+            );
+
+            CouchbaseQueryMethod queryMethod = new CouchbaseQueryMethod(method, metadata, factory, mappingContext);
+            return new CustomCouchbaseRepositoryQuery(couchbaseOperations, queryMethod, namedQueries);
+        }
+    }
+}

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/CustomCouchbaseRepositoryFactoryBean.java.ejs

@@ -0,0 +1,40 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config.couchbase;
+
+import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
+import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactory;
+import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactoryBean;
+
+public class CustomCouchbaseRepositoryFactoryBean extends CouchbaseRepositoryFactoryBean {
+
+    /**
+     * Creates a new {@link CouchbaseRepositoryFactoryBean} for the given repository interface.
+     *
+     * @param repositoryInterface must not be {@literal null}.
+     */
+    public CustomCouchbaseRepositoryFactoryBean(Class repositoryInterface) {
+        super(repositoryInterface);
+    }
+
+    @Override
+    protected CouchbaseRepositoryFactory getFactoryInstance(RepositoryOperationsMapping operationsMapping) {
+        return new CustomCouchbaseRepositoryFactory(operationsMapping);
+    }
+}

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/CustomCouchbaseRepositoryQuery.java.ejs

@@ -0,0 +1,44 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config.couchbase;
+
+import org.springframework.data.couchbase.core.CouchbaseOperations;
+import org.springframework.data.couchbase.repository.query.CouchbaseQueryMethod;
+import org.springframework.data.couchbase.repository.query.CouchbaseRepositoryQuery;
+import org.springframework.data.repository.core.NamedQueries;
+import <%= packageName %>.config.couchbase.CustomN1qlRepositoryQueryExecutor;
+
+public class CustomCouchbaseRepositoryQuery extends CouchbaseRepositoryQuery {
+
+    private CouchbaseOperations couchbaseOperations;
+    private CouchbaseQueryMethod queryMethod;
+    private NamedQueries namedQueries;
+
+    public CustomCouchbaseRepositoryQuery(CouchbaseOperations operations, CouchbaseQueryMethod queryMethod, NamedQueries namedQueries) {
+        super(operations, queryMethod, namedQueries);
+        this.couchbaseOperations = operations;
+        this.queryMethod = queryMethod;
+        this.namedQueries = namedQueries;
+    }
+
+    @Override
+    public Object execute(final Object[] parameters) {
+        return new CustomN1qlRepositoryQueryExecutor(couchbaseOperations, queryMethod, namedQueries).execute(parameters);
+    }
+}

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/CustomN1qlQueryCreator.java.ejs

@@ -0,0 +1,162 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config.couchbase;
+
+import static org.springframework.data.couchbase.core.query.N1QLExpression.*;
+
+import java.util.Iterator;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.couchbase.core.CouchbaseOperations;
+import org.springframework.data.couchbase.core.convert.CouchbaseConverter;
+import org.springframework.data.couchbase.core.mapping.CouchbasePersistentProperty;
+import org.springframework.data.couchbase.core.query.Query;
+import org.springframework.data.couchbase.core.query.QueryCriteria;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mapping.PersistentPropertyPath;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.repository.query.ParameterAccessor;
+import org.springframework.data.repository.query.QueryMethod;
+import org.springframework.data.repository.query.parser.AbstractQueryCreator;
+import org.springframework.data.repository.query.parser.Part;
+import org.springframework.data.repository.query.parser.PartTree;
+
+public class CustomN1qlQueryCreator extends AbstractQueryCreator<Query, QueryCriteria> {
+
+    private final CouchbaseOperations couchbaseOperations;
+    private final ParameterAccessor accessor;
+    private final MappingContext<?, CouchbasePersistentProperty> context;
+    private final QueryMethod queryMethod;
+    private final CouchbaseConverter converter;
+
+    public CustomN1qlQueryCreator(
+        final CouchbaseOperations operations,
+        final PartTree tree,
+        final ParameterAccessor accessor,
+        QueryMethod queryMethod,
+        CouchbaseConverter converter
+    ) {
+        super(tree, accessor);
+        this.accessor = accessor;
+        this.context = converter.getMappingContext();
+        this.queryMethod = queryMethod;
+        this.converter = converter;
+        this.couchbaseOperations = operations;
+    }
+
+    static Converter<? super CouchbasePersistentProperty, String> cvtr = source ->
+        new StringBuilder(source.getFieldName().length() + 2).append('`').append(source.getFieldName()).append('`').toString();
+
+    @Override
+    protected QueryCriteria create(final Part part, final Iterator<Object> iterator) {
+        PersistentPropertyPath<CouchbasePersistentProperty> path = context.getPersistentPropertyPath(part.getProperty());
+        CouchbasePersistentProperty property = path.getLeafProperty();
+        return from(part, property, QueryCriteria.where(addMetaIfIdProperty(path, property)), iterator);
+    }
+
+    @Override
+    protected QueryCriteria and(Part part, QueryCriteria base, Iterator<Object> iterator) {
+        if (base == null) {
+            return create(part, iterator);
+        }
+        PersistentPropertyPath<CouchbasePersistentProperty> path = context.getPersistentPropertyPath(part.getProperty());
+        CouchbasePersistentProperty property = path.getLeafProperty();
+        return from(part, property, base.and(addMetaIfIdProperty(path, property)), iterator);
+    }
+
+    private String addMetaIfIdProperty(
+        final PersistentPropertyPath<CouchbasePersistentProperty> path,
+        final CouchbasePersistentProperty property
+    ) {
+        return path.toDotPath(cvtr);
+    }
+
+    @Override
+    protected QueryCriteria or(QueryCriteria base, QueryCriteria criteria) {
+        return base.or(criteria);
+    }
+
+    @Override
+    protected Query complete(QueryCriteria criteria, Sort sort) {
+        return (criteria == null ? new Query() : new Query().addCriteria(criteria)).with(sort);
+    }
+
+    private QueryCriteria from(
+        final Part part,
+        final CouchbasePersistentProperty property,
+        final QueryCriteria criteria,
+        final Iterator<Object> parameters
+    ) {
+        final Part.Type type = part.getType();
+
+        switch (type) {
+            case GREATER_THAN:
+            case AFTER:
+                return criteria.gt(parameters.next());
+            case GREATER_THAN_EQUAL:
+                return criteria.gte(parameters.next());
+            case LESS_THAN:
+            case BEFORE:
+                return criteria.lt(parameters.next());
+            case LESS_THAN_EQUAL:
+                return criteria.lte(parameters.next());
+            case SIMPLE_PROPERTY:
+                return criteria.eq(parameters.next());
+            case NEGATING_SIMPLE_PROPERTY:
+                return criteria.ne(parameters.next());
+            case CONTAINING:
+                return criteria.containing(parameters.next());
+            case NOT_CONTAINING:
+                return criteria.notContaining(parameters.next());
+            case STARTING_WITH:
+                return criteria.startingWith(parameters.next());
+            case ENDING_WITH:
+                return criteria.endingWith(parameters.next());
+            case LIKE:
+                return criteria.like(parameters.next());
+            case NOT_LIKE:
+                return criteria.notLike(parameters.next());
+            case WITHIN:
+                return criteria.within(parameters.next());
+            case IS_NULL:
+                return criteria.isNull();
+            case IS_NOT_NULL:
+                return criteria.isNotNull();
+            case IS_EMPTY:
+                return criteria.isNotValued();
+            case IS_NOT_EMPTY:
+                return criteria.isValued();
+            case EXISTS:
+                return criteria.isNotMissing();
+            case REGEX:
+                return criteria.regex(parameters.next());
+            case BETWEEN:
+                return criteria.between(parameters.next(), parameters.next());
+            case IN:
+                return criteria.in(parameters.next());
+            case NOT_IN:
+                return criteria.notIn(parameters.next());
+            case TRUE:
+                return criteria.TRUE();
+            case FALSE:
+                return criteria.FALSE();
+            default:
+                throw new IllegalArgumentException("Unsupported keyword!");
+        }
+    }
+}

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/CustomN1qlRepositoryQueryExecutor.java.ejs

@@ -0,0 +1,104 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config.couchbase;
+
+import com.couchbase.client.java.query.QueryScanConsistency;
+import org.springframework.data.couchbase.core.CouchbaseOperations;
+import org.springframework.data.couchbase.core.ExecutableFindByQueryOperation;
+import org.springframework.data.couchbase.core.query.Query;
+import org.springframework.data.couchbase.repository.query.CouchbaseQueryMethod;
+import org.springframework.data.couchbase.repository.query.ReactiveN1qlRepositoryQueryExecutor;
+import org.springframework.data.couchbase.repository.query.StringN1qlQueryCreator;
+import org.springframework.data.repository.core.NamedQueries;
+import org.springframework.data.repository.query.ParameterAccessor;
+import org.springframework.data.repository.query.ParametersParameterAccessor;
+import org.springframework.data.repository.query.QueryMethodEvaluationContextProvider;
+import org.springframework.data.repository.query.parser.PartTree;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+
+public class CustomN1qlRepositoryQueryExecutor {
+
+    private final CouchbaseOperations operations;
+    private final CouchbaseQueryMethod queryMethod;
+    private final NamedQueries namedQueries;
+
+    public CustomN1qlRepositoryQueryExecutor(
+        final CouchbaseOperations operations,
+        final CouchbaseQueryMethod queryMethod,
+        final NamedQueries namedQueries
+    ) {
+        this.operations = operations;
+        this.queryMethod = queryMethod;
+        this.namedQueries = namedQueries;
+    }
+
+    /**
+     * see also {@link ReactiveN1qlRepositoryQueryExecutor#execute(Object[] parameters) execute }
+     *
+     * @param parameters substitute values
+     * @return with data
+     */
+    public Object execute(final Object[] parameters) {
+        final Class<?> domainClass = queryMethod.getResultProcessor().getReturnedType().getDomainType();
+        final ParameterAccessor accessor = new ParametersParameterAccessor(queryMethod.getParameters(), parameters);
+
+        // this is identical to ReactiveN1qlRespositoryQueryExecutor,
+        // except for the type of 'q', and the call to oneValue() vs one()
+        Query query;
+        ExecutableFindByQueryOperation.ExecutableFindByQuery q;
+        if (queryMethod.hasN1qlAnnotation()) {
+            query =
+                new StringN1qlQueryCreator(
+                    accessor,
+                    queryMethod,
+                    operations.getConverter(),
+                    operations.getBucketName(),
+                    new SpelExpressionParser(),
+                    QueryMethodEvaluationContextProvider.DEFAULT,
+                    namedQueries
+                )
+                    .createQuery();
+        } else {
+            final PartTree tree = new PartTree(queryMethod.getName(), domainClass);
+            query = new CustomN1qlQueryCreator(operations, tree, accessor, queryMethod, operations.getConverter()).createQuery();
+        }
+        q =
+            (ExecutableFindByQueryOperation.ExecutableFindByQuery) operations
+                .findByQuery(domainClass)
+                .consistentWith(buildQueryScanConsistency())
+                .matching(query);
+        if (queryMethod.isCountQuery()) {
+            return q.count();
+        } else if (queryMethod.isCollectionQuery()) {
+            return q.all();
+        } else {
+            return q.oneValue();
+        }
+    }
+
+    private QueryScanConsistency buildQueryScanConsistency() {
+        QueryScanConsistency scanConsistency = QueryScanConsistency.NOT_BOUNDED;
+        if (queryMethod.hasConsistencyAnnotation()) {
+            scanConsistency = queryMethod.getConsistencyAnnotation().value();
+        } else if (queryMethod.hasScanConsistencyAnnotation()) {
+            scanConsistency = queryMethod.getScanConsistencyAnnotation().query();
+        }
+        return scanConsistency;
+    }
+}

package/generators/server/templates/couchbase/src/main/java/package/config/couchbase/package-info.java.ejs

@@ -0,0 +1,25 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+/**
+ * Classes in this package are meant to extend Spring Data Couchbase
+ * and fix some of the issues encountered during integration.
+ */
+package <%= packageName %>.config.couchbase;
+
+

package/generators/server/templates/couchbase/src/main/java/package/repository/JHipsterCouchbaseRepository.java.ejs

@@ -0,0 +1,114 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.repository;
+
+import com.couchbase.client.java.query.QueryScanConsistency;
+import org.springframework.data.couchbase.repository.<% if (reactive) { %>Reactive<% } %>CouchbaseRepository;
+import org.springframework.data.couchbase.repository.ScanConsistency;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.repository.NoRepositoryBean;
+<%_ if (searchEngineCouchbase) { _%>
+import com.couchbase.client.java.search.SearchQuery;
+import com.couchbase.client.java.search.queries.DocIdQuery;
+import com.couchbase.client.java.search.queries.QueryStringQuery;
+import java.util.LinkedList;
+<%_ } _%>
+
+<%_ if (reactive) { _%>
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+<%_ } else { _%>
+import org.springframework.data.domain.Page;
+<%_ } _%>
+
+import java.util.List;
+import java.util.stream.Collectors;
+import org.springframework.data.couchbase.core.query.Query;
+
+import static java.lang.String.format;
+
+/**
+ * Couchbase specific {@link org.springframework.data.repository.Repository} interface uses N1QL for all requests.
+ */
+<%_
+    let listOrFlux = reactive ? 'Flux' : 'List';
+    let pageOrFlux = reactive ? 'Flux' : 'Page';
+_%>
+@NoRepositoryBean
+public interface JHipsterCouchbaseRepository<T, ID> extends <% if (reactive) { %>Reactive<% } %>CouchbaseRepository<T, ID> {
+
+    static String pageableStatement(Pageable pageable) {
+        return pageableStatement(pageable, "");
+    }
+
+    static String pageableStatement(Pageable pageable, String prefix) {
+        Sort sort = Sort.by(
+            pageable.getSort().stream()
+                .map(order -> {
+                    String property = order.getProperty();
+                    if ("id".equals(property)) {
+                        return order.withProperty(format("meta(%s).id", prefix));
+                    }
+                    if (prefix.isEmpty()) {
+                        return order;
+                    }
+                    return order.withProperty(format("%s.%s", prefix, property));
+                })
+                .collect(Collectors.toList()));
+        return new Query()
+            .limit(pageable.getPageSize())
+            .skip(pageable.getOffset())
+            .with(sort)
+            .export();
+    }
+
+<%_ if (searchEngineCouchbase) { _%>
+    static SearchQuery searchQuery(String queryString) {
+        List<String> ids = new LinkedList<>();
+        for (String r : queryString.split(" ")) {
+            if (r.indexOf("id:") == 0) {
+                ids.add(r.substring(3));
+                queryString = queryString.replace(r, "").replaceAll("[ ]+", " ").trim();
+            }
+        }
+        QueryStringQuery query = SearchQuery.queryString(queryString);
+        if (ids.size() != 0) {
+            DocIdQuery docIdQuery = SearchQuery.docId(ids.toArray(new String[0]));
+            if (!queryString.isEmpty()) {
+                return SearchQuery.conjuncts(query, docIdQuery);
+            }
+            return docIdQuery;
+        }
+        return query;
+    }
+<%_ } _%>
+
+    @ScanConsistency(query = QueryScanConsistency.REQUEST_PLUS)
+    <%= listOrFlux %><T> findAll();
+
+    @ScanConsistency(query = QueryScanConsistency.REQUEST_PLUS)
+    <%= listOrFlux %><T> findAll(Sort sort);
+
+    @ScanConsistency(query = QueryScanConsistency.REQUEST_PLUS)
+    <%= pageOrFlux %><T> findAll<% if (reactive) { %>By<% } %>(Pageable pageable);
+
+    @ScanConsistency(query = QueryScanConsistency.REQUEST_PLUS)
+    <% if (reactive) { %>Mono<Void><% } else { %>void<% } %> deleteAll();
+}

package/generators/server/templates/couchbase/src/main/java/package/repository/PersistentTokenRepository_couchbase.java.ejs

@@ -0,0 +1,49 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.repository;
+
+import <%= packageName %>.domain.PersistentToken;
+import <%= packageName %>.domain.<%= asEntity('User') %>;
+import org.springframework.data.couchbase.repository.CouchbaseRepository;
+import java.util.List;
+import java.util.Optional;
+import static <%= packageName %>.config.Constants.ID_DELIMITER;
+
+/**
+ * Spring Data Couchbase repository for the {@link PersistentToken} entity.
+ */
+public interface PersistentTokenRepository extends CouchbaseRepository<PersistentToken, String> {
+
+    default Optional<PersistentToken> findBySeries(String series) {
+        return findById(PersistentToken.PREFIX + ID_DELIMITER + series);
+    }
+
+    default void deleteBySeries(String series) {
+        deleteById(PersistentToken.PREFIX + ID_DELIMITER + series);
+    }
+
+    default List<PersistentToken> findByUser(<%= asEntity('User') %> user) {
+        return findByLogin(user.getLogin());
+    }
+
+    List<PersistentToken> findByLogin(String login);
+
+    List<PersistentToken> findByTokenDateBefore(LocalDate localDate);
+
+}

package/generators/server/templates/couchbase/src/main/resources/config/couchmove/changelog/V0.1__initial_setup/user__admin.json.ejs

@@ -0,0 +1,18 @@
+{
+  "login": "admin",
+<%_ if (!authenticationTypeOauth2) { _%>
+  "password": "$2a$10$gSAhZrxMllrbgj/kkK9UceBPpChGWJA7SYIb1Mqo.n5aNLq1/oRrC",
+<% } %>
+  "firstName": "Administrator",
+  "lastName": "Administrator",
+  "email": "admin@localhost",
+  "activated": true,
+  "langKey": "<%= nativeLanguage %>",
+  "createdBy": "system",
+  "lastModifiedBy": "system",
+  "authorities": [
+    "ROLE_USER",
+    "ROLE_ADMIN"
+  ],
+  "_class": "<%= packageName %>.domain.<%= asEntity('User') %>"
+}

package/generators/server/templates/couchbase/src/main/resources/config/couchmove/changelog/V0.1__initial_setup/user__user.json.ejs

@@ -0,0 +1,17 @@
+{
+  "login": "user",
+<%_ if (!authenticationTypeOauth2) { _%>
+  "password": "$2a$10$VEjxo0jq2YG9Rbk2HmX9S.k1uZBGYUHdUcid3g/vfiEl7lwWgOH/K",
+<% } %>
+  "firstName": "User",
+  "lastName": "User",
+  "email": "user@localhost",
+  "activated": true,
+  "langKey": "<%= nativeLanguage %>",
+  "createdBy": "system",
+  "lastModifiedBy": "system",
+  "authorities": [
+    "ROLE_USER"
+  ],
+  "_class": "<%= packageName %>.domain.<%= asEntity('User') %>"
+}