chore(dataplane): migrate LoginAttemptRepository to dataplane plugin

gravitee-am-dataplane/gravitee-am-dataplane-api/src/main/java/io/gravitee/am/dataplane/api/DataPlaneProvider.java

@@ -18,6 +18,7 @@
 import io.gravitee.am.dataplane.api.repository.CredentialRepository;
 import io.gravitee.am.dataplane.api.repository.DeviceRepository;
 import io.gravitee.am.dataplane.api.repository.GroupRepository;
+import io.gravitee.am.dataplane.api.repository.LoginAttemptRepository;
 import io.gravitee.am.dataplane.api.repository.PasswordHistoryRepository;
 import io.gravitee.am.dataplane.api.repository.ScopeApprovalRepository;
 import io.gravitee.am.dataplane.api.repository.UserActivityRepository;
@@ -40,4 +41,6 @@ public interface DataPlaneProvider {
     UserRepository getUserRepository();
 
     PasswordHistoryRepository getPasswordHistoryRepository();
+
+    LoginAttemptRepository getLoginAttemptRepository();
 }

gravitee-am-service/src/main/java/io/gravitee/am/service/LoginAttemptService.java → gravitee-am-dataplane/gravitee-am-dataplane-api/src/main/java/io/gravitee/am/dataplane/api/repository/LoginAttemptRepository.java

@@ -13,30 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.gravitee.am.service;
+package io.gravitee.am.dataplane.api.repository;
 
+import io.gravitee.am.dataplane.api.search.LoginAttemptCriteria;
 import io.gravitee.am.model.LoginAttempt;
-import io.gravitee.am.model.account.AccountSettings;
-import io.gravitee.am.repository.management.api.search.LoginAttemptCriteria;
+import io.gravitee.am.repository.common.CrudRepository;
 import io.reactivex.rxjava3.core.Completable;
 import io.reactivex.rxjava3.core.Maybe;
-import io.reactivex.rxjava3.core.Single;
 
 /**
  * @author Titouan COMPIEGNE (titouan.compiegne at graviteesource.com)
  * @author GraviteeSource Team
  */
