@RequestMapping(value = "/{needId}", method = RequestMethod.GET)
public String viewNeed(@PathVariable String needId, Model model) {
model.addAttribute("needId", needId);
List<Need> needs = needRepository.findById(Long.valueOf(needId));
if (needs.isEmpty()) return "noNeedFound";
Need need = needs.get(0);
model.addAttribute("active", need.getState() != NeedState.ACTIVE ? "activate" : "deactivate");
model.addAttribute("needURI", need.getNeedURI());
List<Facet> facets = facetRepository.findByNeedURI(need.getNeedURI());
NeedPojo needCommandPojo = new NeedPojo(facets);
model.addAttribute("command", needCommandPojo);
NeedPojo pojo =
new NeedPojo(
need.getNeedURI(),
linkedDataSource.getDataForResource(need.getNeedURI()).getDefaultModel());
pojo.setState(need.getState());
model.addAttribute("pojo", pojo);
// set facets on 'command': (needed for the dropdown list in the 'connect' control TODO:
// deuglify
needCommandPojo.setNeedFacetURIs(pojo.getNeedFacetURIs());
return "viewNeed";
}
/**
* Creates a new Connection object. Expects <> won:hasFacet [FACET] in the RDF content, will throw
* exception if it's not there.
*
* @param needURI
* @param otherNeedURI
* @param otherConnectionURI
* @param content
* @param connectionState
* @param connectionEventType
* @return
* @throws NoSuchNeedException
* @throws IllegalMessageForNeedStateException
* @throws ConnectionAlreadyExistsException
*/
public Connection createConnection(
final URI needURI,
final URI otherNeedURI,
final URI otherConnectionURI,
final Model content,
final ConnectionState connectionState,
final ConnectionEventType connectionEventType)
throws NoSuchNeedException, IllegalMessageForNeedStateException,
ConnectionAlreadyExistsException {
if (needURI == null) throw new IllegalArgumentException("needURI is not set");
if (otherNeedURI == null) throw new IllegalArgumentException("otherNeedURI is not set");
if (needURI.equals(otherNeedURI))
throw new IllegalArgumentException("needURI and otherNeedURI are the same");
// Load need (throws exception if not found)
Need need = DataAccessUtils.loadNeed(needRepository, needURI);
if (!isNeedActive(need))
throw new IllegalMessageForNeedStateException(
needURI, connectionEventType.name(), need.getState());
URI facetURI = getFacet(content);
if (facetURI == null)
throw new IllegalArgumentException(
"at least one RDF node must be of type won:" + WON.HAS_FACET.getLocalName());
// TODO: create a proper exception if a facet is not supported by a need
if (facetRepository.findByNeedURIAndTypeURI(needURI, facetURI).isEmpty())
throw new RuntimeException("Facet is not supported by Need: " + facetURI);
List<Connection> connections =
connectionRepository.findByNeedURIAndRemoteNeedURI(needURI, otherNeedURI);
Connection con = getConnection(connections, facetURI, connectionEventType);
if (con == null) {
/* Create connection */
con = new Connection();
con.setNeedURI(needURI);
con.setState(connectionState);
con.setRemoteNeedURI(otherNeedURI);
con.setRemoteConnectionURI(otherConnectionURI);
con.setTypeURI(facetURI);
// save connection (this creates a new id)
con = connectionRepository.saveAndFlush(con);
// create and set new uri
con.setConnectionURI(URIService.createConnectionURI(con));
con = connectionRepository.saveAndFlush(con);
// TODO: do we save the connection content? where? as a chat content?
}
return con;
}
@RequestMapping(value = "/{needId}/toggle", method = RequestMethod.POST)
public String toggleNeed(@PathVariable String needId, Model model)
throws NoSuchConnectionFault, IllegalMessageForConnectionStateFault {
List<Need> needs = needRepository.findById(Long.valueOf(needId));
if (needs.isEmpty()) return "noNeedFound";
Need need = needs.get(0);
try {
if (need.getState() == NeedState.ACTIVE) {
ownerService.deactivate(need.getNeedURI(), null);
} else {
ownerService.activate(need.getNeedURI(), null);
}
} catch (NoSuchNeedException e) {
logger.warn("caught NoSuchNeedException:", e);
} catch (Exception e) {
logger.warn("caught Exception", e);
}
return "redirect:/need/" + need.getId().toString();
// return viewNeed(need.getId().toString(), model);
}
private boolean isNeedActive(final Need need) {
return NeedState.ACTIVE == need.getState();
}