コード例 #1
0
  @Override
  public String readResponse(ThemeDisplay themeDisplay, ActionRequest actionRequest)
      throws PortalException {

    HttpServletRequest request = PortalUtil.getHttpServletRequest(actionRequest);

    request = PortalUtil.getOriginalServletRequest(request);

    String receivingURL = ParamUtil.getString(request, "openid.return_to");
    ParameterList parameterList = new ParameterList(request.getParameterMap());

    HttpSession session = request.getSession();

    DiscoveryInformation discoveryInformation =
        (DiscoveryInformation) session.getAttribute(OpenIdWebKeys.OPEN_ID_DISCO);

    if (discoveryInformation == null) {
      return null;
    }

    AuthSuccess authSuccess = null;
    String firstName = null;
    String lastName = null;
    String emailAddress = null;

    try {
      VerificationResult verificationResult =
          _consumerManager.verify(receivingURL, parameterList, discoveryInformation);

      Identifier identifier = verificationResult.getVerifiedId();

      if (identifier == null) {
        return null;
      }

      authSuccess = (AuthSuccess) verificationResult.getAuthResponse();

      firstName = null;
      lastName = null;
      emailAddress = null;

      if (authSuccess.hasExtension(SRegMessage.OPENID_NS_SREG)) {
        MessageExtension messageExtension = authSuccess.getExtension(SRegMessage.OPENID_NS_SREG);

        if (messageExtension instanceof SRegResponse) {
          SRegResponse sregResp = (SRegResponse) messageExtension;

          String fullName =
              GetterUtil.getString(sregResp.getAttributeValue(_OPEN_ID_SREG_ATTR_FULLNAME));

          String[] names = splitFullName(fullName);

          if (names != null) {
            firstName = names[0];
            lastName = names[1];
          }

          emailAddress = sregResp.getAttributeValue(_OPEN_ID_SREG_ATTR_EMAIL);
        }
      }

      if (authSuccess.hasExtension(AxMessage.OPENID_NS_AX)) {
        MessageExtension messageExtension = authSuccess.getExtension(AxMessage.OPENID_NS_AX);

        if (messageExtension instanceof FetchResponse) {
          FetchResponse fetchResponse = (FetchResponse) messageExtension;

          OpenIdProvider openIdProvider =
              _openIdProviderRegistry.getOpenIdProvider(discoveryInformation.getOPEndpoint());

          String[] openIdAXTypes = openIdProvider.getAxSchema();

          for (String openIdAXType : openIdAXTypes) {
            if (openIdAXType.equals(_OPEN_ID_AX_ATTR_EMAIL)) {
              if (Validator.isNull(emailAddress)) {
                emailAddress =
                    getFirstValue(fetchResponse.getAttributeValues(_OPEN_ID_AX_ATTR_EMAIL));
              }
            } else if (openIdAXType.equals(_OPEN_ID_AX_ATTR_FIRST_NAME)) {

              if (Validator.isNull(firstName)) {
                firstName =
                    getFirstValue(fetchResponse.getAttributeValues(_OPEN_ID_AX_ATTR_FIRST_NAME));
              }
            } else if (openIdAXType.equals(_OPEN_ID_AX_ATTR_FULL_NAME)) {

              String fullName = fetchResponse.getAttributeValue(_OPEN_ID_AX_ATTR_FULL_NAME);

              String[] names = splitFullName(fullName);

              if (names != null) {
                if (Validator.isNull(firstName)) {
                  firstName = names[0];
                }

                if (Validator.isNull(lastName)) {
                  lastName = names[1];
                }
              }
            } else if (openIdAXType.equals(_OPEN_ID_AX_ATTR_LAST_NAME)) {

              if (Validator.isNull(lastName)) {
                lastName =
                    getFirstValue(fetchResponse.getAttributeValues(_OPEN_ID_AX_ATTR_LAST_NAME));
              }
            }
          }
        }
      }
    } catch (AssociationException ae) {
      throw new OpenIdServiceException.AssociationException(ae.getMessage(), ae);
    } catch (DiscoveryException de) {
      throw new OpenIdServiceException.DiscoveryException(de.getMessage(), de);
    } catch (MessageException me) {
      throw new OpenIdServiceException.MessageException(me.getMessage(), me);
    }

    String openId = normalize(authSuccess.getIdentity());

    User user = _userLocalService.fetchUserByOpenId(themeDisplay.getCompanyId(), openId);

    if (user != null) {
      session.setAttribute(WebKeys.OPEN_ID_LOGIN, user.getUserId());

      return null;
    }

    try {
      if (Validator.isNull(firstName)
          || Validator.isNull(lastName)
          || Validator.isNull(emailAddress)) {

        SessionMessages.add(request, "openIdUserInformationMissing");

        if (_log.isInfoEnabled()) {
          _log.info(
              "The OpenID provider did not send the required " + "attributes to create an account");
        }

        String createAccountURL = PortalUtil.getCreateAccountURL(request, themeDisplay);

        String portletId = HttpUtil.getParameter(createAccountURL, "p_p_id", false);

        String portletNamespace = PortalUtil.getPortletNamespace(portletId);

        createAccountURL =
            HttpUtil.setParameter(createAccountURL, portletNamespace + "openId", openId);

        session.setAttribute(WebKeys.OPEN_ID_LOGIN_PENDING, Boolean.TRUE);

        return createAccountURL;
      }
    } catch (Exception e) {
      throw new PortalException(e);
    }

    long creatorUserId = 0;
    long companyId = themeDisplay.getCompanyId();
    boolean autoPassword = false;
    String password1 = PwdGenerator.getPassword();
    String password2 = password1;
    boolean autoScreenName = true;
    String screenName = StringPool.BLANK;
    long facebookId = 0;
    Locale locale = themeDisplay.getLocale();
    String middleName = StringPool.BLANK;
    long prefixId = 0;
    long suffixId = 0;
    boolean male = true;
    int birthdayMonth = Calendar.JANUARY;
    int birthdayDay = 1;
    int birthdayYear = 1970;
    String jobTitle = StringPool.BLANK;
    long[] groupIds = null;
    long[] organizationIds = null;
    long[] roleIds = null;
    long[] userGroupIds = null;
    boolean sendEmail = false;

    ServiceContext serviceContext = new ServiceContext();

    user =
        _userLocalService.addUser(
            creatorUserId,
            companyId,
            autoPassword,
            password1,
            password2,
            autoScreenName,
            screenName,
            emailAddress,
            facebookId,
            openId,
            locale,
            firstName,
            middleName,
            lastName,
            prefixId,
            suffixId,
            male,
            birthdayMonth,
            birthdayDay,
            birthdayYear,
            jobTitle,
            groupIds,
            organizationIds,
            roleIds,
            userGroupIds,
            sendEmail,
            serviceContext);

    session.setAttribute(WebKeys.OPEN_ID_LOGIN, user.getUserId());

    return null;
  }