-public interface LoginAttemptService {
+public interface LoginAttemptRepository extends CrudRepository<LoginAttempt, String> {
 
-    Completable loginSucceeded(LoginAttemptCriteria criteria);
-
-    Single<LoginAttempt> loginFailed(LoginAttemptCriteria criteria, AccountSettings accountSettings);
-
-    Completable reset(LoginAttemptCriteria criteria);
-
-    Maybe<LoginAttempt> checkAccount(LoginAttemptCriteria criteria, AccountSettings accountSettings);
-
-    Maybe<LoginAttempt> findById(String id);
+    Maybe<LoginAttempt> findByCriteria(LoginAttemptCriteria criteria);
 
+    Completable delete(LoginAttemptCriteria criteria);
 
+    default Completable purgeExpiredData() {
+        return Completable.complete();
+    }
 }

gravitee-am-dataplane/gravitee-am-dataplane-api/src/main/java/io/gravitee/am/dataplane/api/search/LoginAttemptCriteria.java

@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * 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
+ *
+ *         http://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 io.gravitee.am.dataplane.api.search;
+
+/**
+ * @author Titouan COMPIEGNE (titouan.compiegne at graviteesource.com)
+ * @author GraviteeSource Team
+ */
+public class LoginAttemptCriteria {
+
+    private String domain;
+    private String client;
+    private String identityProvider;
+    private String username;
+
+    public LoginAttemptCriteria(Builder builder) {
+        domain = builder.domain;
+        client = builder.client;
+        identityProvider = builder.identityProvider;
+        username = builder.username;
+    }
+
+    public String domain() {
+        return domain;
+    }
+
+    public String client() {
+        return client;
+    }
+
+    public String identityProvider() {
+        return identityProvider;
+    }
+
+    public String username() {
+        return username;
+    }
+
+    public static class Builder {
+        private String domain;
+        private String client;
+        private String identityProvider;
+        private String username;
+
+        public Builder domain(String domain) {
+            this.domain = domain;
+            return this;
+        }
+
+        public Builder client(String client) {
+            this.client = client;
+            return this;
+        }
+
+        public Builder identityProvider(String identityProvider) {
+            this.identityProvider = identityProvider;
+            return this;
+        }
+
+        public Builder username(String username) {
+            this.username = username;
+            return this;
+        }
+
+        public LoginAttemptCriteria build() {
+            return new LoginAttemptCriteria(this);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "{\"_class\":\"LoginAttemptCriteria\", " +
+                "\"domain\":" + (domain == null ? "null" : "\"" + domain + "\"") + ", " +
+                "\"client\":" + (client == null ? "null" : "\"" + client + "\"") + ", " +
+                "\"identityProvider\":" + (identityProvider == null ? "null" : "\"" + identityProvider + "\"") + ", " +
+                "\"username\":" + (username == null ? "null" : "\"" + username + "\"") +
+                "}";
+    }
+}

gravitee-am-dataplane/gravitee-am-dataplane-mongodb/src/main/java/io/gravitee/am/dataplane/mongodb/provider/MongoDataPlaneProvider.java

@@ -21,6 +21,7 @@
 import io.gravitee.am.dataplane.api.repository.CredentialRepository;
 import io.gravitee.am.dataplane.api.repository.DeviceRepository;
 import io.gravitee.am.dataplane.api.repository.GroupRepository;
+import io.gravitee.am.dataplane.api.repository.LoginAttemptRepository;
 import io.gravitee.am.dataplane.api.repository.PasswordHistoryRepository;
 import io.gravitee.am.dataplane.api.repository.ScopeApprovalRepository;
 import io.gravitee.am.dataplane.api.repository.UserActivityRepository;
@@ -63,6 +64,9 @@ public class MongoDataPlaneProvider implements DataPlaneProvider, InitializingBe
     @Autowired
     private PasswordHistoryRepository passwordHistoryRepository;
 
+    @Autowired
+    private LoginAttemptRepository loginAttemptRepository;
+
     @Override
     public void afterPropertiesSet() throws Exception {
         log.info("DataPlane provider loaded with id {}", dataPlaneDescription.id());
@@ -109,4 +113,9 @@ public UserRepository getUserRepository() {
     public PasswordHistoryRepository getPasswordHistoryRepository() {
         return passwordHistoryRepository;
     }
+
+    @Override
+    public LoginAttemptRepository getLoginAttemptRepository() {
+        return loginAttemptRepository;
+    }
 }

gravitee-am-dataplane/gravitee-am-dataplane-mongodb/src/main/java/io/gravitee/am/dataplane/mongodb/repository/MongoLoginAttemptRepository.java

@@ -0,0 +1,171 @@
+/**
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * 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
+ *
+ *         http://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 io.gravitee.am.dataplane.mongodb.repository;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.client.model.IndexOptions;
+import com.mongodb.reactivestreams.client.MongoCollection;
+import io.gravitee.am.common.utils.RandomString;
+import io.gravitee.am.dataplane.api.repository.LoginAttemptRepository;
+import io.gravitee.am.dataplane.api.search.LoginAttemptCriteria;
+import io.gravitee.am.dataplane.mongodb.repository.model.LoginAttemptMongo;
+import io.gravitee.am.model.LoginAttempt;
+import io.gravitee.am.repository.mongodb.common.MongoUtils;
+import io.reactivex.rxjava3.core.Completable;
+import io.reactivex.rxjava3.core.Maybe;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Single;
+import jakarta.annotation.PostConstruct;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.env.Environment;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static com.mongodb.client.model.Filters.and;
+import static com.mongodb.client.model.Filters.eq;
+import static com.mongodb.client.model.Filters.gte;
+import static io.gravitee.am.repository.mongodb.common.MongoUtils.FIELD_CLIENT;
+import static io.gravitee.am.repository.mongodb.common.MongoUtils.FIELD_DOMAIN;
+import static io.gravitee.am.repository.mongodb.common.MongoUtils.FIELD_ID;
+
+/**
+ * @author Titouan COMPIEGNE (titouan.compiegne at graviteesource.com)
+ * @author GraviteeSource Team
+ */
+@Component
+public class MongoLoginAttemptRepository extends AbstractDataPlaneMongoRepository implements LoginAttemptRepository {
+
+    private static final String FIELD_IDP = "identityProvider";
+    private static final String FIELD_USERNAME = "username";
+    private static final String FIELD_EXPIRE_AT = "expireAt";
+    private MongoCollection<LoginAttemptMongo> loginAttemptsCollection;
+
+    @Autowired
+    private Environment environment;
+
+    @PostConstruct
+    public void init() {
+        loginAttemptsCollection = mongoDatabase.getCollection("login_attempts", LoginAttemptMongo.class);
+        MongoUtils.init(loginAttemptsCollection);
+
+        final var indexes = new HashMap<Document, IndexOptions>();
+        indexes.put(new Document(FIELD_DOMAIN, 1).append(FIELD_CLIENT, 1).append(FIELD_USERNAME, 1), new IndexOptions().name("d1c1u1"));
+        // expire after index
+        indexes.put(new Document(FIELD_EXPIRE_AT, 1), new IndexOptions().name("e1").expireAfter(0L, TimeUnit.SECONDS));
+
+        MongoUtils.createIndex(loginAttemptsCollection, indexes, getEnsureIndexOnStart());
+    }
+
+    @Override
+    public Maybe<LoginAttempt> findById(String id) {
+        return Observable.fromPublisher(loginAttemptsCollection.find(and(eq(FIELD_ID, id), gte(FIELD_EXPIRE_AT, new Date()))).first()).firstElement().map(this::convert);
+    }
+
+    @Override
+    public Maybe<LoginAttempt> findByCriteria(LoginAttemptCriteria criteria) {
+        return Observable.fromPublisher(withMaxTime(loginAttemptsCollection.find(and(query(criteria), gte(FIELD_EXPIRE_AT, new Date())))).first()).firstElement().map(this::convert);
+    }
+
+    @Override
+    public Single<LoginAttempt> create(LoginAttempt item) {
+        LoginAttemptMongo loginAttempt = convert(item);
+        loginAttempt.setId(loginAttempt.getId() == null ? RandomString.generate() : loginAttempt.getId());
+        return Single.fromPublisher(loginAttemptsCollection.insertOne(loginAttempt)).flatMap(success -> {
+            item.setId(loginAttempt.getId());
+            return Single.just(item);
+        });
+    }
+
+    @Override
+    public Single<LoginAttempt> update(LoginAttempt item) {
+        LoginAttemptMongo loginAttempt = convert(item);
+        return Single.fromPublisher(loginAttemptsCollection.replaceOne(eq(FIELD_ID, loginAttempt.getId()), loginAttempt)).flatMap(success -> Single.just(item));
+    }
+
+    @Override
+    public Completable delete(String id) {
+        return Completable.fromPublisher(loginAttemptsCollection.deleteOne(eq(FIELD_ID, id)));
+    }
+
+    @Override
+    public Completable delete(LoginAttemptCriteria criteria) {
+        return Completable.fromPublisher(loginAttemptsCollection.deleteOne(query(criteria)));
+    }
+
+    private Bson query(LoginAttemptCriteria criteria) {
+        List<Bson> filters = new ArrayList<>();
+        // domain
+        if (criteria.domain() != null && !criteria.domain().isEmpty()) {
+            filters.add(eq(FIELD_DOMAIN, criteria.domain()));
+        }
+        // client
+        if (criteria.client() != null && !criteria.client().isEmpty()) {
+            filters.add(eq(FIELD_CLIENT, criteria.client()));
+        }
+        // idp
+        if (criteria.identityProvider() != null && !criteria.identityProvider().isEmpty()) {
+            filters.add(eq(FIELD_IDP, criteria.identityProvider()));
+        }
+        // username
+        if (criteria.username() != null && !criteria.username().isEmpty()) {
+            filters.add(eq(FIELD_USERNAME, criteria.username()));
+        }
+        // build query
+        Bson query = (filters.isEmpty()) ? new BasicDBObject() : and(filters);
+        return query;
+    }
+
+    private LoginAttempt convert(LoginAttemptMongo loginAttemptMongo) {
+        if (loginAttemptMongo == null) {
+            return null;
+        }
+        LoginAttempt loginAttempt = new LoginAttempt();
+        loginAttempt.setId(loginAttemptMongo.getId());
+        loginAttempt.setDomain(loginAttemptMongo.getDomain());
+        loginAttempt.setClient(loginAttemptMongo.getClient());
+        loginAttempt.setIdentityProvider(loginAttemptMongo.getIdentityProvider());
+        loginAttempt.setUsername(loginAttemptMongo.getUsername());
+        loginAttempt.setAttempts(loginAttemptMongo.getAttempts());
+        loginAttempt.setExpireAt(loginAttemptMongo.getExpireAt());
+        loginAttempt.setCreatedAt(loginAttemptMongo.getCreatedAt());
+        loginAttempt.setUpdatedAt(loginAttemptMongo.getUpdatedAt());
+        return loginAttempt;
+    }
+
+    private LoginAttemptMongo convert(LoginAttempt loginAttempt) {
+        if (loginAttempt == null) {
+            return null;
+        }
+        LoginAttemptMongo loginAttemptMongo = new LoginAttemptMongo();
+        loginAttemptMongo.setId(loginAttempt.getId());
+        loginAttemptMongo.setDomain(loginAttempt.getDomain());
+        loginAttemptMongo.setClient(loginAttempt.getClient());
+        loginAttemptMongo.setIdentityProvider(loginAttempt.getIdentityProvider());
+        loginAttemptMongo.setUsername(loginAttempt.getUsername());
+        loginAttemptMongo.setAttempts(loginAttempt.getAttempts());
+        loginAttemptMongo.setExpireAt(loginAttempt.getExpireAt());
+        loginAttemptMongo.setCreatedAt(loginAttempt.getCreatedAt());
+        loginAttemptMongo.setUpdatedAt(loginAttempt.getUpdatedAt());
+        return loginAttemptMongo;
+    }
+}