1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.rest.service.command.v2;
35
36 import info.magnolia.commands.CommandsManager;
37 import info.magnolia.commands.chain.Command;
38 import info.magnolia.context.MgnlContext;
39 import info.magnolia.rest.service.command.AbstractCommandEndpoint;
40 import info.magnolia.rest.service.command.definition.CommandDefinition;
41 import info.magnolia.rest.service.command.definition.CommandEndpointDefinition;
42
43 import java.util.Collection;
44 import java.util.Collections;
45 import java.util.HashMap;
46 import java.util.Map;
47
48 import javax.inject.Inject;
49 import javax.jcr.RepositoryException;
50 import javax.ws.rs.Consumes;
51 import javax.ws.rs.POST;
52 import javax.ws.rs.Path;
53 import javax.ws.rs.PathParam;
54 import javax.ws.rs.Produces;
55 import javax.ws.rs.core.MediaType;
56 import javax.ws.rs.core.Response;
57
58 import org.apache.commons.lang.StringUtils;
59 import org.apache.commons.lang.exception.ExceptionUtils;
60 import org.slf4j.Logger;
61 import org.slf4j.LoggerFactory;
62
63 import com.wordnik.swagger.annotations.Api;
64 import com.wordnik.swagger.annotations.ApiOperation;
65 import com.wordnik.swagger.annotations.ApiResponse;
66 import com.wordnik.swagger.annotations.ApiResponses;
67
68
69
70
71
72
73
74
75 @Api(value = "/commands/v2", description = "The commands API v2")
76 @Path("/commands/v2")
77 public class CommandEndpoint extends AbstractCommandEndpoint<CommandEndpointDefinition> {
78
79 private final Logger log = LoggerFactory.getLogger(getClass());
80
81 @Inject
82 public CommandEndpoint(final CommandEndpointDefinition commandEndpointDefinition, final CommandsManager commandsManager) {
83 super(commandEndpointDefinition, commandsManager);
84 }
85
86 @POST
87 @Path("/{catalogName}/{commandName:(.)*}")
88 @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
89 @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
90 @ApiOperation(value = "Executes a command", notes = "Executes a command from a specific catalog")
91 @ApiResponses(value = {
92 @ApiResponse(code = 200, message = STATUS_MESSAGE_OK),
93 @ApiResponse(code = 403, message = STATUS_MESSAGE_FORBIDDEN),
94 @ApiResponse(code = 404, message = STATUS_MESSAGE_COMMAND_NOT_FOUND),
95 @ApiResponse(code = 500, message = STATUS_MESSAGE_ERROR_OCCURRED)
96 })
97 public Response executeCommand(
98 @PathParam("catalogName") String catalogName,
99 @PathParam("commandName") String commandName,
100 Map<String, Object> commandMap) throws RepositoryException {
101
102 if (!isCommandExecutableByCurrentUser(catalogName, commandName)) {
103 log.error("Unauthorized access while executing command '{}' from catalog '{}' with commandMap '{}'", commandName, catalogName, commandMap);
104 return Response.status(Response.Status.FORBIDDEN).build();
105 }
106
107 Command command = commandsManager.getCommand(catalogName, commandName);
108
109 if (command == null) {
110 return Response.status(Response.Status.NOT_FOUND).build();
111 }
112
113 Map<String, Object> resultMap = new HashMap<String, Object>();
114 Collection<String> contextParameters = getResponseContextParametersForCommand(catalogName, commandName);
115
116 try {
117 commandsManager.executeCommand(command, commandMap);
118 resultMap.put("success", true);
119 if (contextParameters != null && !contextParameters.isEmpty()) {
120 for (String key : contextParameters) {
121 resultMap.put(key, MgnlContext.getAttribute(key));
122 }
123 }
124 return Response.status(Response.Status.OK).entity(resultMap).build();
125 } catch (Exception e) {
126 log.error("Error executing command '{}' from catalog '{}' with commandMap '{}'", commandName, catalogName, commandMap, e);
127 resultMap.put("success", false);
128 resultMap.put("exceptionMessage", e.getMessage());
129 resultMap.put("stackTrace", ExceptionUtils.getStackTrace(e));
130 return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(resultMap).build();
131 }
132 }
133
134 @POST
135 @Path("/{commandName:(.)*}")
136 @Consumes({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
137 @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
138 @ApiOperation(value = "Executes a command", notes = "Executes a command from the default catalog")
139 @ApiResponses(value = {
140 @ApiResponse(code = 200, message = STATUS_MESSAGE_OK),
141 @ApiResponse(code = 403, message = STATUS_MESSAGE_FORBIDDEN),
142 @ApiResponse(code = 404, message = STATUS_MESSAGE_COMMAND_NOT_FOUND),
143 @ApiResponse(code = 500, message = STATUS_MESSAGE_ERROR_OCCURRED)
144 })
145 public Response executeCommand(@PathParam("commandName") String commandName, Map<String, Object> commandMap) throws RepositoryException {
146 return executeCommand(null, commandName, commandMap);
147 }
148
149
150
151
152 protected Collection<String> getResponseContextParametersForCommand(String catalogName, String commandName) {
153 if (commandName != null) {
154 for (CommandDefinition commandDefinition : getEndpointDefinition().getEnabledCommands()) {
155 if (StringUtils.equals(catalogName, commandDefinition.getCatalogName()) && StringUtils.equals(commandName, commandDefinition.getCommandName())) {
156 return commandDefinition.getResponseContextParameters();
157 }
158 }
159 }
160 return Collections.emptyList();
161 }
162 }