001
014
015 package com.liferay.portal.kernel.portlet;
016
017 import com.liferay.portal.kernel.log.Log;
018 import com.liferay.portal.kernel.log.LogFactoryUtil;
019 import com.liferay.portal.kernel.util.StringPool;
020 import com.liferay.portal.kernel.util.Validator;
021 import com.liferay.portal.model.PortletConstants;
022 import com.liferay.portal.util.PortalUtil;
023
024 import java.util.HashMap;
025 import java.util.LinkedHashMap;
026 import java.util.LinkedHashSet;
027 import java.util.Map;
028 import java.util.Set;
029
030 import javax.portlet.PortletMode;
031 import javax.portlet.WindowState;
032
033
050 public class DefaultFriendlyURLMapper extends BaseFriendlyURLMapper {
051
052 public DefaultFriendlyURLMapper() {
053 defaultIgnoredParameters = new LinkedHashSet<>();
054
055 defaultIgnoredParameters.add("p_p_id");
056 defaultIgnoredParameters.add("p_p_col_id");
057 defaultIgnoredParameters.add("p_p_col_pos");
058 defaultIgnoredParameters.add("p_p_col_count");
059
060 defaultReservedParameters = new LinkedHashMap<>();
061
062 defaultReservedParameters.put("p_p_lifecycle", "0");
063 defaultReservedParameters.put(
064 "p_p_state", WindowState.NORMAL.toString());
065 defaultReservedParameters.put("p_p_mode", PortletMode.VIEW.toString());
066 }
067
068
077 public void addDefaultIgnoredParameter(String name) {
078 defaultIgnoredParameters.add(name);
079 }
080
081
092 public void addDefaultReservedParameter(String name, String value) {
093 defaultReservedParameters.put(name, value);
094 }
095
096 @Override
097 public String buildPath(LiferayPortletURL liferayPortletURL) {
098 Map<String, String> routeParameters = new HashMap<>();
099
100 buildRouteParameters(liferayPortletURL, routeParameters);
101
102 String friendlyURLPath = router.parametersToUrl(routeParameters);
103
104 if (Validator.isNull(friendlyURLPath)) {
105 return null;
106 }
107
108 addParametersIncludedInPath(liferayPortletURL, routeParameters);
109
110 friendlyURLPath = StringPool.SLASH.concat(getMapping()).concat(
111 friendlyURLPath);
112
113 return friendlyURLPath;
114 }
115
116
122 public Set<String> getDefaultIgnoredParameters() {
123 return defaultIgnoredParameters;
124 }
125
126
132 public Map<String, String> getDefaultReservedParameters() {
133 return defaultReservedParameters;
134 }
135
136 @Override
137 public void populateParams(
138 String friendlyURLPath, Map<String, String[]> parameterMap,
139 Map<String, Object> requestContext) {
140
141 friendlyURLPath = friendlyURLPath.substring(getMapping().length() + 1);
142
143 if (friendlyURLPath.endsWith(StringPool.SLASH)) {
144 friendlyURLPath = friendlyURLPath.substring(
145 0, friendlyURLPath.length() - 1);
146 }
147
148 Map<String, String> routeParameters = new HashMap<>();
149
150 if (!router.urlToParameters(friendlyURLPath, routeParameters)) {
151 if (_log.isWarnEnabled()) {
152 _log.warn(
153 "No route could be found to match URL " + friendlyURLPath);
154 }
155
156 return;
157 }
158
159 String namespace = null;
160
161 String portletId = getPortletId(routeParameters);
162
163 if (Validator.isNotNull(portletId)) {
164 namespace = PortalUtil.getPortletNamespace(portletId);
165
166 addParameter(namespace, parameterMap, "p_p_id", portletId);
167 }
168 else if (isAllPublicRenderParameters(routeParameters)) {
169
170
171
172
173 addParameter(null, parameterMap, "p_p_id", getPortletId());
174 }
175 else {
176 return;
177 }
178
179 populateParams(parameterMap, namespace, routeParameters);
180 }
181
182
198 protected void addParametersIncludedInPath(
199 LiferayPortletURL liferayPortletURL,
200 Map<String, String> routeParameters) {
201
202
203
204 for (String name : defaultIgnoredParameters) {
205 liferayPortletURL.addParameterIncludedInPath(name);
206 }
207
208
209
210 Map<String, String[]> portletURLParameters =
211 liferayPortletURL.getParameterMap();
212
213 for (String name : portletURLParameters.keySet()) {
214 if (!routeParameters.containsKey(name)) {
215 liferayPortletURL.addParameterIncludedInPath(name);
216 }
217 }
218
219
220
221 Map<String, String> reservedParameters =
222 liferayPortletURL.getReservedParameterMap();
223
224 for (Map.Entry<String, String> entry : reservedParameters.entrySet()) {
225 String key = entry.getKey();
226 String value = entry.getValue();
227
228 if (!routeParameters.containsKey(key) ||
229 value.equals(defaultReservedParameters.get(key))) {
230
231 liferayPortletURL.addParameterIncludedInPath(key);
232 }
233 }
234 }
235
236
250 protected void buildRouteParameters(
251 LiferayPortletURL liferayPortletURL,
252 Map<String, String> routeParameters) {
253
254
255
256 Map<String, String[]> portletURLParameters =
257 liferayPortletURL.getParameterMap();
258
259 for (Map.Entry<String, String[]> entry :
260 portletURLParameters.entrySet()) {
261
262 String[] values = entry.getValue();
263
264 if (values.length > 0) {
265 routeParameters.put(entry.getKey(), values[0]);
266 }
267 }
268
269
270
271 if (isPortletInstanceable()) {
272 String portletId = liferayPortletURL.getPortletId();
273
274 routeParameters.put("p_p_id", portletId);
275
276 if (Validator.isNotNull(portletId) &&
277 PortletConstants.hasInstanceId(portletId)) {
278
279 routeParameters.put(
280 "instanceId", PortletConstants.getInstanceId(portletId));
281 }
282 }
283
284
285
286 routeParameters.putAll(liferayPortletURL.getReservedParameterMap());
287 }
288
289
299 protected String getPortletId(Map<String, String> routeParameters) {
300 if (!isPortletInstanceable()) {
301 return getPortletId();
302 }
303
304 String portletId = routeParameters.remove("p_p_id");
305
306 if (Validator.isNotNull(portletId)) {
307 return portletId;
308 }
309
310 String instanceId = routeParameters.remove("instanceId");
311
312 if (Validator.isNotNull(instanceId)) {
313 return PortletConstants.assemblePortletId(
314 getPortletId(), instanceId);
315 }
316
317 if (!isAllPublicRenderParameters(routeParameters)) {
318 _log.error(
319 "Either p_p_id or instanceId must be provided for an " +
320 "instanceable portlet");
321 }
322
323 return null;
324 }
325
326
334 protected boolean isAllPublicRenderParameters(
335 Map<String, String> routeParameters) {
336
337 Set<String> routeParameterKeys = routeParameters.keySet();
338
339 Map<String, String> publicRenderParameters =
340 FriendlyURLMapperThreadLocal.getPRPIdentifiers();
341
342 return routeParameterKeys.containsAll(publicRenderParameters.keySet());
343 }
344
345
356 protected void populateParams(
357 Map<String, String[]> parameterMap, String namespace,
358 Map<String, String> routeParameters) {
359
360
361
362 for (Map.Entry<String, String> entry : routeParameters.entrySet()) {
363 addParameter(
364 namespace, parameterMap, entry.getKey(), entry.getValue());
365 }
366
367
368
369 for (Map.Entry<String, String> entry :
370 defaultReservedParameters.entrySet()) {
371
372 String key = entry.getKey();
373
374 if (!parameterMap.containsKey(key)) {
375 addParameter(namespace, parameterMap, key, entry.getValue());
376 }
377 }
378 }
379
380 protected Set<String> defaultIgnoredParameters;
381 protected Map<String, String> defaultReservedParameters;
382
383 private static final Log _log = LogFactoryUtil.getLog(
384 DefaultFriendlyURLMapper.class);
385
386 }