How to use

store

method

in

de.juplo.yourshouter.api.persistence.NodeRepository

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

assertEquals(0, stored.size());
nodeRepository.store(person);
flush();
assertTrue(stored.contains(uriPerson));
nodeRepository.store(venue);
flush();

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

@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();
 }
}

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

@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();
 }
}

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

nodeRepository.store(location);
flush();
assertEquals(1, notifier.created.size());
nodeRepository.store(event);
flush();
assertEquals(1, notifier.created.size());

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

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

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

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

@Override
public void store(NodeData node)
{
 nodeRepository.store(node);
 LOG.debug("RECORDING STORED NODE: {}", node);
 stored.put(node.getUri(), node);
}

public NodeStatus store(NodeData node)
{
 Uri uri = identity.getId(node);
 if (!Uri.get(node).equals(uri))
 {
  LOG.debug("changing URI: {} -> {}", Uri.get(node), uri);
  node.setUri(uri);
 }
 NodeData old = get(uri);
 if (old == null)
 {
  LOG.info("created:     {}", uri);
  node = repository.store(node);
  notifier.created(uri);
  return new NodeStatus(uri, Status.CREATED, node);
 }
 if (tracker.modified(old, node))
 {
  LOG.info("updated:     {}", uri);
  node = repository.store(node);
  notifier.updated(uri);
  return new NodeStatus(uri, Status.MODIFIED, node);
 }
 else
 {
  LOG.info("unmodified:  {}", uri);
  return new NodeStatus(uri, Status.UNMODIFIED, node);
 }
}

@Before
public void prepare()
{
 Storage.openStage(nodeRepository, nodeService, config, nodeHandler, null, null);
 try
 {
  country.setSource(source);
  nodeRepository.store(country);
  state.setSource(source);
  nodeRepository.store(state);
  city.setSource(source);
  nodeRepository.store(city);
  district.setSource(source);
  nodeRepository.store(district);
  region.setSource(source);
  nodeRepository.store(region);
  category.setSource(source);
  nodeRepository.store(category);
  media.setSource(source);
  nodeRepository.store(media);
  recordingNodeRepository.clear();
 }
 finally
 {
  Storage.closeStage();
 }
}

@Test
public void testVersion()
{
 LOG.debug("<-- start of new test-case");
 assertNull(person.getVersion());
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
 person.setName("NAME");
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
 person.setLastName("Lustig");
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
 person.setName("NAME");
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
 person.setName("Peter");
 nodeRepository.store(person);
 flush();
 assertNull(person.getVersion());
}

@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());
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());
nodeRepository.store(flat.getNodeData());
flush();
assertEquals(1, notifier.created.size());

@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));
}