コード例 #2
0
  @Override
  public String getActualURL(
      long companyId,
      long groupId,
      boolean privateLayout,
      String mainPath,
      String friendlyURL,
      Map<String, String[]> params,
      Map<String, Object> requestContext)
      throws PortalException {

    String urlTitle =
        friendlyURL.substring(JournalArticleConstants.CANONICAL_URL_SEPARATOR.length());

    JournalArticle journalArticle =
        _journalArticleLocalService.getArticleByUrlTitle(groupId, urlTitle);

    Layout layout = getJournalArticleLayout(groupId, privateLayout, friendlyURL);

    String layoutActualURL = PortalUtil.getLayoutActualURL(layout, mainPath);

    InheritableMap<String, String[]> actualParams = new InheritableMap<>();

    if (params != null) {
      actualParams.setParentMap(params);
    }

    UnicodeProperties typeSettingsProperties = layout.getTypeSettingsProperties();

    String defaultAssetPublisherPortletId =
        typeSettingsProperties.get(LayoutTypePortletConstants.DEFAULT_ASSET_PUBLISHER_PORTLET_ID);

    String currentDefaultAssetPublisherPortletId = defaultAssetPublisherPortletId;

    if (Validator.isNull(defaultAssetPublisherPortletId)) {
      PortletInstance portletInstance =
          new PortletInstance(AssetPublisherPortletKeys.ASSET_PUBLISHER);

      defaultAssetPublisherPortletId = portletInstance.getPortletInstanceKey();
    }

    HttpServletRequest request = (HttpServletRequest) requestContext.get("request");

    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
      String actualPortletAuthenticationToken =
          AuthTokenUtil.getToken(request, layout.getPlid(), defaultAssetPublisherPortletId);

      actualParams.put("p_p_auth", new String[] {actualPortletAuthenticationToken});
    }

    actualParams.put("p_p_id", new String[] {defaultAssetPublisherPortletId});
    actualParams.put("p_p_lifecycle", new String[] {"0"});

    if (Validator.isNull(currentDefaultAssetPublisherPortletId)) {
      actualParams.put("p_p_state", new String[] {WindowState.MAXIMIZED.toString()});
    }

    actualParams.put("p_p_mode", new String[] {"view"});
    actualParams.put("p_j_a_id", new String[] {String.valueOf(journalArticle.getId())});

    String namespace = PortalUtil.getPortletNamespace(defaultAssetPublisherPortletId);

    actualParams.put(namespace + "mvcPath", new String[] {"/view_content.jsp"});

    AssetRendererFactory<?> assetRendererFactory =
        AssetRendererFactoryRegistryUtil.getAssetRendererFactoryByClassName(
            JournalArticle.class.getName());

    actualParams.put(namespace + "type", new String[] {assetRendererFactory.getType()});

    actualParams.put(namespace + "urlTitle", new String[] {journalArticle.getUrlTitle()});

    String queryString = HttpUtil.parameterMapToString(actualParams, false);

    if (layoutActualURL.contains(StringPool.QUESTION)) {
      layoutActualURL = layoutActualURL + StringPool.AMPERSAND + queryString;
    } else {
      layoutActualURL = layoutActualURL + StringPool.QUESTION + queryString;
    }

    Locale locale = PortalUtil.getLocale(request);

    PortalUtil.addPageSubtitle(journalArticle.getTitle(locale), request);
    PortalUtil.addPageDescription(journalArticle.getDescription(locale), request);

    List<AssetTag> assetTags =
        _assetTagLocalService.getTags(
            JournalArticle.class.getName(), journalArticle.getPrimaryKey());

    if (!assetTags.isEmpty()) {
      PortalUtil.addPageKeywords(ListUtil.toString(assetTags, AssetTag.NAME_ACCESSOR), request);
    }

    return layoutActualURL;
  }
コード例 #3
0
  protected void onRemoveFromLayout(String[] portletIds) {
    Set<String> portletIdList = new HashSet<>();

    for (String portletId : portletIds) {
      removeModesPortletId(portletId);
      removeStatesPortletId(portletId);

      portletIdList.add(portletId);

      String rootPortletId = PortletConstants.getRootPortletId(portletId);

      if (rootPortletId.equals(PortletKeys.NESTED_PORTLETS)) {
        String portletNamespace = PortalUtil.getPortletNamespace(portletId);

        UnicodeProperties typeSettingsProperties = getTypeSettingsProperties();

        for (Map.Entry<String, String> entry : typeSettingsProperties.entrySet()) {

          String key = entry.getKey();

          if (!key.startsWith(portletNamespace)) {
            continue;
          }

          String nestedPortletIds = entry.getValue();

          for (String nestedPortletId : StringUtil.split(nestedPortletIds)) {

            removeModesPortletId(nestedPortletId);
            removeStatesPortletId(nestedPortletId);

            portletIdList.add(nestedPortletId);
          }
        }

        removeNestedColumns(portletNamespace);
      }

      Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);

      if (portlet == null) {
        continue;
      }

      PortletLayoutListener portletLayoutListener = portlet.getPortletLayoutListenerInstance();

      if (portletLayoutListener == null) {
        continue;
      }

      portletLayoutListener.updatePropertiesOnRemoveFromLayout(
          portletId, getTypeSettingsProperties());
    }

    try {
      PortletLocalServiceUtil.deletePortlets(
          getCompanyId(), portletIdList.toArray(new String[portletIdList.size()]), getPlid());
    } catch (PortalException pe) {
      _log.error(pe, pe);
    }
  }
コード例 #4
0
/**
 * @author Brian Wing Shun Chan
 * @author Berentey Zsolt
 * @author Jorge Ferrer
 * @author Raymond Augé
 */
public class LayoutTypePortletImpl extends LayoutTypeImpl implements LayoutTypePortlet {

  public LayoutTypePortletImpl(
      Layout layout,
      LayoutTypeController layoutTypeController,
      LayoutTypeAccessPolicy layoutTypeAccessPolicy) {

    super(layout, layoutTypeController, layoutTypeAccessPolicy);

    _layoutSetPrototypeLayout = SitesUtil.getLayoutSetPrototypeLayout(layout);
  }

