How to use

NodeRepository

in

de.juplo.yourshouter.api.persistence

@Bean
public StorageHandler nodeHandler(NodeRepository nodeRepository)
{
 return (NodeData node) -> nodeRepository.store(node);
}

 public NodeStatus remove(Uri uri)
 {
  NodeData node = repository.get(uri);
  if (node == null)
  {
   LOG.info("already removed: {}", uri);
   return new NodeStatus(uri, Status.UNMODIFIED, node);
  }
  else
  {
   LOG.info("removed:     {}", uri);
   repository.remove(node);
   notifier.removed(uri);
   return new NodeStatus(uri, Status.REMOVED, node);
  }
 }
}

public Set<Uri> stored(NodeType... types)
{
 return repository.stored(types);
}

assertFalse(nodeRepository.exists(uriLocation));
nodeRepository.store(location);
flush();
assertEquals(1, notifier.created.size());
assertTrue(nodeRepository.exists(uriLocation));
assertEquals(location, nodeRepository.get(uriLocation));
stored = nodeRepository.stored(uriLocation.getType());
assertEquals(1, stored.size());
assertEquals(uriLocation, stored.iterator().next());
 assertEquals(location, nodeRepository.getLocation(uriLocation.getId()));
assertFalse(nodeRepository.exists(uriEvent));
nodeRepository.store(event);
flush();
assertEquals(1, notifier.created.size());
assertTrue(nodeRepository.exists(uriEvent));
assertEquals(event, nodeRepository.get(uriEvent));
assertEquals(location, ((EventData)nodeRepository.get(uriEvent)).getGenerator());
stored = nodeRepository.stored(uriEvent.getType());
assertEquals(1, stored.size());
assertEquals(uriEvent, stored.iterator().next());
 assertEquals(event, nodeRepository.getEvent(uriEvent.getId()));

@Test
public void testStoreAndGetPerson() throws Exception
{
 LOG.debug("<-- start of new test-case");
 Set<Uri> stored;
 assertFalse(nodeRepository.exists(uriPerson));
 notifier.clear();
 nodeRepository.store(person);
 flush();
 assertEquals(1, notifier.created.size());
 assertEquals(uriPerson, notifier.created.iterator().next());
 assertEquals(0, notifier.updated.size());
 assertEquals(0, notifier.removed.size());
 assertTrue(nodeRepository.exists(uriPerson));
 assertEquals(person, nodeRepository.get(uriPerson));
 stored = nodeRepository.stored(uriPerson.getType());
 assertEquals(1, stored.size());
 assertEquals(uriPerson, stored.iterator().next());
 Storage.openStage(nodeRepository, null, config, (NodeData n) -> {}, null, null);
 try
 {
  assertEquals(person, nodeRepository.getPerson(uriPerson.getId()));
 }
 finally
 {
  Storage.closeStage();
 }
}

@Test
public void testStoreAndGetVenue() throws Exception
{
 LOG.debug("<-- start of new test-case");
 Set<Uri> stored;
 assertFalse(nodeRepository.exists(uriVenue));
 notifier.clear();
 nodeRepository.store(venue);
 flush();
 assertEquals(1, notifier.created.size());
 assertEquals(uriVenue, notifier.created.iterator().next());
 assertEquals(0, notifier.updated.size());
 assertEquals(0, notifier.removed.size());
 assertTrue(nodeRepository.exists(uriVenue));
 assertEquals(venue, nodeRepository.get(uriVenue));
 stored = nodeRepository.stored(uriVenue.getType());
 assertEquals(1, stored.size());
 assertEquals(uriVenue, stored.iterator().next());
 Storage.openStage(nodeRepository, null, config, (NodeData n) -> {}, null, null);
 try
 {
  assertEquals(venue, nodeRepository.getVenue(uriVenue.getId()));
 }
 finally
 {
  Storage.closeStage();
 }
}

stored = nodeRepository.stored(PERSON);
assertEquals(0, stored.size());
stored = nodeRepository.stored(VENUE);
assertEquals(0, stored.size());
stored = nodeRepository.stored();
assertEquals(0, stored.size());
nodeRepository.store(person);
flush();
stored = nodeRepository.stored(PERSON);
assertEquals(1, stored.size());
assertEquals(uriPerson, stored.iterator().next());
stored = nodeRepository.stored(VENUE);
assertEquals(0, stored.size());
stored = nodeRepository.stored();
assertEquals(1, stored.size());
assertTrue(stored.contains(uriPerson));
nodeRepository.store(venue);
flush();
stored = nodeRepository.stored(PERSON);
assertEquals(1, stored.size());
assertEquals(uriPerson, stored.iterator().next());
stored = nodeRepository.stored(VENUE);
assertEquals(1, stored.size());
assertEquals(uriVenue, stored.iterator().next());
stored = nodeRepository.stored();

