1   /**
2    * Copyright (c) 2000-2007 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.model.impl;
24  
25  import com.germinus.easyconf.Filter;
26  
27  import com.liferay.portal.SystemException;
28  import com.liferay.portal.kernel.portlet.PortletLayoutListener;
29  import com.liferay.portal.kernel.util.ArrayUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.StringPool;
32  import com.liferay.portal.kernel.util.StringUtil;
33  import com.liferay.portal.kernel.util.Validator;
34  import com.liferay.portal.model.Group;
35  import com.liferay.portal.model.Layout;
36  import com.liferay.portal.model.LayoutTemplate;
37  import com.liferay.portal.model.LayoutTypePortlet;
38  import com.liferay.portal.model.Portlet;
39  import com.liferay.portal.service.PluginSettingLocalServiceUtil;
40  import com.liferay.portal.service.PortletLocalServiceUtil;
41  import com.liferay.portal.service.impl.LayoutTemplateLocalUtil;
42  import com.liferay.portal.util.PropsUtil;
43  import com.liferay.util.ListUtil;
44  import com.liferay.util.PwdGenerator;
45  
46  import java.util.ArrayList;
47  import java.util.Iterator;
48  import java.util.List;
49  
50  import org.apache.commons.lang.StringUtils;
51  import org.apache.commons.logging.Log;
52  import org.apache.commons.logging.LogFactory;
53  
54  /**
55   * <a href="LayoutTypePortletImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class LayoutTypePortletImpl
61      extends LayoutTypeImpl implements LayoutTypePortlet {
62  
63      public static final String LAYOUT_TEMPLATE_ID = "layout-template-id";
64  
65      public static final String NESTED_LAYOUT_TEMPLATE_IDS =
66          "nested-layout-template-ids";
67  
68      public static final String NESTED_LAYOUT_TEMPLATE_SEPARATOR =
69          "_NESTED_LAYOUT_TEMPLATE_";
70  
71      public static final String STATE_MAX = "state-max";
72  
73      public static final String STATE_MAX_PREVIOUS = "state-max-previous";
74  
75      public static final String STATE_MIN = "state-min";
76  
77      public static final String MODE_ABOUT = "mode-about";
78  
79      public static final String MODE_CONFIG = "mode-config";
80  
81      public static final String MODE_EDIT = "mode-edit";
82  
83      public static final String MODE_EDIT_DEFAULTS = "mode-edit-defaults";
84  
85      public static final String MODE_EDIT_GUEST = "mode-edit-guest";
86  
87      public static final String MODE_HELP = "mode-help";
88  
89      public static final String MODE_PREVIEW = "mode-preview";
90  
91      public static final String MODE_PRINT = "mode-print";
92  
93      public static String getFullInstanceSeparator() {
94          String instanceId = PwdGenerator.getPassword(
95              PwdGenerator.KEY1 + PwdGenerator.KEY2 + PwdGenerator.KEY3, 4);
96  
97          return PortletImpl.INSTANCE_SEPARATOR + instanceId;
98      }
99  
100     public LayoutTypePortletImpl(LayoutImpl layout) {
101         super(layout);
102     }
103 
104     public LayoutTemplate getLayoutTemplate() {
105         LayoutTemplate layoutTemplate =
106             LayoutTemplateLocalUtil.getLayoutTemplate(
107                 getLayoutTemplateId(), false, null);
108 
109         if (layoutTemplate == null) {
110             layoutTemplate = new LayoutTemplateImpl(
111                 StringPool.BLANK, StringPool.BLANK);
112 
113             List columns = new ArrayList();
114 
115             for (int i = 1; i <= 10; i++) {
116                 columns.add("column-" + i);
117             }
118 
119             layoutTemplate.setColumns(columns);
120         }
121 
122         return layoutTemplate;
123     }
124 
125     public String getLayoutTemplateId() {
126         String layoutTemplateId =
127             getTypeSettingsProperties().getProperty(LAYOUT_TEMPLATE_ID);
128 
129         if (Validator.isNull(layoutTemplateId)) {
130             layoutTemplateId = "2_columns_ii";
131 
132             getTypeSettingsProperties().setProperty(
133                 LAYOUT_TEMPLATE_ID, layoutTemplateId);
134 
135             _log.warn(
136                 "Layout template id for layout " + getLayout().getPrimaryKey() +
137                     " is null, setting it to 2_columns_ii");
138         }
139 
140         return layoutTemplateId;
141     }
142 
143     public void setLayoutTemplateId(long userId, String newLayoutTemplateId) {
144         setLayoutTemplateId(userId, newLayoutTemplateId, true);
145     }
146 
147     public void setLayoutTemplateId(
148         long userId, String newLayoutTemplateId, boolean checkPermission) {
149 
150         if (checkPermission &&
151             !PluginSettingLocalServiceUtil.hasPermission(
152                 userId, newLayoutTemplateId, LayoutTemplateImpl.PLUGIN_TYPE)) {
153 
154             return;
155         }
156 
157         String oldLayoutTemplateId = getLayoutTemplateId();
158 
159         getTypeSettingsProperties().setProperty(
160             LAYOUT_TEMPLATE_ID, newLayoutTemplateId);
161 
162         if (Validator.isNull(oldLayoutTemplateId)) {
163             return;
164         }
165 
166         String themeId = null;
167 
168         try {
169             themeId = getLayout().getTheme().getThemeId();
170         }
171         catch (Exception e) {
172             _log.error(e);
173         }
174 
175         LayoutTemplate oldLayoutTemplate =
176             LayoutTemplateLocalUtil.getLayoutTemplate(
177                 oldLayoutTemplateId, false, themeId);
178 
179         if (oldLayoutTemplate == null) {
180             return;
181         }
182 
183         LayoutTemplate newLayoutTemplate =
184             LayoutTemplateLocalUtil.getLayoutTemplate(
185                 newLayoutTemplateId, false, themeId);
186 
187         List oldColumns = oldLayoutTemplate.getColumns();
188         List newColumns = newLayoutTemplate.getColumns();
189 
190         if (newColumns.size() < oldColumns.size()) {
191             String lastNewColumnId =
192                 (String)newColumns.get(newColumns.size() - 1);
193             String lastNewColumnValue =
194                 getTypeSettingsProperties().getProperty(lastNewColumnId);
195 
196             for (int i = newColumns.size() - 1; i < oldColumns.size(); i++) {
197                 String oldColumnId = (String)oldColumns.get(i);
198                 String oldColumnValue =
199                     (String)getTypeSettingsProperties().remove(oldColumnId);
200 
201                 String[] portletIds = StringUtil.split(oldColumnValue);
202 
203                 for (int j = 0; j < portletIds.length; j++) {
204                     lastNewColumnValue =
205                         StringUtil.add(lastNewColumnValue, portletIds[j]);
206                 }
207             }
208 
209             getTypeSettingsProperties().setProperty(
210                 lastNewColumnId, lastNewColumnValue);
211         }
212     }
213 
214     public void addNestedLayoutTemplate(
215         LayoutTemplate template, String containerId) {
216 
217         String nestedLayoutTemplateIds = GetterUtil.getString(
218             getTypeSettingsProperties().getProperty(
219                 NESTED_LAYOUT_TEMPLATE_IDS));
220 
221         if (nestedLayoutTemplateIds.indexOf(
222                 containerId + NESTED_LAYOUT_TEMPLATE_SEPARATOR +
223                     template.getLayoutTemplateId()) == -1) {
224 
225             if (nestedLayoutTemplateIds.indexOf(
226                     containerId + NESTED_LAYOUT_TEMPLATE_SEPARATOR) > -1) {
227 
228                 // This must be an old instance
229 
230                 nestedLayoutTemplateIds = StringUtils.replace(
231                     nestedLayoutTemplateIds,
232                     containerId + NESTED_LAYOUT_TEMPLATE_SEPARATOR + ".*?,",
233                     ",");
234             }
235 
236             nestedLayoutTemplateIds +=
237                 containerId + NESTED_LAYOUT_TEMPLATE_SEPARATOR +
238                     template.getLayoutTemplateId();
239 
240             getTypeSettingsProperties().setProperty(
241                 NESTED_LAYOUT_TEMPLATE_IDS, nestedLayoutTemplateIds);
242         }
243     }
244 
245     public int getNumOfColumns() {
246         return getLayoutTemplate().getColumns().size();
247     }
248 
249     public List getAllPortlets(String columnId) throws SystemException {
250         String columnValue =
251             getTypeSettingsProperties().getProperty(columnId);
252 
253         String[] portletIds = StringUtil.split(columnValue);
254 
255         List portlets = new ArrayList(portletIds.length);
256 
257         for (int i = 0; i < portletIds.length; i++) {
258             Portlet portlet = PortletLocalServiceUtil.getPortletById(
259                 getLayout().getCompanyId(), portletIds[i]);
260 
261             if (portlet != null) {
262                 portlets.add(portlet);
263             }
264         }
265 
266         List startPortlets = getStaticPortlets(
267             PropsUtil.LAYOUT_STATIC_PORTLETS_START + columnId);
268 
269         List endPortlets = getStaticPortlets(
270             PropsUtil.LAYOUT_STATIC_PORTLETS_END + columnId);
271 
272         return addStaticPortlets(portlets, startPortlets, endPortlets);
273     }
274 
275     public List addStaticPortlets(
276             List portlets, List startPortlets, List endPortlets)
277         throws SystemException {
278 
279         // Return the original array of portlets if no static portlets are
280         // specified
281 
282         if (startPortlets == null) {
283             startPortlets = new ArrayList();
284         }
285 
286         if (endPortlets == null) {
287             endPortlets = new ArrayList();
288         }
289 
290         if ((startPortlets.isEmpty()) && (endPortlets.isEmpty())) {
291             return portlets;
292         }
293 
294         // New array of portlets that contain the static portlets
295 
296         List list = new ArrayList(
297             portlets.size() + startPortlets.size() + endPortlets.size());
298 
299         if (startPortlets != null) {
300             list.addAll(startPortlets);
301         }
302 
303         for (int i = 0; i < portlets.size(); i++) {
304             Portlet portlet = (Portlet)portlets.get(i);
305 
306             // Add the portlet if and only if it is not also a static portlet
307 
308             if (!startPortlets.contains(portlet) &&
309                 !endPortlets.contains(portlet)) {
310 
311                 list.add(portlet);
312             }
313         }
314 
315         if (endPortlets != null) {
316             list.addAll(endPortlets);
317         }
318 
319         return list;
320     }
321 
322     // Modify portlets
323 
324     public String addPortletId(long userId, String portletId) {
325         return addPortletId(userId, portletId, true);
326     }
327 
328     public String addPortletId(
329         long userId, String portletId, boolean checkPermission) {
330 
331         return addPortletId(userId, portletId, null, -1, checkPermission);
332     }
333 
334     public String addPortletId(
335         long userId, String portletId, String columnId, int columnPos) {
336 
337         return addPortletId(userId, portletId, columnId, columnPos, true);
338     }
339 
340     public String addPortletId(
341         long userId, String portletId, String columnId, int columnPos,
342         boolean checkPermission) {
343 
344         Layout layout = getLayout();
345 
346         Portlet portlet = null;
347 
348         try {
349             portlet = PortletLocalServiceUtil.getPortletById(
350                 layout.getCompanyId(), portletId);
351 
352             if (checkPermission && !portlet.hasAddPortletPermission(userId)) {
353                 return null;
354             }
355         }
356         catch (Exception e) {
357             _log.error(e);
358         }
359 
360         if (portlet != null) {
361             if (portlet.isSystem()) {
362                 return null;
363             }
364 
365             if ((portlet.isInstanceable()) &&
366                 (PortletImpl.getInstanceId(portlet.getPortletId()) == null)) {
367 
368                 portletId = portletId + getFullInstanceSeparator();
369             }
370 
371             if (hasPortletId(portletId)) {
372                 return null;
373             }
374 
375             if (columnId == null) {
376                 LayoutTemplate layoutTemplate = getLayoutTemplate();
377 
378                 List columns = layoutTemplate.getColumns();
379 
380                 if (columns.size() > 0) {
381                     columnId = (String)columns.get(0);
382                 }
383             }
384 
385             if (columnId != null) {
386                 String columnValue =
387                     getTypeSettingsProperties().getProperty(columnId);
388 
389                 if (columnPos >= 0) {
390                     List portletIds =
391                         ListUtil.fromArray(StringUtil.split(columnValue));
392 
393                     if (columnPos <= portletIds.size()) {
394                         portletIds.add(columnPos, portletId);
395                     }
396                     else {
397                         portletIds.add(portletId);
398                     }
399 
400                     columnValue = StringUtil.merge(portletIds);
401                 }
402                 else {
403                     columnValue = StringUtil.add(columnValue, portletId);
404                 }
405 
406                 getTypeSettingsProperties().setProperty(columnId, columnValue);
407             }
408 
409             try {
410                 PortletLayoutListener portletLayoutListener =
411                     (PortletLayoutListener)portlet.getPortletLayoutListener();
412 
413                 if (_enablePortletLayoutListener &&
414                     (portletLayoutListener != null)) {
415 
416                     portletLayoutListener.onAddToLayout(
417                         portletId, layout.getPlid());
418                 }
419             }
420             catch (Exception e) {
421                 _log.error("Unable to fire portlet layout listener event", e);
422             }
423 
424             return portletId;
425         }
426         else {
427             return null;
428         }
429     }
430 
431     public void addPortletIds(
432         long userId, String[] portletIds, boolean checkPermission) {
433 
434         for (int i = 0; i < portletIds.length; i++) {
435             String portletId = portletIds[i];
436 
437             addPortletId(userId, portletId, checkPermission);
438         }
439     }
440 
441     public void addPortletIds(
442         long userId, String[] portletIds, String columnId,
443         boolean checkPermission) {
444 
445         for (int i = 0; i < portletIds.length; i++) {
446             String portletId = portletIds[i];
447 
448             addPortletId(userId, portletId, columnId, -1, checkPermission);
449         }
450     }
451 
452     public List getPortlets() throws SystemException {
453         List portletIds = getPortletIds();
454 
455         List portlets = new ArrayList(portletIds.size());
456 
457         for (int i = 0; i < portletIds.size(); i++) {
458             String portletId = (String)portletIds.get(i);
459 
460             Portlet portlet = PortletLocalServiceUtil.getPortletById(
461                 getLayout().getCompanyId(), portletId);
462 
463             if (portlet != null) {
464                 portlets.add(portlet);
465             }
466         }
467 
468         return portlets;
469     }
470 
471     public List getPortletIds() {
472         List portletIds = new ArrayList();
473 
474         List columns = getColumns();
475 
476         for (int i = 0; i < columns.size(); i++) {
477             String columnId = (String)columns.get(i);
478 
479             String columnValue =
480                 getTypeSettingsProperties().getProperty(columnId);
481 
482             portletIds.addAll(
483                 ListUtil.fromArray(StringUtil.split(columnValue)));
484 
485         }
486 
487         return portletIds;
488     }
489 
490     public boolean hasPortletId(String portletId) {
491         List columns = getColumns();
492 
493         for (int i = 0; i < columns.size(); i++) {
494             String columnId = (String)columns.get(i);
495 
496             if (hasNonstaticPortletId(columnId, portletId)) {
497                 return true;
498             }
499 
500             if (hasStaticPortletId(columnId, portletId)) {
501                 return true;
502             }
503         }
504 
505         return false;
506     }
507 
508     public void movePortletId(
509         long userId, String portletId, String columnId, int columnPos) {
510 
511         _enablePortletLayoutListener = false;
512 
513         try {
514             removePortletId(portletId, false);
515             addPortletId(userId, portletId, columnId, columnPos);
516         }
517         finally {
518             _enablePortletLayoutListener = true;
519         }
520 
521         Layout layout = getLayout();
522 
523         try {
524             Portlet portlet = PortletLocalServiceUtil.getPortletById(
525                 layout.getCompanyId(), portletId);
526 
527             if (portlet != null) {
528                 PortletLayoutListener portletLayoutListener =
529                     (PortletLayoutListener)portlet.getPortletLayoutListener();
530 
531                 if (portletLayoutListener != null) {
532                     portletLayoutListener.onMoveInLayout(
533                         portletId, layout.getPlid());
534                 }
535             }
536         }
537         catch (Exception e) {
538             _log.error("Unable to fire portlet layout listener event", e);
539         }
540     }
541 
542     public void removePortletId(String portletId) {
543         removePortletId(portletId, true);
544     }
545 
546     public void removePortletId(String portletId, boolean modeAndState) {
547         List columns = getColumns();
548 
549         String nestedLayoutTemplateIds = GetterUtil.getString(
550             getTypeSettingsProperties().getProperty(
551                 NESTED_LAYOUT_TEMPLATE_IDS));
552 
553         boolean nestedPortletId = nestedLayoutTemplateIds.indexOf(
554             portletId + NESTED_LAYOUT_TEMPLATE_SEPARATOR) > -1;
555 
556         if (nestedPortletId) {
557             nestedLayoutTemplateIds = StringUtils.replace(
558                 nestedLayoutTemplateIds,
559                 portletId + NESTED_LAYOUT_TEMPLATE_SEPARATOR + ".*?", "");
560 
561             nestedLayoutTemplateIds = StringUtils.replace(
562                 nestedLayoutTemplateIds, ",,", ",");
563 
564             getTypeSettingsProperties().setProperty(
565                 NESTED_LAYOUT_TEMPLATE_IDS, nestedLayoutTemplateIds);
566         }
567 
568         for (int i = 0; i < columns.size(); i++) {
569             String columnId = (String)columns.get(i);
570 
571             if (nestedPortletId && columnId.startsWith(portletId)) {
572                 getTypeSettingsProperties().remove(columnId);
573 
574                 continue;
575             }
576 
577             String columnValue =
578                 getTypeSettingsProperties().getProperty(columnId);
579 
580             columnValue = StringUtil.remove(columnValue, portletId);
581 
582             getTypeSettingsProperties().setProperty(columnId, columnValue);
583         }
584 
585         if (modeAndState) {
586             removeStatesPortletId(portletId);
587             removeModesPortletId(portletId);
588         }
589 
590         Layout layout = getLayout();
591 
592         try {
593             Portlet portlet = PortletLocalServiceUtil.getPortletById(
594                 layout.getCompanyId(), portletId);
595 
596             if (portlet != null) {
597                 PortletLayoutListener portletLayoutListener =
598                     (PortletLayoutListener)portlet.getPortletLayoutListener();
599 
600                 if (_enablePortletLayoutListener &&
601                     (portletLayoutListener != null)) {
602 
603                     portletLayoutListener.onRemoveFromLayout(
604                         portletId, layout.getPlid());
605                 }
606             }
607         }
608         catch (Exception e) {
609             _log.error("Unable to fire portlet layout listener event", e);
610         }
611     }
612 
613     public void setPortletIds(String columnId, String portletIds) {
614         getTypeSettingsProperties().setProperty(columnId, portletIds);
615     }
616 
617     // Maximized state
618 
619     public String getStateMax() {
620         return getTypeSettingsProperties().getProperty(STATE_MAX);
621     }
622 
623     public void setStateMax(String stateMax) {
624         getTypeSettingsProperties().setProperty(STATE_MAX, stateMax);
625     }
626 
627     public boolean hasStateMax() {
628         String[] stateMax = StringUtil.split(getStateMax());
629 
630         if (stateMax.length > 0) {
631             return true;
632         }
633         else {
634             return false;
635         }
636     }
637 
638     public void addStateMaxPortletId(String portletId) {
639         removeStatesPortletId(portletId);
640         //setStateMax(StringUtil.add(getStateMax(), portletId));
641         setStateMax(StringUtil.add(StringPool.BLANK, portletId));
642     }
643 
644     public String getStateMaxPortletId() {
645         String[] stateMax = StringUtil.split(getStateMax());
646 
647         if (stateMax.length > 0) {
648             return stateMax[0];
649         }
650         else {
651             return StringPool.BLANK;
652         }
653     }
654 
655     public boolean hasStateMaxPortletId(String portletId) {
656         if (StringUtil.contains(getStateMax(), portletId)) {
657             return true;
658         }
659         else {
660             return false;
661         }
662     }
663 
664     public void removeStateMaxPortletId(String portletId) {
665         setStateMax(StringUtil.remove(getStateMax(), portletId));
666     }
667 
668     // Maximized state previous
669 
670     public String getStateMaxPrevious() {
671         return getTypeSettingsProperties().getProperty(STATE_MAX_PREVIOUS);
672     }
673 
674     public void setStateMaxPrevious(String stateMaxPrevious) {
675         getTypeSettingsProperties().setProperty(
676             STATE_MAX_PREVIOUS, stateMaxPrevious);
677     }
678 
679     public void removeStateMaxPrevious() {
680         getTypeSettingsProperties().remove(STATE_MAX_PREVIOUS);
681     }
682 
683     // Minimized state
684 
685     public String getStateMin() {
686         return getTypeSettingsProperties().getProperty(STATE_MIN);
687     }
688 
689     public void setStateMin(String stateMin) {
690         getTypeSettingsProperties().setProperty(STATE_MIN, stateMin);
691     }
692 
693     public boolean hasStateMin() {
694         String[] stateMin = StringUtil.split(getStateMin());
695 
696         if (stateMin.length > 0) {
697             return true;
698         }
699         else {
700             return false;
701         }
702     }
703 
704     public void addStateMinPortletId(String portletId) {
705         removeStateMaxPortletId(portletId);
706         setStateMin(StringUtil.add(getStateMin(), portletId));
707     }
708 
709     public boolean hasStateMinPortletId(String portletId) {
710         if (StringUtil.contains(getStateMin(), portletId)) {
711             return true;
712         }
713         else {
714             return false;
715         }
716     }
717 
718     public void removeStateMinPortletId(String portletId) {
719         setStateMin(StringUtil.remove(getStateMin(), portletId));
720     }
721 
722     // Normal state
723 
724     public boolean hasStateNormalPortletId(String portletId) {
725         if (hasStateMaxPortletId(portletId) ||
726             hasStateMinPortletId(portletId)) {
727 
728             return false;
729         }
730         else {
731             return true;
732         }
733     }
734 
735     // All states
736 
737     public void resetStates() {
738         setStateMax(StringPool.BLANK);
739         setStateMin(StringPool.BLANK);
740     }
741 
742     public void removeStatesPortletId(String portletId) {
743         removeStateMaxPortletId(portletId);
744         removeStateMinPortletId(portletId);
745     }
746 
747     // About mode
748 
749     public String getModeAbout() {
750         return getTypeSettingsProperties().getProperty(MODE_ABOUT);
751     }
752 
753     public void setModeAbout(String modeAbout) {
754         getTypeSettingsProperties().setProperty(MODE_ABOUT, modeAbout);
755     }
756 
757     public void addModeAboutPortletId(String portletId) {
758         removeModesPortletId(portletId);
759         setModeAbout(StringUtil.add(getModeAbout(), portletId));
760     }
761 
762     public boolean hasModeAboutPortletId(String portletId) {
763         return StringUtil.contains(getModeAbout(), portletId);
764     }
765 
766     public void removeModeAboutPortletId(String portletId) {
767         setModeAbout(StringUtil.remove(getModeAbout(), portletId));
768     }
769 
770     // Config mode
771 
772     public String getModeConfig() {
773         return getTypeSettingsProperties().getProperty(MODE_CONFIG);
774     }
775 
776     public void setModeConfig(String modeConfig) {
777         getTypeSettingsProperties().setProperty(MODE_CONFIG, modeConfig);
778     }
779 
780     public void addModeConfigPortletId(String portletId) {
781         removeModesPortletId(portletId);
782         setModeConfig(StringUtil.add(getModeConfig(), portletId));
783     }
784 
785     public boolean hasModeConfigPortletId(String portletId) {
786         return StringUtil.contains(getModeConfig(), portletId);
787     }
788 
789     public void removeModeConfigPortletId(String portletId) {
790         setModeConfig(StringUtil.remove(getModeConfig(), portletId));
791     }
792 
793     // Edit mode
794 
795     public String getModeEdit() {
796         return getTypeSettingsProperties().getProperty(MODE_EDIT);
797     }
798 
799     public void setModeEdit(String modeEdit) {
800         getTypeSettingsProperties().setProperty(MODE_EDIT, modeEdit);
801     }
802 
803     public void addModeEditPortletId(String portletId) {
804         removeModesPortletId(portletId);
805         setModeEdit(StringUtil.add(getModeEdit(), portletId));
806     }
807 
808     public boolean hasModeEditPortletId(String portletId) {
809         return StringUtil.contains(getModeEdit(), portletId);
810     }
811 
812     public void removeModeEditPortletId(String portletId) {
813         setModeEdit(StringUtil.remove(getModeEdit(), portletId));
814     }
815 
816     // Edit defaults mode
817 
818     public String getModeEditDefaults() {
819         return getTypeSettingsProperties().getProperty(MODE_EDIT_DEFAULTS);
820     }
821 
822     public void setModeEditDefaults(String modeEditDefaults) {
823         getTypeSettingsProperties().setProperty(
824             MODE_EDIT_DEFAULTS, modeEditDefaults);
825     }
826 
827     public void addModeEditDefaultsPortletId(String portletId) {
828         removeModesPortletId(portletId);
829         setModeEditDefaults(StringUtil.add(getModeEditDefaults(), portletId));
830     }
831 
832     public boolean hasModeEditDefaultsPortletId(String portletId) {
833         return StringUtil.contains(getModeEditDefaults(), portletId);
834     }
835 
836     public void removeModeEditDefaultsPortletId(String portletId) {
837         setModeEditDefaults(
838             StringUtil.remove(getModeEditDefaults(), portletId));
839     }
840 
841     // Edit guest mode
842 
843     public String getModeEditGuest() {
844         return getTypeSettingsProperties().getProperty(MODE_EDIT_GUEST);
845     }
846 
847     public void setModeEditGuest(String modeEditGuest) {
848         getTypeSettingsProperties().setProperty(MODE_EDIT_GUEST, modeEditGuest);
849     }
850 
851     public void addModeEditGuestPortletId(String portletId) {
852         removeModesPortletId(portletId);
853         setModeEditGuest(StringUtil.add(getModeEditGuest(), portletId));
854     }
855 
856     public boolean hasModeEditGuestPortletId(String portletId) {
857         return StringUtil.contains(getModeEditGuest(), portletId);
858     }
859 
860     public void removeModeEditGuestPortletId(String portletId) {
861         setModeEditGuest(StringUtil.remove(getModeEditGuest(), portletId));
862     }
863 
864     // Help mode
865 
866     public String getModeHelp() {
867         return getTypeSettingsProperties().getProperty(MODE_HELP);
868     }
869 
870     public void setModeHelp(String modeHelp) {
871         getTypeSettingsProperties().setProperty(MODE_HELP, modeHelp);
872     }
873 
874     public void addModeHelpPortletId(String portletId) {
875         removeModesPortletId(portletId);
876         setModeHelp(StringUtil.add(getModeHelp(), portletId));
877     }
878 
879     public boolean hasModeHelpPortletId(String portletId) {
880         return StringUtil.contains(getModeHelp(), portletId);
881     }
882 
883     public void removeModeHelpPortletId(String portletId) {
884         setModeHelp(StringUtil.remove(getModeHelp(), portletId));
885     }
886 
887     // Preview mode
888 
889     public String getModePreview() {
890         return getTypeSettingsProperties().getProperty(MODE_PREVIEW);
891     }
892 
893     public void setModePreview(String modePreview) {
894         getTypeSettingsProperties().setProperty(MODE_PREVIEW, modePreview);
895     }
896 
897     public void addModePreviewPortletId(String portletId) {
898         removeModesPortletId(portletId);
899         setModePreview(StringUtil.add(getModePreview(), portletId));
900     }
901 
902     public boolean hasModePreviewPortletId(String portletId) {
903         return StringUtil.contains(getModePreview(), portletId);
904     }
905 
906     public void removeModePreviewPortletId(String portletId) {
907         setModePreview(StringUtil.remove(getModePreview(), portletId));
908     }
909 
910     // Print mode
911 
912     public String getModePrint() {
913         return getTypeSettingsProperties().getProperty(MODE_PRINT);
914     }
915 
916     public void setModePrint(String modePrint) {
917         getTypeSettingsProperties().setProperty(MODE_PRINT, modePrint);
918     }
919 
920     public void addModePrintPortletId(String portletId) {
921         removeModesPortletId(portletId);
922         setModePrint(StringUtil.add(getModePrint(), portletId));
923     }
924 
925     public boolean hasModePrintPortletId(String portletId) {
926         return StringUtil.contains(getModePrint(), portletId);
927     }
928 
929     public void removeModePrintPortletId(String portletId) {
930         setModePrint(StringUtil.remove(getModePrint(), portletId));
931     }
932 
933     // View mode
934 
935     public boolean hasModeViewPortletId(String portletId) {
936         if (hasModeAboutPortletId(portletId) ||
937             hasModeConfigPortletId(portletId) ||
938             hasModeEditPortletId(portletId) ||
939             hasModeEditDefaultsPortletId(portletId) ||
940             hasModeEditGuestPortletId(portletId) ||
941             hasModeHelpPortletId(portletId) ||
942             hasModePreviewPortletId(portletId) ||
943             hasModePrintPortletId(portletId)) {
944 
945             return false;
946         }
947         else {
948             return true;
949         }
950     }
951 
952     // All modes
953 
954     public void resetModes() {
955         setModeAbout(StringPool.BLANK);
956         setModeConfig(StringPool.BLANK);
957         setModeEdit(StringPool.BLANK);
958         setModeEditDefaults(StringPool.BLANK);
959         setModeEditGuest(StringPool.BLANK);
960         setModeHelp(StringPool.BLANK);
961         setModePreview(StringPool.BLANK);
962         setModePrint(StringPool.BLANK);
963     }
964 
965     public void removeModesPortletId(String portletId) {
966         removeModeAboutPortletId(portletId);
967         removeModeConfigPortletId(portletId);
968         removeModeEditPortletId(portletId);
969         removeModeEditDefaultsPortletId(portletId);
970         removeModeEditGuestPortletId(portletId);
971         removeModeHelpPortletId(portletId);
972         removeModePreviewPortletId(portletId);
973         removeModePrintPortletId(portletId);
974     }
975 
976     // Protected methods
977 
978     protected List getColumns() {
979         LayoutTemplate layoutTemplate = getLayoutTemplate();
980 
981         List columns = layoutTemplate.getColumns();
982 
983         columns.addAll(getNestedColumns());
984 
985         return columns;
986     }
987 
988     protected List getNestedColumns() {
989         List nestedColumns = new ArrayList();
990 
991         String nestedLayoutTemplateIds =
992             getTypeSettingsProperties().getProperty(
993                 NESTED_LAYOUT_TEMPLATE_IDS);
994 
995         if (Validator.isNull(nestedLayoutTemplateIds)) {
996             return nestedColumns;
997         }
998 
999         String[] nestedLayoutTemplateIdsArray = StringUtil.split(
1000            nestedLayoutTemplateIds);
1001
1002        for (int i = 0; i < nestedLayoutTemplateIdsArray.length; i++) {
1003            String[] kvp = StringUtil.split(
1004                nestedLayoutTemplateIdsArray[i],
1005                NESTED_LAYOUT_TEMPLATE_SEPARATOR);
1006
1007            String containerId = kvp[0];
1008            String layoutTemplateId = kvp[1];
1009
1010            LayoutTemplate layoutTemplate =
1011                LayoutTemplateLocalUtil.getLayoutTemplate(
1012                    layoutTemplateId, false, null);
1013
1014            Iterator itr = layoutTemplate.getColumns().iterator();
1015
1016            while (itr.hasNext()) {
1017                String columnId = (String)itr.next();
1018
1019                nestedColumns.add(containerId + "_" + columnId);
1020            }
1021        }
1022
1023        return nestedColumns;
1024    }
1025
1026    protected String[] getStaticPortletIds(String position) {
1027        Layout layout = getLayout();
1028
1029        String selector1 = StringPool.BLANK;
1030
1031        Group group = layout.getGroup();
1032
1033        if (group.isUser()) {
1034            selector1 = "user";
1035        }
1036        else if (group.isCommunity()) {
1037            selector1 = "community";
1038        }
1039        else if (group.isOrganization()) {
1040            selector1 = "organization";
1041        }
1042
1043        String selector2 = StringPool.BLANK;
1044
1045        if (layout.isFirstParent()) {
1046            selector2 = "firstLayout";
1047        }
1048
1049        return PropsUtil.getComponentProperties().getStringArray(
1050            position, Filter.by(selector1, selector2));
1051    }
1052
1053    protected List getStaticPortlets(String position) throws SystemException {
1054        String[] portletIds = getStaticPortletIds(position);
1055
1056        List portlets = new ArrayList();
1057
1058        for (int i = 0; i < portletIds.length; i++) {
1059            String portletId = portletIds[i];
1060
1061            if (hasNonstaticPortletId(portletId)) {
1062                continue;
1063            }
1064
1065            Portlet portlet = PortletLocalServiceUtil.getPortletById(
1066                getLayout().getCompanyId(), portletId);
1067
1068            if (portlet != null) {
1069                Portlet staticPortlet = portlet;
1070
1071                if (portlet.isInstanceable()) {
1072
1073                    // Instanceable portlets do not need to be cloned because
1074                    // they are already cloned. See the method getPortletById in
1075                    // the class PortletLocalServiceImpl and how it references
1076                    // the method getClonedInstance in the class PortletImpl.
1077
1078                }
1079                else {
1080                    staticPortlet = (Portlet)staticPortlet.clone();
1081                }
1082
1083                staticPortlet.setStatic(true);
1084
1085                if (position.startsWith("layout.static.portlets.start")) {
1086                    staticPortlet.setStaticStart(true);
1087                }
1088
1089                portlets.add(staticPortlet);
1090            }
1091        }
1092
1093        return portlets;
1094    }
1095
1096    protected boolean hasNonstaticPortletId(String portletId) {
1097        LayoutTemplate layoutTemplate = getLayoutTemplate();
1098
1099        List columns = layoutTemplate.getColumns();
1100
1101        for (int i = 0; i < columns.size(); i++) {
1102            String columnId = (String)columns.get(i);
1103
1104            if (hasNonstaticPortletId(columnId, portletId)) {
1105                return true;
1106            }
1107        }
1108
1109        return false;
1110    }
1111
1112    protected boolean hasNonstaticPortletId(String columnId, String portletId) {
1113        String columnValue = getTypeSettingsProperties().getProperty(columnId);
1114
1115        if (StringUtil.contains(columnValue, portletId)) {
1116            return true;
1117        }
1118        else {
1119            return false;
1120        }
1121    }
1122
1123    /*protected boolean hasStaticPortletId(String portletId) {
1124        LayoutTemplate layoutTemplate = getLayoutTemplate();
1125
1126        List columns = layoutTemplate.getColumns();
1127
1128        for (int i = 0; i < columns.size(); i++) {
1129            String columnId = (String)columns.get(i);
1130
1131            if (hasStaticPortletId(columnId, portletId)) {
1132                return true;
1133            }
1134        }
1135
1136        return false;
1137    }*/
1138
1139    protected boolean hasStaticPortletId(String columnId, String portletId) {
1140        String[] staticPortletIdsStart = getStaticPortletIds(
1141            PropsUtil.LAYOUT_STATIC_PORTLETS_START + columnId);
1142
1143        String[] staticPortletIdsEnd = getStaticPortletIds(
1144            PropsUtil.LAYOUT_STATIC_PORTLETS_END + columnId);
1145
1146        String[] staticPortletIds = ArrayUtil.append(
1147            staticPortletIdsStart, staticPortletIdsEnd);
1148
1149        for (int i = 0; i < staticPortletIds.length; i++) {
1150            String staticPortletId = staticPortletIds[i];
1151
1152            if (staticPortletId.equals(portletId)) {
1153                return true;
1154            }
1155        }
1156
1157        return false;
1158    }
1159
1160    private static Log _log = LogFactory.getLog(LayoutTypePortletImpl.class);
1161
1162    private boolean _enablePortletLayoutListener = true;
1163
1164}