io.committed.invest.plugin.server.repo.MapBackedUserAccountRepository Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of invest-plugin-server-auth Show documentation
Auth for Invest
The newest version!
package io.committed.invest.plugin.server.repo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.springframework.util.StringUtils;

import io.committed.invest.plugin.server.auth.dao.UserAccount;

/** User account repository which is an in memory map. */
public class MapBackedUserAccountRepository implements UnreactiveUserAccountRepository {

  private final Map db = new ConcurrentHashMap<>();

  private final AtomicLong idGenerator = new AtomicLong();

  private String randomId() {
    // ARguable a A better implementation required here which will generate something more random
    // perhaps but this should not be used in production.
    return Long.toString(idGenerator.incrementAndGet());
  }

  @Override
  public  S save(final S entity) {
    if (StringUtils.isEmpty(entity.getId())) {
      entity.setId(randomId());
    }
    db.put(entity.getId(), entity);
    return entity;
  }

  @Override
  public  Iterable saveAll(final Iterable entities) {
    return StreamSupport.stream(entities.spliterator(), false)
        .map(this::save)
        .collect(Collectors.toList());
  }

  @Override
  public Optional findById(final String id) {
    return Optional.ofNullable(db.get(id));
  }

  @Override
  public boolean existsById(final String id) {
    return db.get(id) != null;
  }

  @Override
  public Iterable findAll() {

    return Collections.unmodifiableCollection(db.values());
  }

  @Override
  public Iterable findAllById(final Iterable ids) {
    final List accounts = new ArrayList<>();
    for (final String id : ids) {
      final UserAccount userAccount = db.get(id);
      if (userAccount != null) {
        accounts.add(userAccount);
      }
    }
    return accounts;
  }

  @Override
  public long count() {
    return db.size();
  }

  @Override
  public void deleteById(final String id) {
    db.remove(id);
  }

  @Override
  public void delete(final UserAccount entity) {
    db.remove(entity.getId());
  }

  @Override
  public void deleteAll(final Iterable entities) {
    StreamSupport.stream(entities.spliterator(), false).forEach(this::delete);
  }

  @Override
  public void deleteAll() {
    db.clear();
  }

  @Override
  public void deleteByUsername(final String username) {
    if (username == null) {
      return;
    }

    final Iterator> iterator = db.entrySet().iterator();
    while (iterator.hasNext()) {
      final Entry next = iterator.next();
      if (username.equals(next.getValue().getUsername())) {
        iterator.remove();
      }
    }
  }

  @Override
  public Stream findByAuthorities(final String authority) {
    return db.values()
        .stream()
        .filter(p -> p.getAuthorities() != null && p.getAuthorities().contains(authority));
  }

  @Override
  public Optional findByUsername(final String username) {
    return db.values().stream().filter(p -> p.getUsername().equals(username)).findAny();
  }
}