@Test
public void testExists()
{
 LOG.debug("<-- start of new test-case");
 assertFalse(nodeRepository.exists(uriPerson));
 assertFalse(nodeRepository.exists(uriVenue));
 nodeRepository.store(person);
 assertTrue(nodeRepository.exists(uriPerson));
 assertFalse(nodeRepository.exists(uriVenue));
 nodeRepository.store(venue);
 assertTrue(nodeRepository.exists(uriPerson));
 assertTrue(nodeRepository.exists(uriVenue));
 nodeRepository.remove(uriPerson);
 assertFalse(nodeRepository.exists(uriPerson));
 assertTrue(nodeRepository.exists(uriVenue));
 // Remove non-existent should not change anything
 nodeRepository.remove(uriPerson);
 assertFalse(nodeRepository.exists(uriPerson));
 assertTrue(nodeRepository.exists(uriVenue));
 nodeRepository.remove(uriVenue);
 assertFalse(nodeRepository.exists(uriPerson));
 assertFalse(nodeRepository.exists(uriVenue));
}

@Test
public void testStoreAndGetDateWithType() throws Exception
{
 LOG.debug("<-- start of new test-case");
 config.createType("START|END");
 DetachedDate detached = (DetachedDate)parse("/xml/nodes/date.xml");
 notifier.clear();
 nodeRepository.store(detached.getNodeData());
 flush();
 assertEquals(1, notifier.created.size());
 assertEquals(detached.getUri(), notifier.created.iterator().next());
 assertEquals(0, notifier.updated.size());
 assertEquals(0, notifier.removed.size());
 assertTrue(nodeRepository.exists(detached.getUri()));
 NodeData node = nodeRepository.get(detached.getUri());
 assertNotNull(node);
 assertEquals(DATE, node.getNodeType());
 assertEquals("114095325941506", node.getId());
 DateData date = (DateData)node;
 assertEquals(detached.getType(), date.getType());
}

nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
assertEquals(0, notifier.updated.size());
assertEquals(0, notifier.removed.size());
node = nodeRepository.get(flat.getUri());
assertEquals("💩", node.getName());
assertEquals(nodeRepository.get(flat.getUri()), node);
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
assertEquals(0, notifier.updated.size());
assertEquals(0, notifier.removed.size());
node = nodeRepository.get(flat.getUri());
assertEquals("ФУЗИОН", node.getName());
assertEquals(nodeRepository.get(flat.getUri()), node);
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
assertEquals(0, notifier.updated.size());
assertEquals(0, notifier.removed.size());
node = nodeRepository.get(flat.getUri());
assertEquals("Ł", node.getName());
assertEquals(nodeRepository.get(flat.getUri()), node);

public NodeData get(Uri uri)
{
 return repository.get(uri);
}

@Override
public NodeData remove(Uri uri)
{
 NodeData node = nodeRepository.remove(uri);
 LOG.debug("RECORDING REMOVED NODE: {} -> {}", uri);
 stored.remove(uri);
 removed.put(uri, node);
 return node;
}

Set<String> ids;
CategoryData konzerte = nodeRepository.getCategory("3");
CategoryData ausstellungen = nodeRepository.getCategory("1");
CityData münster = nodeRepository.getCity("münster");
CityData dortmund = nodeRepository.getCity("dortmund");

@Test
public void testGetCities()
{
 LOG.debug("<-- start of new test-case");
 parse("/xml/rce/model.xml");
 List<City> found;
 found = nodeService.getCities(null, 0, 100);
 log(found);
 assertEquals("unexpected number of cities found", 18, found.size());
 found = nodeService.getCities(null, 0, 100, nodeRepository.getCountry("DE"));
 log(found);
 assertEquals("unexpected number of cities found", 17, found.size());
 found = nodeService.getCities(null, 0, 100, nodeRepository.getCountry("I"));
 log(found);
 assertEquals("unexpected number of cities found", 1, found.size());
 found = nodeService.getCities(null, 0, 100, nodeRepository.getState("NRW"));
 log(found);
 assertEquals("unexpected number of cities found", 8, found.size());
}

@Override
public CityData getCity(String id)
{
 return (CityData)nodeRepository.getCity(id);
}

@Override
public CountryData getCountry(String id)
{
 return (CountryData)nodeRepository.getCountry(id);
}

public void flush()
{
 repository.flush();
}

@Override
public CategoryData getCategory(String id)
{
 return (CategoryData)nodeRepository.getCategory(id);
}

@Override
public NodeData get(Uri uri)
{
 return nodeRepository.get(uri);
}

 @Bean
 public Consumer<NodeData> remove(NodeRepository nodeRepository)
 {
  return (NodeData node) -> nodeRepository.remove(node.getUri());
 }
}