  @Override
  public void addModeAboutPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeAbout(StringUtil.add(getModeAbout(), portletId));
  }

  @Override
  public void addModeConfigPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeConfig(StringUtil.add(getModeConfig(), portletId));
  }

  @Override
  public void addModeEditDefaultsPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeEditDefaults(StringUtil.add(getModeEditDefaults(), portletId));
  }

  @Override
  public void addModeEditGuestPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeEditGuest(StringUtil.add(getModeEditGuest(), portletId));
  }

  @Override
  public void addModeEditPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeEdit(StringUtil.add(getModeEdit(), portletId));
  }

  @Override
  public void addModeHelpPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModeHelp(StringUtil.add(getModeHelp(), portletId));
  }

  @Override
  public void addModePreviewPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModePreview(StringUtil.add(getModePreview(), portletId));
  }

  @Override
  public void addModePrintPortletId(String portletId) {
    removeModesPortletId(portletId);
    setModePrint(StringUtil.add(getModePrint(), portletId));
  }

  @Override
  public String addPortletId(long userId, String portletId) {
    return addPortletId(userId, portletId, true);
  }

  @Override
  public String addPortletId(long userId, String portletId, boolean checkPermission) {

    return addPortletId(userId, portletId, null, -1, checkPermission);
  }

  @Override
  public String addPortletId(long userId, String portletId, String columnId, int columnPos) {

    return addPortletId(userId, portletId, columnId, columnPos, true);
  }

  @Override
  public String addPortletId(
      long userId, String portletId, String columnId, int columnPos, boolean checkPermission) {

    return addPortletId(userId, portletId, columnId, columnPos, checkPermission, false);
  }

  @Override
  public void addPortletIds(long userId, String[] portletIds, boolean checkPermission) {

    for (String portletId : portletIds) {
      addPortletId(userId, portletId, checkPermission);
    }
  }

  @Override
  public void addPortletIds(
      long userId, String[] portletIds, String columnId, boolean checkPermission) {

    for (String portletId : portletIds) {
      addPortletId(userId, portletId, columnId, -1, checkPermission);
    }
  }

  @Override
  public void addStateMaxPortletId(String portletId) {
    removeStatesPortletId(portletId);
    // setStateMax(StringUtil.add(getStateMax(), portletId));
    setStateMax(StringUtil.add(StringPool.BLANK, portletId));
  }

  @Override
  public void addStateMinPortletId(String portletId) {
    removeStateMaxPortletId(portletId);
    setStateMin(StringUtil.add(getStateMin(), portletId));
  }

  @Override
  public List<Portlet> addStaticPortlets(
      List<Portlet> portlets, List<Portlet> startPortlets, List<Portlet> endPortlets) {

    // Return the original array of portlets if no static portlets are
    // specified

    if (startPortlets == null) {
      startPortlets = new ArrayList<>();
    }

    if (endPortlets == null) {
      endPortlets = new ArrayList<>();
    }

    if (startPortlets.isEmpty() && endPortlets.isEmpty()) {
      return portlets;
    }

    // New array of portlets that contain the static portlets

    List<Portlet> list =
        new ArrayList<>(portlets.size() + startPortlets.size() + endPortlets.size());

    if (!startPortlets.isEmpty()) {
      list.addAll(startPortlets);
    }

    for (int i = 0; i < portlets.size(); i++) {
      Portlet portlet = portlets.get(i);

      // Add the portlet if and only if it is not also a static portlet

      if (!startPortlets.contains(portlet) && !endPortlets.contains(portlet)) {

        list.add(portlet);
      }
    }

    if (!endPortlets.isEmpty()) {
      list.addAll(endPortlets);
    }

    return list;
  }

  @Override
  public List<Portlet> getAllPortlets() {
    List<Portlet> explicitlyAddedPortlets = getExplicitlyAddedPortlets();

    List<Portlet> staticPortlets = getStaticPortlets(PropsKeys.LAYOUT_STATIC_PORTLETS_ALL);

    List<Portlet> embeddedPortlets = getEmbeddedPortlets();

    return addStaticPortlets(explicitlyAddedPortlets, staticPortlets, embeddedPortlets);
  }

  @Override
  public List<Portlet> getAllPortlets(boolean includeSystem) {
    List<Portlet> filteredPortlets = new ArrayList<>();

    List<Portlet> portlets = getAllPortlets();

    for (Portlet portlet : portlets) {
      if (portlet.isSystem() && !includeSystem) {
        continue;
      }

      filteredPortlets.add(portlet);
    }

    return filteredPortlets;
  }

  @Override
  public List<Portlet> getAllPortlets(String columnId) {
    String columnValue = getColumnValue(columnId);

    String[] portletIds = StringUtil.split(columnValue);

    List<Portlet> portlets = new ArrayList<>(portletIds.length);

    for (String portletId : portletIds) {
      Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), portletId);

      if (portlet != null) {
        portlets.add(portlet);
      }
    }

    List<Portlet> startPortlets =
        getStaticPortlets(PropsKeys.LAYOUT_STATIC_PORTLETS_START + columnId);

    List<Portlet> endPortlets = getStaticPortlets(PropsKeys.LAYOUT_STATIC_PORTLETS_END + columnId);

    return addStaticPortlets(portlets, startPortlets, endPortlets);
  }

  @Override
  public List<Portlet> getEmbeddedPortlets() {
    Layout layout = getLayout();

    return layout.getEmbeddedPortlets();
  }

  @Override
  public List<Portlet> getExplicitlyAddedPortlets() {
    List<Portlet> portlets = new ArrayList<>();

    List<String> columns = getColumns();

    for (int i = 0; i < columns.size(); i++) {
      String columnId = columns.get(i);

      portlets.addAll(getAllPortlets(columnId));
    }

    return portlets;
  }

  @Override
  public Layout getLayoutSetPrototypeLayout() {
    return _layoutSetPrototypeLayout;
  }

  @Override
  public String getLayoutSetPrototypeLayoutProperty(String key) {
    if (_layoutSetPrototypeLayout == null) {
      return StringPool.BLANK;
    }

    UnicodeProperties typeSettingsProperties =
        _layoutSetPrototypeLayout.getTypeSettingsProperties();

    return typeSettingsProperties.getProperty(key);
  }

  @Override
  public LayoutTemplate getLayoutTemplate() {
    String themeId = getThemeId();

    LayoutTemplate layoutTemplate =
        LayoutTemplateLocalServiceUtil.getLayoutTemplate(getLayoutTemplateId(), false, themeId);

    if (layoutTemplate == null) {
      layoutTemplate = new LayoutTemplateImpl(StringPool.BLANK, StringPool.BLANK);

      List<String> columns = new ArrayList<>();

      for (int i = 1; i <= 10; i++) {
        columns.add(LayoutTypePortletConstants.COLUMN_PREFIX + i);
      }

      layoutTemplate.setColumns(columns);
    }

    return layoutTemplate;
  }

  @Override
  public String getLayoutTemplateId() {
    return GetterUtil.getString(
        getTypeSettingsProperty(LayoutTypePortletConstants.LAYOUT_TEMPLATE_ID));
  }

  @Override
  public String getModeAbout() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_ABOUT);
  }

  @Override
  public String getModeConfig() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_CONFIG);
  }

  @Override
  public String getModeEdit() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT);
  }

  @Override
  public String getModeEditDefaults() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT_DEFAULTS);
  }

  @Override
  public String getModeEditGuest() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT_GUEST);
  }

  @Override
  public String getModeHelp() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_HELP);
  }

  @Override
  public String getModePreview() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_PREVIEW);
  }

  @Override
  public String getModePrint() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.MODE_PRINT);
  }

  @Override
  public int getNumOfColumns() {
    return getLayoutTemplate().getColumns().size();
  }

  @Override
  public PortalPreferences getPortalPreferences() {
    return _portalPreferences;
  }

  @Override
  public List<String> getPortletIds() {
    List<String> portletIds = new ArrayList<>();

    List<String> columns = getColumns();

    for (int i = 0; i < columns.size(); i++) {
      String columnId = columns.get(i);

      String columnValue = getColumnValue(columnId);

      portletIds.addAll(ListUtil.fromArray(StringUtil.split(columnValue)));
    }

    return portletIds;
  }

  @Override
  public List<Portlet> getPortlets() {
    List<String> portletIds = getPortletIds();

    List<Portlet> portlets = new ArrayList<>(portletIds.size());

    for (int i = 0; i < portletIds.size(); i++) {
      String portletId = portletIds.get(i);

      Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), portletId);

      if (portlet != null) {
        portlets.add(portlet);
      }
    }

    return portlets;
  }

  @Override
  public String getStateMax() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.STATE_MAX);
  }

  @Override
  public String getStateMaxPortletId() {
    String[] stateMax = StringUtil.split(getStateMax());

    if (stateMax.length > 0) {
      return stateMax[0];
    } else {
      return StringPool.BLANK;
    }
  }

  @Override
  public String getStateMin() {
    return getTypeSettingsProperty(LayoutTypePortletConstants.STATE_MIN);
  }

  @Override
  public boolean hasDefaultScopePortletId(long groupId, String portletId) {
    if (hasPortletId(portletId)) {
      long scopeGroupId = PortalUtil.getScopeGroupId(getLayout(), portletId);

      if (groupId == scopeGroupId) {
        return true;
      }
    }

    return false;
  }

  @Override
  public boolean hasModeAboutPortletId(String portletId) {
    return StringUtil.contains(getModeAbout(), portletId);
  }

  @Override
  public boolean hasModeConfigPortletId(String portletId) {
    return StringUtil.contains(getModeConfig(), portletId);
  }

  @Override
  public boolean hasModeEditDefaultsPortletId(String portletId) {
    return StringUtil.contains(getModeEditDefaults(), portletId);
  }

  @Override
  public boolean hasModeEditGuestPortletId(String portletId) {
    return StringUtil.contains(getModeEditGuest(), portletId);
  }

  @Override
  public boolean hasModeEditPortletId(String portletId) {
    return StringUtil.contains(getModeEdit(), portletId);
  }

  @Override
  public boolean hasModeHelpPortletId(String portletId) {
    return StringUtil.contains(getModeHelp(), portletId);
  }

  @Override
  public boolean hasModePreviewPortletId(String portletId) {
    return StringUtil.contains(getModePreview(), portletId);
  }

  @Override
  public boolean hasModePrintPortletId(String portletId) {
    return StringUtil.contains(getModePrint(), portletId);
  }

  @Override
  public boolean hasModeViewPortletId(String portletId) {
    if (hasModeAboutPortletId(portletId)
        || hasModeConfigPortletId(portletId)
        || hasModeEditPortletId(portletId)
        || hasModeEditDefaultsPortletId(portletId)
        || hasModeEditGuestPortletId(portletId)
        || hasModeHelpPortletId(portletId)
        || hasModePreviewPortletId(portletId)
        || hasModePrintPortletId(portletId)) {

      return false;
    } else {
      return true;
    }
  }

  @Override
  public boolean hasPortletId(String portletId) {
    return hasPortletId(portletId, false);
  }

  @Override
  public boolean hasPortletId(String portletId, boolean strict) {
    List<String> columns = getColumns();

    for (String columnId : columns) {
      if (hasNonstaticPortletId(columnId, portletId)) {
        return true;
      }

      if (hasStaticPortletId(columnId, portletId)) {
        return true;
      }
    }

    Layout layout = getLayout();

    if (layout.isTypeControlPanel()) {
      return false;
    }

    if (isCustomizable() && isCustomizedView()) {
      LayoutTypePortletImpl defaultLayoutTypePortletImpl = getDefaultLayoutTypePortletImpl();

      if (defaultLayoutTypePortletImpl.hasNonstaticPortletId(portletId)) {
        return false;
      }
    }

    if (!strict
        && ((PortletPreferencesLocalServiceUtil.getPortletPreferencesCount(
                    PortletKeys.PREFS_OWNER_TYPE_LAYOUT, layout.getPlid(), portletId)
                > 0)
            || (PortletPreferencesLocalServiceUtil.getPortletPreferencesCount(
                    PortletKeys.PREFS_OWNER_TYPE_USER, layout.getPlid(), portletId)
                > 0))) {

      return true;
    }

    return false;
  }

  @Override
  public boolean hasStateMax() {
    String[] stateMax = StringUtil.split(getStateMax());

    if (stateMax.length > 0) {
      return true;
    } else {
      return false;
    }
  }

  @Override
  public boolean hasStateMaxPortletId(String portletId) {
    if (StringUtil.contains(getStateMax(), portletId)) {
      return true;
    } else {
      return false;
    }
  }

  @Override
  public boolean hasStateMin() {
    String[] stateMin = StringUtil.split(getStateMin());

    if (stateMin.length > 0) {
      return true;
    } else {
      return false;
    }
  }

  @Override
  public boolean hasStateMinPortletId(String portletId) {
    if (StringUtil.contains(getStateMin(), portletId)) {
      return true;
    } else {
      return false;
    }
  }

  @Override
  public boolean hasStateNormalPortletId(String portletId) {
    if (hasStateMaxPortletId(portletId) || hasStateMinPortletId(portletId)) {

      return false;
    } else {
      return true;
    }
  }

  @Override
  public boolean hasUpdatePermission() {
    return _updatePermission;
  }

  @Override
  public boolean isCacheable() {
    List<Portlet> portlets = new ArrayList<>();

    for (String columnId : getColumns()) {
      List<Portlet> columnPortlets = getAllPortlets(columnId);

      for (Portlet portlet : columnPortlets) {
        Portlet rootPortlet = portlet.getRootPortlet();

        if (!rootPortlet.isLayoutCacheable()) {
          return false;
        }
      }

      portlets.addAll(columnPortlets);
    }

    List<Portlet> staticPortlets = getStaticPortlets(PropsKeys.LAYOUT_STATIC_PORTLETS_ALL);

    for (Portlet portlet : staticPortlets) {
      Portlet rootPortlet = portlet.getRootPortlet();

      if (!rootPortlet.isLayoutCacheable()) {
        return false;
      }
    }

    List<Portlet> embeddedPortlets = getEmbeddedPortlets();

    for (Portlet portlet : embeddedPortlets) {
      Portlet rootPortlet = portlet.getRootPortlet();

      if (!rootPortlet.isLayoutCacheable()) {
        return false;
      }
    }

    return true;
  }

  @Override
  public boolean isColumnCustomizable(String columnId) {
    if (!isLayoutSetPrototype()) {
      String customizableString =
          getTypeSettingsProperty(CustomizedPages.namespaceColumnId(columnId));

      boolean customizable = GetterUtil.getBoolean(customizableString);

      if (!customizable && hasUserPreferences()) {
        String columnValue =
            _portalPreferences.getValue(
                CustomizedPages.namespacePlid(getPlid()), columnId, StringPool.NULL);

        if (!Objects.equals(columnValue, StringPool.NULL)) {
          setUserPreference(columnId, null);
        }
      }

      return customizable;
    }

    return false;
  }

  @Override
  public boolean isColumnDisabled(String columnId) {
    if ((isCustomizedView() && !isColumnCustomizable(columnId))
        || (!isCustomizedView() && !hasUpdatePermission())) {

      return true;
    }

    return false;
  }

  @Override
  public boolean isCustomizable() {
    for (String columnId : getColumns()) {
      if (isColumnCustomizable(columnId)) {
        return true;
      }
    }

    return false;
  }

  @Override
  public boolean isCustomizedView() {
    return _customizedView;
  }

  @Override
  public boolean isDefaultUpdated() {
    if (!isCustomizedView() || !hasUserPreferences()) {
      return false;
    }

    String preferencesModifiedDateString =
        _portalPreferences.getValue(
            CustomizedPages.namespacePlid(getPlid()), _MODIFIED_DATE, _NULL_DATE);

    DateFormat dateFormat =
        DateFormatFactoryUtil.getSimpleDateFormat(PropsValues.INDEX_DATE_FORMAT_PATTERN);

    try {
      Date preferencesModifiedDate = dateFormat.parse(preferencesModifiedDateString);

      Layout layout = getLayout();

      String propertiesModifiedDateString =
          layout.getTypeSettingsProperty(_MODIFIED_DATE, _NULL_DATE);

      Date propertiesModifiedDate = dateFormat.parse(propertiesModifiedDateString);

      return propertiesModifiedDate.after(preferencesModifiedDate);
    } catch (Exception e) {
      _log.error(e, e);
    }

    return false;
  }

  @Override
  public boolean isPortletCustomizable(String portletId) {
    return isColumnCustomizable(getColumn(portletId));
  }

  @Override
  public boolean isPortletEmbedded(String portletId) {
    Layout layout = getLayout();

    return layout.isPortletEmbedded(portletId, layout.getGroupId());
  }

  @Override
  public void movePortletId(long userId, String portletId, String columnId, int columnPos) {

    if (!hasPortletId(portletId)) {
      return;
    }

    _enablePortletLayoutListener = false;

    try {
      removePortletId(userId, portletId, false);
      addPortletId(userId, portletId, columnId, columnPos, false, true);
    } finally {
      _enablePortletLayoutListener = true;
    }

    Layout layout = getLayout();

    try {
      Portlet portlet = PortletLocalServiceUtil.getPortletById(layout.getCompanyId(), portletId);

      if (portlet != null) {
        PortletLayoutListener portletLayoutListener = portlet.getPortletLayoutListenerInstance();

        if (portletLayoutListener != null) {
          portletLayoutListener.onMoveInLayout(portletId, layout.getPlid());
        }
      }
    } catch (Exception e) {
      _log.error("Unable to fire portlet layout listener event", e);
    }
  }

  @Override
  public void removeCustomization(UnicodeProperties typeSettingsProperties) {
    for (String columnId : getColumns()) {
      if (!isColumnCustomizable(columnId)) {
        continue;
      }

      if (GetterUtil.getBoolean(
          getTypeSettingsProperty(CustomizedPages.namespaceColumnId(columnId)))) {

        typeSettingsProperties.remove(CustomizedPages.namespaceColumnId(columnId));
      }
    }
  }

  @Override
  public void removeModeAboutPortletId(String portletId) {
    setModeAbout(StringUtil.removeFromList(getModeAbout(), portletId));
  }

  @Override
  public void removeModeConfigPortletId(String portletId) {
    setModeConfig(StringUtil.removeFromList(getModeConfig(), portletId));
  }

  @Override
  public void removeModeEditDefaultsPortletId(String portletId) {
    setModeEditDefaults(StringUtil.removeFromList(getModeEditDefaults(), portletId));
  }

  @Override
  public void removeModeEditGuestPortletId(String portletId) {
    setModeEditGuest(StringUtil.removeFromList(getModeEditGuest(), portletId));
  }

  @Override
  public void removeModeEditPortletId(String portletId) {
    setModeEdit(StringUtil.removeFromList(getModeEdit(), portletId));
  }

  @Override
  public void removeModeHelpPortletId(String portletId) {
    setModeHelp(StringUtil.removeFromList(getModeHelp(), portletId));
  }

  @Override
  public void removeModePreviewPortletId(String portletId) {
    setModePreview(StringUtil.removeFromList(getModePreview(), portletId));
  }

  @Override
  public void removeModePrintPortletId(String portletId) {
    setModePrint(StringUtil.removeFromList(getModePrint(), portletId));
  }

  @Override
  public void removeModesPortletId(String portletId) {
    removeModeAboutPortletId(portletId);
    removeModeConfigPortletId(portletId);
    removeModeEditPortletId(portletId);
    removeModeEditDefaultsPortletId(portletId);
    removeModeEditGuestPortletId(portletId);
    removeModeHelpPortletId(portletId);
    removeModePreviewPortletId(portletId);
    removeModePrintPortletId(portletId);
  }

  @Override
  public void removeNestedColumns(String portletNamespace) {
    UnicodeProperties typeSettingsProperties = getTypeSettingsProperties();

    UnicodeProperties newTypeSettingsProperties = new UnicodeProperties();

    for (Map.Entry<String, String> entry : typeSettingsProperties.entrySet()) {

      String key = entry.getKey();

      if (!key.startsWith(portletNamespace)) {
        newTypeSettingsProperties.setProperty(key, entry.getValue());
      }
    }

    Layout layout = getLayout();

    layout.setTypeSettingsProperties(newTypeSettingsProperties);

    String nestedColumnIds =
        GetterUtil.getString(getTypeSettingsProperty(LayoutTypePortletConstants.NESTED_COLUMN_IDS));

    String[] nestedColumnIdsArray =
        ArrayUtil.removeByPrefix(StringUtil.split(nestedColumnIds), portletNamespace);

    setTypeSettingsProperty(
        LayoutTypePortletConstants.NESTED_COLUMN_IDS, StringUtil.merge(nestedColumnIdsArray));
  }

  @Override
  public void removePortletId(long userId, String portletId) {
    removePortletId(userId, portletId, true);
  }

  @Override
  public void removePortletId(long userId, String portletId, boolean cleanUp) {

    try {
      Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), portletId);

      if (portlet == null) {
        _log.error("Portlet " + portletId + " cannot be removed because it is not registered");

        return;
      }

      PermissionChecker permissionChecker = PermissionThreadLocal.getPermissionChecker();

      if (!LayoutPermissionUtil.contains(permissionChecker, getLayout(), ActionKeys.UPDATE)
          && !isCustomizable()) {

        return;
      }
    } catch (Exception e) {
      _log.error(e, e);

      return;
    }

    List<String> columns = getColumns();

    for (int i = 0; i < columns.size(); i++) {
      String columnId = columns.get(i);

      if (isCustomizable() && isColumnDisabled(columnId)) {
        continue;
      }

      String columnValue = StringPool.BLANK;

      if (hasUserPreferences()) {
        columnValue = getUserPreference(columnId);
      } else {
        columnValue = getTypeSettingsProperty(columnId);
      }

      columnValue = StringUtil.removeFromList(columnValue, portletId);

      if (hasUserPreferences()) {
        setUserPreference(columnId, columnValue);
      } else {
        setTypeSettingsProperty(columnId, columnValue);
      }
    }

    if (cleanUp) {
      try {
        onRemoveFromLayout(new String[] {portletId});
      } catch (Exception e) {
        _log.error(e, e);
      }
    }
  }

  @Override
  public void removeStateMaxPortletId(String portletId) {
    setStateMax(StringUtil.removeFromList(getStateMax(), portletId));
  }

  @Override
  public void removeStateMinPortletId(String portletId) {
    setStateMin(StringUtil.removeFromList(getStateMin(), portletId));
  }

  @Override
  public void removeStatesPortletId(String portletId) {
    removeStateMaxPortletId(portletId);
    removeStateMinPortletId(portletId);
  }

  @Override
  public void reorganizePortlets(List<String> newColumns, List<String> oldColumns) {

    String lastNewColumnId = newColumns.get(newColumns.size() - 1);
    String lastNewColumnValue = getTypeSettingsProperty(lastNewColumnId);

    for (String oldColumnId : oldColumns) {
      if (!newColumns.contains(oldColumnId)) {
        String oldColumnValue = getTypeSettingsProperties().remove(oldColumnId);

        String[] portletIds = StringUtil.split(oldColumnValue);

        for (String portletId : portletIds) {
          lastNewColumnValue = StringUtil.add(lastNewColumnValue, portletId);
        }
      }
    }

    setTypeSettingsProperty(lastNewColumnId, lastNewColumnValue);
  }

  @Override
  public void resetModes() {
    setModeAbout(StringPool.BLANK);
    setModeConfig(StringPool.BLANK);
    setModeEdit(StringPool.BLANK);
    setModeEditDefaults(StringPool.BLANK);
    setModeEditGuest(StringPool.BLANK);
    setModeHelp(StringPool.BLANK);
    setModePreview(StringPool.BLANK);
    setModePrint(StringPool.BLANK);
  }

  @Override
  public void resetStates() {
    setStateMax(StringPool.BLANK);
    setStateMin(StringPool.BLANK);
  }

  @Override
  public void resetUserPreferences() {
    if (!hasUserPreferences()) {
      return;
    }

    long plid = getPlid();

    Set<String> customPortletIds = new HashSet<>();

    for (String columnId : getColumns()) {
      String value = _portalPreferences.getValue(CustomizedPages.namespacePlid(plid), columnId);

      for (String customPortletId : StringUtil.split(value)) {
        customPortletIds.add(customPortletId);
      }
    }

    try {
      onRemoveFromLayout(customPortletIds.toArray(new String[customPortletIds.size()]));
    } catch (Exception e) {
      _log.error(e, e);
    }

    _portalPreferences.resetValues(CustomizedPages.namespacePlid(plid));

    _portalPreferences.setValue(
        CustomizedPages.namespacePlid(plid), _MODIFIED_DATE, _dateFormat.format(new Date()));
  }

  @Override
  public void setCustomizedView(boolean customizedView) {
    _customizedView = customizedView;
  }

  @Override
  public void setLayoutTemplateId(long userId, String newLayoutTemplateId) {
    setLayoutTemplateId(userId, newLayoutTemplateId, true);
  }

  @Override
  public void setLayoutTemplateId(
      long userId, String newLayoutTemplateId, boolean checkPermission) {

    if (checkPermission
        && !PluginSettingLocalServiceUtil.hasPermission(
            userId, newLayoutTemplateId, Plugin.TYPE_LAYOUT_TEMPLATE)) {

      return;
    }

    LayoutTemplate oldLayoutTemplate = getLayoutTemplate();

    String themeId = getThemeId();

    LayoutTemplate newLayoutTemplate =
        LayoutTemplateLocalServiceUtil.getLayoutTemplate(newLayoutTemplateId, false, themeId);

    if (newLayoutTemplate == null) {
      if (_log.isWarnEnabled()) {
        _log.warn("Unable to find layout template " + newLayoutTemplateId);
      }

      return;
    }

    setTypeSettingsProperty(LayoutTypePortletConstants.LAYOUT_TEMPLATE_ID, newLayoutTemplateId);

    List<String> oldColumns = oldLayoutTemplate.getColumns();
    List<String> newColumns = newLayoutTemplate.getColumns();

    reorganizePortlets(newColumns, oldColumns);
  }

  @Override
  public void setModeAbout(String modeAbout) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_ABOUT, modeAbout);
  }

  @Override
  public void setModeConfig(String modeConfig) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_CONFIG, modeConfig);
  }

  @Override
  public void setModeEdit(String modeEdit) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT, modeEdit);
  }

  @Override
  public void setModeEditDefaults(String modeEditDefaults) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT_DEFAULTS, modeEditDefaults);
  }

  @Override
  public void setModeEditGuest(String modeEditGuest) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_EDIT_GUEST, modeEditGuest);
  }

  @Override
  public void setModeHelp(String modeHelp) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_HELP, modeHelp);
  }

  @Override
  public void setModePreview(String modePreview) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_PREVIEW, modePreview);
  }

  @Override
  public void setModePrint(String modePrint) {
    setTypeSettingsProperty(LayoutTypePortletConstants.MODE_PRINT, modePrint);
  }

  @Override
  public void setPortalPreferences(PortalPreferences portalPreferences) {
    _portalPreferences = portalPreferences;
  }

  @Override
  public void setStateMax(String stateMax) {
    setTypeSettingsProperty(LayoutTypePortletConstants.STATE_MAX, stateMax);
  }

  @Override
  public void setStateMin(String stateMin) {
    setTypeSettingsProperty(LayoutTypePortletConstants.STATE_MIN, stateMin);
  }

  @Override
  public void setUpdatePermission(boolean updatePermission) {
    _updatePermission = updatePermission;
  }

  protected void addNestedColumn(String columnId) {
    String nestedColumnIds =
        getTypeSettingsProperty(LayoutTypePortletConstants.NESTED_COLUMN_IDS, StringPool.BLANK);

    if (!nestedColumnIds.contains(columnId)) {
      nestedColumnIds = StringUtil.add(nestedColumnIds, columnId);

      setTypeSettingsProperty(LayoutTypePortletConstants.NESTED_COLUMN_IDS, nestedColumnIds);
    }
  }

  protected String addPortletId(
      long userId,
      String portletId,
      String columnId,
      int columnPos,
      boolean checkPermission,
      boolean strictHasPortlet) {

    portletId = JS.getSafeName(portletId);

    Layout layout = getLayout();

    Portlet portlet = null;

    try {
      portlet = PortletLocalServiceUtil.getPortletById(layout.getCompanyId(), portletId);

      if (portlet == null) {
        if (_log.isWarnEnabled()) {
          _log.warn("Portlet " + portletId + " cannot be added because it is not registered");
        }

        return null;
      }

      PermissionChecker permissionChecker = PermissionThreadLocal.getPermissionChecker();

      if (checkPermission
          && !PortletPermissionUtil.contains(
              permissionChecker, layout, portlet, ActionKeys.ADD_TO_PAGE)) {

        return null;
      }
    } catch (Exception e) {
      _log.error(e, e);
    }

    if (portlet.isSystem()) {
      return null;
    }

    if (portlet.isInstanceable() && !PortletConstants.hasInstanceId(portletId)) {

      portletId =
          PortletConstants.assemblePortletId(portletId, PortletConstants.generateInstanceId());
    }

    if (hasPortletId(portletId, strictHasPortlet)) {
      return null;
    }

    if (columnId == null) {
      LayoutTemplate layoutTemplate = getLayoutTemplate();

      List<String> columns = layoutTemplate.getColumns();

      if (!columns.isEmpty()) {
        columnId = columns.get(0);
      }
    }

    if (columnId == null) {
      return null;
    }

    if (isCustomizable()) {
      if (isColumnDisabled(columnId)) {
        return null;
      }

      if ((PortletConstants.hasInstanceId(portletId) || portlet.isPreferencesUniquePerLayout())
          && hasUserPreferences()) {

        portletId = PortletConstants.assemblePortletId(portletId, userId);
      }
    }

    String columnValue = StringPool.BLANK;

    if (hasUserPreferences()) {
      columnValue = getUserPreference(columnId);
    } else {
      columnValue = getTypeSettingsProperty(columnId);
    }

    if ((columnValue == null) && columnId.startsWith(_NESTED_PORTLETS_NAMESPACE)) {

      addNestedColumn(columnId);
    }

    if (columnPos >= 0) {
      List<String> portletIds = ListUtil.fromArray(StringUtil.split(columnValue));

      if (columnPos <= portletIds.size()) {
        portletIds.add(columnPos, portletId);
      } else {
        portletIds.add(portletId);
      }

      columnValue = StringUtil.merge(portletIds);
    } else {
      columnValue = StringUtil.add(columnValue, portletId);
    }

    if (hasUserPreferences()) {
      setUserPreference(columnId, columnValue);
    } else {
      setTypeSettingsProperty(columnId, columnValue);
    }

    try {
      if (_enablePortletLayoutListener && !portlet.isUndeployedPortlet()) {

        PortletLayoutListener portletLayoutListener = portlet.getPortletLayoutListenerInstance();

        if (portletLayoutListener != null) {
          portletLayoutListener.onAddToLayout(portletId, layout.getPlid());
        }
      }
    } catch (Exception e) {
      _log.error("Unable to fire portlet layout listener event", e);
    }

    return portletId;
  }

  protected void copyPreferences(long userId, String sourcePortletId, String targetPortletId) {

    Layout layout = getLayout();

    try {
      PortletPreferencesIds portletPreferencesIds =
          PortletPreferencesFactoryUtil.getPortletPreferencesIds(
              layout.getGroupId(), 0, layout, sourcePortletId, false);

      javax.portlet.PortletPreferences sourcePortletPreferences =
          PortletPreferencesLocalServiceUtil.getStrictPreferences(portletPreferencesIds);

      portletPreferencesIds =
          PortletPreferencesFactoryUtil.getPortletPreferencesIds(
              layout.getGroupId(), userId, layout, targetPortletId, false);

      PortletPreferencesLocalServiceUtil.updatePreferences(
          portletPreferencesIds.getOwnerId(),
          portletPreferencesIds.getOwnerType(),
          portletPreferencesIds.getPlid(),
          portletPreferencesIds.getPortletId(),
          sourcePortletPreferences);
    } catch (Exception e) {
    }
  }

  protected void copyResourcePermissions(String sourcePortletId, String targetPortletId) {

    Layout layout = getLayout();

    Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), sourcePortletId);

    String sourcePortletPrimaryKey =
        PortletPermissionUtil.getPrimaryKey(layout.getPlid(), sourcePortletId);

    List<ResourcePermission> resourcePermissions =
        ResourcePermissionLocalServiceUtil.getResourcePermissions(
            portlet.getCompanyId(),
            portlet.getPortletName(),
            PortletKeys.PREFS_OWNER_TYPE_USER,
            sourcePortletPrimaryKey);

    for (ResourcePermission resourcePermission : resourcePermissions) {
      String targetPortletPrimaryKey =
          PortletPermissionUtil.getPrimaryKey(layout.getPlid(), targetPortletId);

      resourcePermission.setResourcePermissionId(CounterLocalServiceUtil.increment());
      resourcePermission.setPrimKey(targetPortletPrimaryKey);

      ResourcePermissionLocalServiceUtil.addResourcePermission(resourcePermission);
    }
  }

  protected String getColumn(String portletId) {
    String portletIdColumnId = StringPool.BLANK;

    List<String> columnIds = getColumns();

    for (String columnId : columnIds) {
      String columnValue = getColumnValue(columnId);

      String[] portletIds = StringUtil.split(columnValue);

      for (String columnPortletId : portletIds) {
        if (columnPortletId.equals(portletId)) {
          return columnId;
        }

        if (Validator.isNull(portletIdColumnId)
            && PortletConstants.hasIdenticalRootPortletId(columnPortletId, portletId)) {

          portletIdColumnId = columnId;
        }
      }
    }

    return portletIdColumnId;
  }

  protected List<String> getColumns() {
    List<String> columns = new ArrayList<>();

    Layout layout = getLayout();

    if (layout.isTypePortlet()) {
      LayoutTemplate layoutTemplate = getLayoutTemplate();

      columns.addAll(layoutTemplate.getColumns());

      columns.addAll(getNestedColumns());
    } else if (layout.isTypePanel()) {
      columns.add("panelSelectedPortlets");
    }

    return columns;
  }

  protected String getColumnValue(String columnId) {
    if (hasUserPreferences() && isCustomizable() && !isColumnDisabled(columnId)) {

      return getUserPreference(columnId);
    }

    return getTypeSettingsProperty(columnId);
  }

  protected long getCompanyId() {
    Layout layout = getLayout();

    return layout.getCompanyId();
  }

  protected LayoutTypePortletImpl getDefaultLayoutTypePortletImpl() {
    if (!isCustomizedView()) {
      return this;
    }

    LayoutTypePortletImpl defaultLayoutTypePortletImpl =
        (LayoutTypePortletImpl) LayoutTypePortletFactoryUtil.create(getLayout());

    defaultLayoutTypePortletImpl._layoutSetPrototypeLayout = _layoutSetPrototypeLayout;
    defaultLayoutTypePortletImpl._updatePermission = _updatePermission;

    return defaultLayoutTypePortletImpl;
  }

  protected List<String> getNestedColumns() {
    String nestedColumnIds = getTypeSettingsProperty(LayoutTypePortletConstants.NESTED_COLUMN_IDS);

    return ListUtil.fromArray(StringUtil.split(nestedColumnIds));
  }

  protected long getPlid() {
    Layout layout = getLayout();

    return layout.getPlid();
  }

  protected String[] getStaticPortletIds(String position) {
    Layout layout = getLayout();

    String selector1 = StringPool.BLANK;

    Group group = null;

    try {
      group = layout.getGroup();
    } catch (PortalException pe) {
      _log.error("Unable to get group " + layout.getGroupId());

      return new String[0];
    }

    if (group.isUser()) {
      selector1 = LayoutTypePortletConstants.STATIC_PORTLET_USER_SELECTOR;
    } else if (group.isOrganization()) {
      selector1 = LayoutTypePortletConstants.STATIC_PORTLET_ORGANIZATION_SELECTOR;
    } else if (group.isRegularSite()) {
      selector1 = LayoutTypePortletConstants.STATIC_PORTLET_REGULAR_SITE_SELECTOR;
    }

    String selector2 = layout.getFriendlyURL();

    String[] portletIds = PropsUtil.getArray(position, new Filter(selector1, selector2));

    for (int i = 0; i < portletIds.length; i++) {
      portletIds[i] = JS.getSafeName(portletIds[i]);
    }

    return portletIds;
  }

  protected List<Portlet> getStaticPortlets(String position) {
    String[] portletIds = getStaticPortletIds(position);

    List<Portlet> portlets = new ArrayList<>();

    for (String portletId : portletIds) {
      if (Validator.isNull(portletId) || hasNonstaticPortletId(portletId)) {

        continue;
      }

      Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), portletId);

      if (portlet != null) {
        Portlet staticPortlet = portlet;

        if (portlet.isInstanceable()) {

          // Instanceable portlets do not need to be cloned because
          // they are already cloned. See the method getPortletById in
          // the class PortletLocalServiceImpl and how it references
          // the method getClonedInstance in the class PortletImpl.

        } else {
          staticPortlet = (Portlet) staticPortlet.clone();
        }

        staticPortlet.setStatic(true);

        if (position.startsWith("layout.static.portlets.start")) {
          staticPortlet.setStaticStart(true);
        }

        portlets.add(staticPortlet);
      }
    }

    return portlets;
  }

  protected String getThemeId() {
    String themeId = null;

    try {
      Layout layout = getLayout();

      Theme theme = layout.getTheme();

      if (theme != null) {
        themeId = theme.getThemeId();
      } else {
        themeId = layout.getThemeId();
      }
    } catch (Exception e) {
      _log.error(e, e);
    }

    return themeId;
  }

  protected String getUserPreference(String key) {
    String value = StringPool.BLANK;

    if (!hasUserPreferences()) {
      return value;
    }

    value =
        _portalPreferences.getValue(CustomizedPages.namespacePlid(getPlid()), key, StringPool.NULL);

    if (!value.equals(StringPool.NULL)) {
      return value;
    }

    value = getTypeSettingsProperty(key);

    if (Validator.isNull(value)) {
      return value;
    }

    List<String> newPortletIds = new ArrayList<>();

    PermissionChecker permissionChecker = PermissionThreadLocal.getPermissionChecker();

    String[] portletIds = StringUtil.split(value);

    for (String portletId : portletIds) {
      try {
        if (!PortletPermissionUtil.contains(
            permissionChecker, getLayout(), portletId, ActionKeys.VIEW, true)) {

          continue;
        }

        String rootPortletId = PortletConstants.getRootPortletId(portletId);

        if (!PortletPermissionUtil.contains(
            permissionChecker, rootPortletId, ActionKeys.ADD_TO_PAGE)) {

          continue;
        }
      } catch (Exception e) {
        _log.error(e, e);
      }

      String newPortletId = null;

      boolean preferencesUniquePerLayout = false;

      try {
        Portlet portlet = PortletLocalServiceUtil.getPortletById(getCompanyId(), portletId);

        preferencesUniquePerLayout = portlet.isPreferencesUniquePerLayout();
      } catch (SystemException se) {
        _log.error(se, se);
      }

      if (PortletConstants.hasInstanceId(portletId) || preferencesUniquePerLayout) {

        String instanceId = null;

        if (PortletConstants.hasInstanceId(portletId)) {
          instanceId = PortletConstants.generateInstanceId();
        }

        newPortletId =
            PortletConstants.assemblePortletId(
                portletId, _portalPreferences.getUserId(), instanceId);

        copyPreferences(_portalPreferences.getUserId(), portletId, newPortletId);

        copyResourcePermissions(portletId, newPortletId);
      } else {
        newPortletId = portletId;
      }

      newPortletIds.add(newPortletId);
    }

    value = StringUtil.merge(newPortletIds);

    setUserPreference(key, value);

    return value;
  }

  protected boolean hasNonstaticPortletId(String portletId) {
    LayoutTemplate layoutTemplate = getLayoutTemplate();

    List<String> columns = layoutTemplate.getColumns();

    for (int i = 0; i < columns.size(); i++) {
      String columnId = columns.get(i);

      if (hasNonstaticPortletId(columnId, portletId)) {
        return true;
      }
    }

    return false;
  }

  protected boolean hasNonstaticPortletId(String columnId, String portletId) {
    String columnValue = getColumnValue(columnId);

    String[] columnValues = StringUtil.split(columnValue);

    for (String nonstaticPortletId : columnValues) {
      if (nonstaticPortletId.equals(portletId)
          || PortletConstants.getRootPortletId(nonstaticPortletId).equals(portletId)) {

        return true;
      }
    }

    return false;
  }

  protected boolean hasStaticPortletId(String columnId, String portletId) {
    String[] staticPortletIdsStart =
        getStaticPortletIds(PropsKeys.LAYOUT_STATIC_PORTLETS_START + columnId);

    String[] staticPortletIdsEnd =
        getStaticPortletIds(PropsKeys.LAYOUT_STATIC_PORTLETS_END + columnId);

    for (String staticPortletId : staticPortletIdsStart) {
      if (staticPortletId.equals(portletId)
          || PortletConstants.getRootPortletId(staticPortletId).equals(portletId)) {

        return true;
      }
    }

    for (String staticPortletId : staticPortletIdsEnd) {
      if (staticPortletId.equals(portletId)
          || PortletConstants.getRootPortletId(staticPortletId).equals(portletId)) {

        return true;
      }
    }

    return false;
  }

  protected boolean hasUserPreferences() {
    if (_portalPreferences != null) {
      return true;
    }

    return false;
  }

  protected boolean isLayoutSetPrototype() {
    try {
      Layout layout = getLayout();

      LayoutSet layoutSet = layout.getLayoutSet();

      Group group = layoutSet.getGroup();

      return group.isLayoutSetPrototype();
    } catch (Exception e) {
      _log.error(e, e);
    }

    return false;
  }

  protected void onRemoveFromLayout(String[] portletIds) {
    Set<String> portletIdList = new HashSet<>();

    for (String portletId : portletIds) {
      removeModesPortletId(portletId);
      removeStatesPortletId(portletId);

      portletIdList.add(portletId);

      String rootPortletId = PortletConstants.getRootPortletId(portletId);

      if (rootPortletId.equals(PortletKeys.NESTED_PORTLETS)) {
        String portletNamespace = PortalUtil.getPortletNamespace(portletId);

        UnicodeProperties typeSettingsProperties = getTypeSettingsProperties();

        for (Map.Entry<String, String> entry : typeSettingsProperties.entrySet()) {

          String key = entry.getKey();

          if (!key.startsWith(portletNamespace)) {
            continue;
          }

          String nestedPortletIds = entry.getValue();

          for (String nestedPortletId : StringUtil.split(nestedPortletIds)) {

            removeModesPortletId(nestedPortletId);
            removeStatesPortletId(nestedPortletId);

            portletIdList.add(nestedPortletId);
          }
        }

        removeNestedColumns(portletNamespace);
      }

      Portlet portlet = PortletLocalServiceUtil.getPortletById(portletId);

      if (portlet == null) {
        continue;
      }

      PortletLayoutListener portletLayoutListener = portlet.getPortletLayoutListenerInstance();

      if (portletLayoutListener == null) {
        continue;
      }

      portletLayoutListener.updatePropertiesOnRemoveFromLayout(
          portletId, getTypeSettingsProperties());
    }

    try {
      PortletLocalServiceUtil.deletePortlets(
          getCompanyId(), portletIdList.toArray(new String[portletIdList.size()]), getPlid());
    } catch (PortalException pe) {
      _log.error(pe, pe);
    }
  }

  protected void setUserPreference(String key, String value) {
    if (!hasUserPreferences()) {
      return;
    }

    _portalPreferences.setValue(CustomizedPages.namespacePlid(getPlid()), key, value);

    _portalPreferences.setValue(
        CustomizedPages.namespacePlid(getPlid()), _MODIFIED_DATE, _dateFormat.format(new Date()));
  }

  private static final String _MODIFIED_DATE = "modifiedDate";

  private static final String _NESTED_PORTLETS_NAMESPACE =
      PortalUtil.getPortletNamespace(PortletKeys.NESTED_PORTLETS);

  private static final String _NULL_DATE = "00000000000000";

  private static final Log _log = LogFactoryUtil.getLog(LayoutTypePortletImpl.class);

  private boolean _customizedView;
  private final Format _dateFormat =
      FastDateFormatFactoryUtil.getSimpleDateFormat(PropsValues.INDEX_DATE_FORMAT_PATTERN);
  private boolean _enablePortletLayoutListener = true;
  private Layout _layoutSetPrototypeLayout;
  private PortalPreferences _portalPreferences;
  private boolean _updatePermission;
}
コード例 #5
0
 protected String getServerNamespace() {
   return PortalUtil.getPortletNamespace(getServerPortletId());
 }