/*
    * Copyright (C) 2003-2008 eXo Platform SAS.
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Affero General Public License
    * as published by the Free Software Foundation; either version 3
    * of the License, or (at your option) any later version.
    *
    * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, see<http://www.gnu.org/licenses/>.
   */
  package org.exoplatform.wcm.webui;
  
  import java.io.InputStream;
  import java.security.AccessControlException;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.jcr.Node;
  import javax.jcr.NodeIterator;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.jcr.Value;
  import javax.jcr.Workspace;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.query.Query;
  import javax.jcr.query.QueryManager;
  import javax.portlet.PortletMode;
  import javax.portlet.PortletPreferences;
  
  import org.exoplatform.container.PortalContainer;
  import org.exoplatform.container.configuration.ConfigurationManager;
  import org.exoplatform.download.DownloadService;
  import org.exoplatform.download.InputStreamDownloadResource;
  
  import org.exoplatform.ecm.utils.text.Text;
  import org.exoplatform.ecm.utils.lock.LockUtil;
  import org.exoplatform.portal.application.PortalRequestContext;
  import org.exoplatform.portal.config.UserACL;
  import org.exoplatform.portal.config.UserPortalConfigService;
  import org.exoplatform.portal.config.model.PortalConfig;
  import org.exoplatform.portal.mop.SiteType;
  import org.exoplatform.portal.mop.page.PageContext;
  import org.exoplatform.portal.mop.page.PageKey;
  import org.exoplatform.portal.mop.SiteKey;
  import org.exoplatform.portal.mop.user.UserNavigation;
  import org.exoplatform.portal.mop.user.UserNode;
  import org.exoplatform.portal.mop.user.UserPortal;
  import org.exoplatform.portal.webui.page.UIPage;
  import org.exoplatform.portal.webui.page.UIPageBody;
  import org.exoplatform.portal.webui.portal.UIPortal;
  import org.exoplatform.portal.webui.util.Util;
  import org.exoplatform.portal.webui.workspace.UIMaskWorkspace;
  import org.exoplatform.portal.webui.workspace.UIPortalApplication;
  import org.exoplatform.portal.webui.workspace.UIWorkingWorkspace;
  import org.exoplatform.services.cms.drives.DriveData;
  import org.exoplatform.services.cms.drives.ManageDriveService;
  import org.exoplatform.services.cms.link.LinkManager;
  import org.exoplatform.services.cms.mimetype.DMSMimeTypeResolver;
  import org.exoplatform.services.jcr.RepositoryService;
  import org.exoplatform.services.jcr.access.PermissionType;
  import org.exoplatform.services.jcr.core.ExtendedNode;
  import org.exoplatform.services.log.ExoLogger;
  import org.exoplatform.services.log.Log;
  import org.exoplatform.services.security.Identity;
  import org.exoplatform.services.security.IdentityRegistry;
  import org.exoplatform.services.security.MembershipEntry;
  import org.exoplatform.services.wcm.core.NodeLocation;
  import org.exoplatform.services.wcm.core.WCMConfigurationService;
  import org.exoplatform.services.wcm.navigation.NavigationUtils;
  import org.exoplatform.services.wcm.publication.PublicationDefaultStates;
  import org.exoplatform.services.wcm.publication.WCMComposer;
  import org.exoplatform.services.wcm.publication.WCMPublicationService;
  import org.exoplatform.services.wcm.utils.WCMCoreUtils;
  import org.exoplatform.wcm.webui.core.UIPopupWindow;
  import org.exoplatform.web.application.ApplicationMessage;
  import org.exoplatform.web.application.RequestContext;
  import org.exoplatform.web.url.navigation.NavigationResource;
  import org.exoplatform.web.url.navigation.NodeURL;
  import org.exoplatform.webui.application.WebuiRequestContext;
  import org.exoplatform.webui.application.portlet.PortletRequestContext;
  import org.exoplatform.webui.core.UIApplication;
  import org.exoplatform.webui.core.UIComponent;
  import org.exoplatform.webui.core.UIContainer;
  import org.exoplatform.webui.core.UIPopupContainer;
  import org.exoplatform.webui.core.UIPortletApplication;
  import com.ibm.icu.text.Transliterator;
  
  /**
   * Created by The eXo Platform SAS Author : Hoa Pham hoa.phamvu@exoplatform.com
   * Oct 23, 2008
  */
 public class Utils {
 
   /** The Quick edit attribute for HTTPSession */
   public static final String TURN_ON_QUICK_EDIT = "turnOnQuickEdit";
 
   private static final Log LOG = ExoLogger.getExoLogger(Utils.class);
 
   private static final String SQL_PARAM_PATTERN = "\\$\\{([^\\$\\{\\}])+\\}";
   
   private static final String JCR_CONTENT = "jcr:content";
 
   private static final String JCR_DATA = "jcr:data";
 
   private static final String JCR_MIMETYPE = "jcr:mimeType";  
 
   private static final String NT_FILE = "nt:file";
 
   private static final String NT_UNSTRUCTURED = "nt:unstructured";
   
   private static final String DOCUMENTS_ACTIVITY = "documents";
 
   /**
    * Checks if is edits the portlet in create page wizard.
    * @return true, if is edits the portlet in create page wizard
    */
   public static boolean isEditPortletInCreatePageWizard() {
     UIPortalApplication portalApplication = Util.getUIPortalApplication();
     UIMaskWorkspace uiMaskWS = portalApplication.getChildById(UIPortalApplication.UI_MASK_WS_ID);
     // show maskworkpace is being in Portal page edit mode
     if (uiMaskWS.getWindowWidth() > 0 && uiMaskWS.getWindowHeight() < 0)
       return true;
     return false;
   }
 
   /**
    * Checks if is quick editmode.
    *
    * @param container the current container
    * @param popupWindowId the popup window id
    *
    * @return true, if is quick editmode
    */
   public static boolean isQuickEditMode(UIContainer container, String popupWindowId) {
     UIPopupContainer popupContainer = getPopupContainer(container);
     if (popupContainer == null)
       return false;
     UIPopupWindow popupWindow = popupContainer.getChildById(popupWindowId);
     if (popupWindow == null)
       return false;
     return true;
   }
 
   /**
    * Check if the portlet current mode is view mode or not
    * @param pContext The request context of a portlet
    *
    * @return return true if current portlet mode is view mode; otherwise return false
    */
   public static boolean isPortletViewMode(PortletRequestContext pContext) {
     return PortletMode.VIEW.equals(pContext.getApplicationMode());
   }
 
   public static boolean isPortalEditMode() {
     return Util.getUIPortalApplication().getModeState() != UIPortalApplication.NORMAL_MODE;
   }
 
   public static String getRealPortletId(PortletRequestContext portletRequestContext) {
     String portletId = portletRequestContext.getWindowId();
     int modeState = Util.getUIPortalApplication().getModeState();
     switch (modeState) {
     case UIPortalApplication.NORMAL_MODE:
       return portletId;
     case UIPortalApplication.APP_BLOCK_EDIT_MODE:
       return "UIPortlet-" + portletId;
     case UIPortalApplication.APP_VIEW_EDIT_MODE:
       return "EditMode-" + portletId;
     default:
       return null;
     }
   }
 
   /**
    * Can edit current portal.
    *
    * @param remoteUser the remote user
    * @return true, if successful
    * @throws Exception the exception
    */
   public static boolean canEditCurrentPortal(String remoteUser) throws Exception {
     if (remoteUser == null)
       return false;
     IdentityRegistry identityRegistry = Util.getUIPortalApplication()
                                             .getApplicationComponent(IdentityRegistry.class);
     Identity identity = identityRegistry.getIdentity(remoteUser);
     if (identity == null)
       return false;
     UIPortal uiPortal = Util.getUIPortal();
     // this code only work for single edit permission
     String editPermission = uiPortal.getEditPermission();
     MembershipEntry membershipEntry = MembershipEntry.parse(editPermission);
     return identity.isMemberOf(membershipEntry);
   }
 
   /**
    * Clean string.
    *
    * @param str the str
    * @return the string
    */
   public static String cleanString(String str) {
     Transliterator accentsconverter = Transliterator.getInstance("Latin; NFD; [:Nonspacing Mark:] Remove; NFC;");
     str = accentsconverter.transliterate(str);
     // the character ? seems to not be changed to d by the transliterate
     // function
     StringBuffer cleanedStr = new StringBuffer(str.trim());
     // delete special character
     for (int i = 0; i < cleanedStr.length(); i++) {
       char c = cleanedStr.charAt(i);
       if (c == ' ') {
         if (i > 0 && cleanedStr.charAt(i - 1) == '-') {
           cleanedStr.deleteCharAt(i--);
         } else {
           c = '-';
           cleanedStr.setCharAt(i, c);
         }
         continue;
       }
       if (i > 0 && !(Character.isLetterOrDigit(c) || c == '-')) {
         cleanedStr.deleteCharAt(i--);
         continue;
       }
       if (i > 0 && c == '-' && cleanedStr.charAt(i - 1) == '-')
         cleanedStr.deleteCharAt(i--);
     }
     return cleanedStr.toString().toLowerCase();
   }
 
   /**
    * Refresh whole portal by AJAX.
    *
    * @param context the portlet request context
    */
   public static void updatePortal(PortletRequestContext context) {
     UIPortalApplication portalApplication = Util.getUIPortalApplication();
     PortalRequestContext portalRequestContext = (PortalRequestContext) context.getParentAppRequestContext();
     UIWorkingWorkspace uiWorkingWS = portalApplication.getChildById(UIPortalApplication.UI_WORKING_WS_ID);
     portalRequestContext.addUIComponentToUpdateByAjax(uiWorkingWS);
     portalRequestContext.ignoreAJAXUpdateOnPortlets(true);
   }
 
   /**
    * Gets the viewable node by WCMComposer (depends on site mode)
    *
    * @param repository the repository's name
    * @param workspace the workspace's name
    * @param nodeIdentifier the node's path or node's UUID
    * @return the viewable node. Return <code>null</code> if
    *         <code>nodeIdentifier</code> is invalid
    * @see #getViewableNodeByComposer(String repository, String workspace, String
    *      nodeIdentifier, String version) getViewableNodeByComposer()
    */
   public static Node getViewableNodeByComposer(String repository,
                                                String workspace,
                                                String nodeIdentifier) {
     return getViewableNodeByComposer(repository, workspace, nodeIdentifier, null);
   }
 
   /**
    * Gets the viewable node by WCMComposer (depends on site mode)
    *
    * @param repository the repository's name
    * @param workspace the workspace's name
    * @param nodeIdentifier the node's path or node's UUID
    * @param version the base version (e.g. <code>WCMComposer.BASE_VERSION</code>
    *          )
    * @return the viewable node. Return <code>null</code> if
    *         <code>nodeIdentifier</code> is invalid
    * @see #getViewableNodeByComposer(String repository, String workspace, String
    *      nodeIdentifier) getViewableNodeByComposer()
    * @see WCMComposer
    */
   public static Node getViewableNodeByComposer(String repository,
                                                String workspace,
                                                String nodeIdentifier,
                                                String version) {
     return getViewableNodeByComposer(repository, workspace, nodeIdentifier, version, WCMComposer.VISIBILITY_USER);
   }
 
   /**
    * Gets the viewable node by WCMComposer (depends on site mode)
    *
    * @param repository the repository's name
    * @param workspace the workspace's name
    * @param nodeIdentifier the node's path or node's UUID
    * @param version the base version (e.g. <code>WCMComposer.BASE_VERSION</code>
    *          )
    * @param cacheVisibility the visibility of cache
    *
    * @return the viewable node. Return <code>null</code> if
    *         <code>nodeIdentifier</code> is invalid
    * @see #getViewableNodeByComposer(String repository, String workspace, String
    *      nodeIdentifier) getViewableNodeByComposer()
    * @see WCMComposer
    */
   public static Node getViewableNodeByComposer(String repository,
                                                String workspace,
                                                String nodeIdentifier,
                                                String version,
                                                String cacheVisibility) {
     try {
       HashMap<String, String> filters = new HashMap<String, String>();
       StringBuffer filterLang = new StringBuffer(Util.getPortalRequestContext()
                                                      .getLocale()
                                                      .getLanguage());
       String country = Util.getPortalRequestContext().getLocale().getCountry();
       if (country != null && country.length() > 0) {
         filterLang.append("_").append(country);
       }
       filters.put(WCMComposer.FILTER_LANGUAGE, filterLang.toString());
       filters.put(WCMComposer.FILTER_MODE, Utils.getCurrentMode());
       PortletRequestContext portletRequestContext = WebuiRequestContext.getCurrentInstance();
       PortletMode portletMode = portletRequestContext.getApplicationMode();
       filters.put(WCMComposer.PORTLET_MODE, portletMode.toString());
       if (version != null)
         filters.put(WCMComposer.FILTER_VERSION, version);
       filters.put(WCMComposer.FILTER_VISIBILITY, cacheVisibility);
       return WCMCoreUtils.getService(WCMComposer.class)
                          .getContent(workspace,
                                  Text.escapeIllegalJcrChars(nodeIdentifier),
                                      filters,
                                      WCMCoreUtils.getUserSessionProvider());
     } catch (Exception e) {
       return null;
     }
   }
 
   /**
    * Gets the current mode of the site
    *
    * @return the current mode (e.g. <code>WCMComposer.MODE_EDIT</code>)
    * @see WCMComposer
    */
   public static String getCurrentMode() {
     Object isQuickEditable = Util.getPortalRequestContext()
                                  .getRequest()
                                  .getSession()
                                  .getAttribute(TURN_ON_QUICK_EDIT);
     if (isQuickEditable == null)
       return WCMComposer.MODE_LIVE;
     boolean turnOnQuickEdit = Boolean.parseBoolean(isQuickEditable.toString());
     return turnOnQuickEdit ? WCMComposer.MODE_EDIT : WCMComposer.MODE_LIVE;
   }
 
   /**
    * Check if the current mode is live mode or not
    *
    * @return return true if current mode is WCMComposer.MODE_LIVE; otherwise
    *         false.
    */
   public static boolean isLiveMode() {
     return WCMComposer.MODE_LIVE.equals(getCurrentMode());
   }
 
   /**
    * Check if the content is draft and current mode of the site is edit mode
    *
    * @param content the content node.
    * @return true, the content is draft and current mode is edit mode, otherwise
    *         return false.
    */
   public static boolean isShowDraft(Node content) {
     if (content == null)
       return false;
     try {
       if (content.isNodeType("nt:frozenNode"))
         return false;
       WCMPublicationService wcmPublicationService = WCMCoreUtils.getService(WCMPublicationService.class);
       String contentState = wcmPublicationService.getContentState(content);
       boolean isDraftContent = false;
       if (PublicationDefaultStates.DRAFT.equals(contentState))
         isDraftContent = true;
       boolean isShowDraft = false;
       if (WCMComposer.MODE_EDIT.equals(getCurrentMode()))
         isShowDraft = true;
       return isDraftContent && isShowDraft;
     } catch (Exception e) {
       return false;
     }
   }
 
   /**
    * Check if the current mode of the site is edit mode
    *
    * @return true, if current mode is edit mode
    */
   public static boolean isShowQuickEdit() {
     try {
       boolean isEditMode = false;
       if (WCMComposer.MODE_EDIT.equals(getCurrentMode()))
         isEditMode = true;
       return isEditMode;
     } catch (Exception e) {
       return false;
     }
   }
 
   /**
    * Check if the user can delete the current node
    *
    * @return true, if current mode is edit mode
    * @throws RepositoryException
    * @throws AccessControlException
    */
   public static boolean isShowDelete(Node content) throws RepositoryException {
     boolean isEditMode = false;
     if (WCMComposer.MODE_EDIT.equals(getCurrentMode())) isEditMode = true;
     try {
       ((ExtendedNode) content).checkPermission(PermissionType.SET_PROPERTY);
       ((ExtendedNode) content).checkPermission(PermissionType.ADD_NODE);
       ((ExtendedNode) content).checkPermission(PermissionType.REMOVE);
     } catch (AccessControlException e) {
       isEditMode = false;
     } catch (Exception e) {
       String nodePath = null;
       try {
         nodePath = content.getPath();
       } catch (Exception e1) {
         // Nothing to log
       }
       LOG.error("Error while checking permissions on node " + nodePath, e);
       isEditMode = false;
     }
     return isEditMode;
   }
 
   /**
    * Check if the content is editable and current mode of the site is edit mode
    *
    * @param content the content node
    * @return true if there is no content if the content is editable and current
    *         mode is edit mode
    */
   public static boolean isShowQuickEdit(Node content) {
     if (content == null)
       return true;
     try {
       boolean isEditMode = false;
       if (WCMComposer.MODE_EDIT.equals(getCurrentMode())
           || Util.getUIPortalApplication().getModeState() != UIPortalApplication.NORMAL_MODE)
         isEditMode = true;
       ((ExtendedNode) content).checkPermission(PermissionType.SET_PROPERTY);
       ((ExtendedNode) content).checkPermission(PermissionType.ADD_NODE);
       ((ExtendedNode) content).checkPermission(PermissionType.REMOVE);
       return isEditMode;
     } catch (Exception e) {
       return false;
     }
   }
 
   public static String getEditLink(Node node, boolean isEditable, boolean isNew) {
     try {
       ManageDriveService manageDriveService = WCMCoreUtils.getService(ManageDriveService.class);
       String nodeWorkspace = node.getSession().getWorkspace().getName();
       String driveWorkspace = nodeWorkspace;
       List<DriveData> listDrive = manageDriveService.getAllDrives();
       for(DriveData drive : listDrive) {
         if(drive.getWorkspace().equals(nodeWorkspace) && node.getPath().startsWith(drive.getHomePath())) {
           driveWorkspace = drive.getName();
           break;
         }
       }
       String itemPath = driveWorkspace + node.getPath();
       return getEditLink(itemPath, isEditable, isNew);
     } catch (RepositoryException re) {
       return null;
     } catch(Exception e) {
       return null;
     }
   }
   
   public static String getActivityEditLink(Node node) {
     try {
       String itemPath = node.getSession().getWorkspace().getName() + node.getPath();
       return getActivityEditLink(itemPath);
     } catch (RepositoryException e) {
       return null;
     }
   }
 
   /**
    * Creates a restfull compliant link to the editor for editing a content,
    * adding a content or managing contents. Example : Add Content : isEditable =
    * false, isNew = true, itemPath = the parent folder path Edit Content :
    * isEditable = true, isNew = false, itemPath = the content path Manage
    * Contents = isEditable = false, isNew = false, itemPath = the folder path
    *
    * @param itemPath
    * @param isEditable
    * @param isNew
    * @return
    */
   public static String getEditLink(String itemPath, boolean isEditable, boolean isNew) {
     PortalRequestContext pContext = Util.getPortalRequestContext();
     String backto = pContext.getRequestURI();
     WCMConfigurationService configurationService = Util.getUIPortalApplication()
                                                        .getApplicationComponent(WCMConfigurationService.class);
     String editorPageURI = configurationService.getRuntimeContextParam(
                                isEditable || isNew ? WCMConfigurationService.EDITOR_PAGE_URI :
                                                      WCMConfigurationService.SITE_EXPLORER_URI);
     UserNode editorNode = getEditorNode(editorPageURI);
 
     if (editorNode == null) {
       return "";
     }
 
     NodeURL nodeURL = pContext.createURL(NodeURL.TYPE);
     nodeURL.setNode(editorNode).setQueryParameterValue("path", itemPath);
     if (isEditable) {
       nodeURL.setQueryParameterValue("edit", "true");
     }
     if (isNew) {
       nodeURL.setQueryParameterValue("addNew", "true");
     }
     nodeURL.setQueryParameterValue(org.exoplatform.ecm.webui.utils.Utils.URL_BACKTO, backto);
 
     return nodeURL.toString();
   }
   
   public static String getActivityEditLink(String itemPath) {
     PortalRequestContext pContext = Util.getPortalRequestContext();    
     String siteType = pContext.getSiteKey().getType().getName();
     String backto = pContext.getRequestURI();
     WCMConfigurationService configurationService = Util.getUIPortalApplication()
     		.getApplicationComponent(WCMConfigurationService.class);
     
     String editorPageURI = null;
     if(siteType.equals(PortalConfig.PORTAL_TYPE))
       editorPageURI = configurationService.getRuntimeContextParam(WCMConfigurationService.EDIT_PAGE_URI);
     else if(siteType.equals(PortalConfig.GROUP_TYPE)) {
       StringBuffer sb = new StringBuffer();      
     	editorPageURI = pContext.getSiteName();
     	editorPageURI = editorPageURI.substring(editorPageURI.lastIndexOf("/")+1, editorPageURI.length());
     	sb.append(editorPageURI).append("/").append(DOCUMENTS_ACTIVITY);
     	editorPageURI = sb.toString();
     }
     UserNode editorNode = getEditorNode(editorPageURI, siteType);
 
     if (editorNode == null) {
       return "";
     }
 
     NodeURL nodeURL = pContext.createURL(NodeURL.TYPE);
     nodeURL.setNode(editorNode);
     nodeURL.setQueryParameterValue("path", itemPath);
     nodeURL.setQueryParameterValue("edit", "true");   
     nodeURL.setQueryParameterValue(org.exoplatform.ecm.webui.utils.Utils.URL_BACKTO, backto);
 
     return nodeURL.toString();
   }
   
   private static UserNode getEditorNode(String editorPageURI, String siteType) {
     UserPortal userPortal = Util.getPortalRequestContext().getUserPortalConfig().getUserPortal();
     List<UserNavigation> allNavs = userPortal.getNavigations();
 
     for (UserNavigation nav : allNavs) {
       if (nav.getKey().getType().getName().equalsIgnoreCase(siteType)) {
         UserNode userNode = userPortal.resolvePath(nav, null, editorPageURI);
         if (userNode != null) {
           return userNode;
         }
       }
     }
     return null;
   }
 
   private static UserNode getEditorNode(String editorPageURI) {
     UserPortal userPortal = Util.getPortalRequestContext().getUserPortalConfig().getUserPortal();
     List<UserNavigation> allNavs = userPortal.getNavigations();
 
     for (UserNavigation nav : allNavs) {
       if (nav.getKey().getType().equals(SiteType.GROUP)) {
         UserNode userNode = userPortal.resolvePath(nav, null, editorPageURI);
         if (userNode != null) {
           return userNode;
         }
       }
     }
     return null;
   }
 
   /**
    * Creates the popup window. Each portlet have a <code>UIPopupContainer</code>
    * . <br>
    * Every <code>UIPopupWindow</code> created by this method is belong to this
    * container.
    *
    * @param container the current container
    * @param component the component which will be display as a popup
    * @param popupWindowId the popup's ID
    * @param width the width of the popup
    * @throws Exception the exception
    */
   public static void createPopupWindow(UIContainer container,
                                        UIComponent component,
                                        String popupWindowId,
                                        int width) throws Exception {
     UIPopupContainer popupContainer = initPopup(container, component, popupWindowId, width);
     WebuiRequestContext requestContext = WebuiRequestContext.getCurrentInstance();
     requestContext.addUIComponentToUpdateByAjax(popupContainer);
   }
 
   /**
    * Creates the popup window. Each portlet have a <code>UIPopupContainer</code>
    * . <br>
    * Every <code>UIPopupWindow</code> created by this method is belong to this
    * container.
    *
    * @param container the current container
    * @param component the component which will be display as a popup
    * @param popupWindowId the popup's ID
    * @param width the width of the popup
    * @param isShowMask Set as true to create mask layer
    * @throws Exception the exception
    */
   public static void createPopupWindow(UIContainer container,
                                        UIComponent component,
                                        String popupWindowId,
                                        int width, boolean isShowMask) throws Exception {
     UIPopupContainer popupContainer = initPopup(container, component, popupWindowId, width);
     UIPopupWindow popupWindow = popupContainer.getChildById(popupWindowId);
     popupWindow.setShowMask(isShowMask);
     WebuiRequestContext requestContext = WebuiRequestContext.getCurrentInstance();
     requestContext.addUIComponentToUpdateByAjax(popupContainer);
   }
 
   /**
    * Creates the popup window. Each portlet have a <code>UIPopupContainer</code>
    * . <br>
    * Every <code>UIPopupWindow</code> created by this method is belong to this
    * container.
    *
    * @param container the current container
    * @param component the component which will be display as a popup
    * @param popupWindowId the popup's ID
    * @param width the width of the popup
    * @param top the top of the popup
    * @param left the left of the popup
    * @throws Exception the exception
    */
   public static void createPopupWindow(UIContainer container,
       UIComponent component,
       String popupWindowId,
       int width, int top, int left) throws Exception {
     UIPopupContainer popupContainer = initPopup(container, component, popupWindowId, width);
     UIPopupWindow popupWindow = popupContainer.getChildById(popupWindowId);
     popupWindow.setCoordindate(top, left);
     WebuiRequestContext requestContext = WebuiRequestContext.getCurrentInstance();
     requestContext.addUIComponentToUpdateByAjax(popupContainer);
   }
   
   public static void createPopupWindow(UIContainer container,
                                        UIComponent component,
                                        String popupWindowId,
                                        boolean isMiddle,
                                        int width) throws Exception {
     UIPopupContainer popupContainer = initPopup(container, component, popupWindowId, width);
     UIPopupWindow popupWindow = popupContainer.getChildById(popupWindowId);
     popupWindow.setMiddle(isMiddle);
     WebuiRequestContext requestContext = WebuiRequestContext.getCurrentInstance();
     requestContext.addUIComponentToUpdateByAjax(popupContainer);
   }
 
   private static UIPopupContainer initPopup(UIContainer container,
       UIComponent component,
       String popupWindowId,
       int width) throws Exception {
     UIPopupContainer popupContainer = getPopupContainer(container);
     popupContainer.removeChildById(popupWindowId);
     popupContainer.removeChildById("UIPopupWindow");
     UIPopupWindow popupWindow = popupContainer.addChild(UIPopupWindow.class, null, popupWindowId);
     popupWindow.setUIComponent(component);
     popupWindow.setWindowSize(width, 0);
     popupWindow.setShow(true);
     popupWindow.setRendered(true);
     popupWindow.setResizable(true);
     popupWindow.setShowMask(true);
     return popupContainer;
   }
 
 
   /**
    * Close popup window.
    *
    * @param container the current container
    * @param popupWindowId the popup's ID
    */
   public static void closePopupWindow(UIContainer container, String popupWindowId) {
     UIPopupContainer popupContainer = getPopupContainer(container);
     popupContainer.removeChildById(popupWindowId);
   }
 
   /**
    * Update popup window.
    *
    * @param container the container
    * @param component the component which will be replace for the old one in the
    *          same popup
    * @param popupWindowId the popup's ID
    */
   public static void updatePopupWindow(UIContainer container,
                                        UIComponent component,
                                        String popupWindowId) {
     UIPopupContainer popupContainer = getPopupContainer(container);
     UIPopupWindow popupWindow = popupContainer.getChildById(popupWindowId);
     popupWindow.setUIComponent(component);
   }
 
   /**
    * Gets the popup container.
    *
    * @param container the current container
    * @return the popup container
    */
   public static UIPopupContainer getPopupContainer(UIContainer container) {
     if (container instanceof UIPortletApplication)
       return container.getChild(UIPopupContainer.class);
     UIPortletApplication portletApplication = container.getAncestorOfType(UIPortletApplication.class);
     return portletApplication.getChild(UIPopupContainer.class);
   }
 
   /**
    * Creates the popup message.
    *
    * @param container the current container
    * @param message the message key
    * @param args the arguments to show in the message
    * @param type the message's type (e.g. <code>ApplicationMessage.INFO</code>)
    * @see ApplicationMessage
    */
   public static void createPopupMessage(UIContainer container,
                                         String message,
                                         Object[] args,
                                         int type) {
     UIApplication application = container.getAncestorOfType(UIApplication.class);
     application.addMessage(new ApplicationMessage(message, args, type));
   }
 
   /**
    * Get one portlet preference by name
    *
    * @param preferenceName the name of preference
    * @return the portlet preference's value
    */
   public static String getPortletPreference(String preferenceName) {
     PortletRequestContext portletRequestContext = WebuiRequestContext.getCurrentInstance();
     PortletPreferences preferences = portletRequestContext.getRequest().getPreferences();
     return preferences.getValue(preferenceName, null);
   }
 
   /**
    * Get all portlet preferences
    *
    * @return all portlet preferences
    */
   public static PortletPreferences getAllPortletPreferences() {
     PortletRequestContext portletRequestContext = WebuiRequestContext.getCurrentInstance();
     return portletRequestContext.getRequest().getPreferences();
   }
 
   /**
    * Check if the node is viewable for the current user or not viewable. <br>
    * return True if the node is viewable, otherwise will return False
    *
    * @param node: The node to check
    */
   public static boolean isViewable(Node node) {
     try {
       node.refresh(true);
       ((ExtendedNode) node).checkPermission(PermissionType.READ);
     } catch (Exception e) {
       return false;
     }
     return true;
   }
 
   /**
    * Get the real node from frozen node, symlink node return True if the node is
    * viewable, otherwise will return False
    *
    * @param node: The node to check
    */
   public static Node getRealNode(Node node) throws Exception {
     // TODO: Need to add to check symlink node
     if (node.isNodeType("nt:frozenNode")) {
       String uuid = node.getProperty("jcr:frozenUuid").getString();
       return node.getSession().getNodeByUUID(uuid);
     }
     return node;
   }
 
   public static String getRealNodePath(Node node) throws Exception {
     if (node.isNodeType("nt:frozenNode")) {
       Node realNode = getRealNode(node);
       return Text.escape(realNode.getPath(),'%',true) + "?version=" + node.getParent().getName();
     }
     return Text.escape(node.getPath(),'%',true);
   }
 
   public static String getWebdavURL(Node node) throws Exception {
     return getWebdavURL(node, true);
   }
 
   public static String getWebdavURL(Node node, boolean withTimeParam) throws Exception {
     return getWebdavURL(node, withTimeParam, true);
   }
 
   public static String getWebdavURL(Node node, boolean withTimeParam, boolean isGetRealNodePath) throws Exception {
     NodeLocation location = NodeLocation.getNodeLocationByNode(getRealNode(node));
     String repository = location.getRepository();
     String workspace = location.getWorkspace();
     String currentProtal = PortalContainer.getCurrentRestContextName();
     String portalName = PortalContainer.getCurrentPortalContainerName();
 
     String originalNodePath = isGetRealNodePath ? getRealNodePath(node) : Text.escape(node.getPath(),'%',true);
     StringBuffer imagePath = new StringBuffer();
     imagePath.append("/")
              .append(portalName)
              .append("/")
              .append(currentProtal)
              .append("/jcr/")
              .append(repository)
              .append("/")
              .append(workspace)
              .append(originalNodePath);
     if (withTimeParam) {
       if (imagePath.indexOf("?") > 0) {
         imagePath.append("&time=");
       } else {
         imagePath.append("?time=");
       }
       imagePath.append(System.currentTimeMillis());
     }
     return imagePath.toString();
   }
 
   /**
    * GetRealNode
    *
    * @param strRepository
    * @param strWorkspace
    * @param strIdentifier
    * @return the required node/ the target of a symlink node / null if node was
    *         in trash.
    * @throws RepositoryException
    */
   public static Node getRealNode(String strRepository,
                                  String strWorkspace,
                                  String strIdentifier,
                                  boolean isWCMBase) throws RepositoryException {
     return getRealNode(strRepository, strWorkspace, strIdentifier, isWCMBase, WCMComposer.VISIBILITY_USER);
   }
 
   /**
    * GetRealNode
    *
    * @param strRepository
    * @param strWorkspace
    * @param strIdentifier
    * @param cacheVisibility the visibility of cache
    *
    * @return the required node/ the target of a symlink node / null if node was
    *         in trash.
    * @throws RepositoryException
    */
   public static Node getRealNode(String strRepository,
                                  String strWorkspace,
                                  String strIdentifier,
                                  boolean isWCMBase,
                                  String cacheVisibility) throws RepositoryException {
     LinkManager linkManager = WCMCoreUtils.getService(LinkManager.class);
     Node selectedNode;
     if (isWCMBase) {
       selectedNode = getViewableNodeByComposer(strRepository,
                                                strWorkspace,
                                                strIdentifier,
                                                WCMComposer.BASE_VERSION,
                                                cacheVisibility);
     } else {
       selectedNode = getViewableNodeByComposer(strRepository, strWorkspace, strIdentifier, null, cacheVisibility);
     }
     if (selectedNode != null) {
       if (!org.exoplatform.ecm.webui.utils.Utils.isInTrash(selectedNode)) {
         if (linkManager.isLink(selectedNode)) {
           if (linkManager.isTargetReachable(selectedNode)) {
             selectedNode = linkManager.getTarget(selectedNode);
             if (!org.exoplatform.ecm.webui.utils.Utils.isInTrash(selectedNode)) {
               return selectedNode;
             }
           }
         } else {
           return selectedNode;
         }
       }
     }
     return null;
   }
 
   public static boolean hasEditPermissionOnPage() throws Exception {
     UIPortalApplication portalApp = Util.getUIPortalApplication();
     UIWorkingWorkspace uiWorkingWS = portalApp.getChildById(UIPortalApplication.UI_WORKING_WS_ID);
     UIPageBody pageBody = uiWorkingWS.findFirstComponentOfType(UIPageBody.class);
     UIPage uiPage = (UIPage) pageBody.getUIComponent();
     UserACL userACL = portalApp.getApplicationComponent(UserACL.class);
 
     if (uiPage != null) {
       return userACL.hasEditPermissionOnPage(uiPage.getOwnerType(),
                                              uiPage.getOwnerId(),
                                              uiPage.getEditPermission());
     }
     UIPortal currentUIPortal = portalApp.<UIWorkingWorkspace> findComponentById(UIPortalApplication.UI_WORKING_WS_ID)
     .findFirstComponentOfType(UIPortal.class);
     UserNode currentNode = currentUIPortal.getSelectedUserNode();
     PageKey pageReference = currentNode.getPageRef();
     if (pageReference == null) {
       return false;
     }
     UserPortalConfigService portalConfigService = portalApp.getApplicationComponent(UserPortalConfigService.class);
     PageContext page = portalConfigService.getPage(pageReference);
     if (page == null) {
       return false;
     }
     return userACL.hasEditPermission(page);
   }
 
   public static boolean hasEditPermissionOnNavigation() throws Exception {
     UserNavigation selectedNavigation = getSelectedNavigation();
     if(selectedNavigation == null) return false;
     return selectedNavigation.isModifiable();
   }
 
   public static boolean hasEditPermissionOnPortal() throws Exception {
     UIPortalApplication portalApp = Util.getUIPortalApplication();
     UIPortal currentUIPortal = portalApp.<UIWorkingWorkspace> findComponentById(UIPortalApplication.UI_WORKING_WS_ID)
                                         .findFirstComponentOfType(UIPortal.class);
     UserACL userACL = portalApp.getApplicationComponent(UserACL.class);
     return userACL.hasEditPermissionOnPortal(currentUIPortal.getSiteKey().getTypeName(),
                                              currentUIPortal.getSiteKey().getName(),
                                              currentUIPortal.getEditPermission());
   }
 
   public static UserNavigation getSelectedNavigation() throws Exception { 
     SiteKey siteKey = Util.getUIPortal().getSiteKey();
     return NavigationUtils.getUserNavigation(
           Util.getPortalRequestContext().getUserPortalConfig().getUserPortal(),
           siteKey);
   }
 
   public static boolean isEmptyContent(String inputValue) {
     boolean isEmpty = true;
     inputValue = inputValue.trim().replaceAll("<p>", "").replaceAll("</p>", "");
     inputValue = inputValue.replaceAll("\n", "").replaceAll("\t","");
     inputValue = inputValue.replaceAll("&nbsp;", "");
     if(inputValue != null && inputValue.length() > 0) return false;
     return isEmpty;
   }
 
   /**
    * @param workspace
    * @param strQuery
    * @param SQLLanguage
    * @return true as valid query, false as Invalid
    */
   public static boolean checkQuery(String workspace, String strQuery, String SQLLanguage) {
     try {
       Session session = WCMCoreUtils.getUserSessionProvider().getSession(workspace,
             WCMCoreUtils.getService(RepositoryService.class).getCurrentRepository());
       QueryManager qm = session.getWorkspace().getQueryManager();
       Query query = qm.createQuery(strQuery, SQLLanguage);
       query.execute();
     }catch(Exception e) {
       return false;
     }
     return true;
   }
 
   /**
    * get the parameter list from SQL query, the parameter have the ${PARAM} format. <br>
    * For example:
    * <ul>
    *   <li>${folder-id}</li>
    *   <li>${user}</li>
    *   <li>${lang}</li>
    * </ul>
    * @param sqlQuery the given input SQL query
    * @return a list of parameter in input SQL query
    */
   public static HashSet<String> getQueryParams(String sqlQuery) {
     HashSet<String> params = new HashSet<String>();
     if (sqlQuery == null) {
       return params;
     }
     Matcher matcher = Pattern.compile(SQL_PARAM_PATTERN).matcher(sqlQuery);
     while (matcher.find()) {
       String param = matcher.group();
       param = param.replaceAll("\\$\\{", "").replaceAll("\\}", "");
       params.add(param);
     }
     return params;
   }
 
   /**
    * Replace the parameter with the relevant value from <code>params</code>to
    * build the SQL query
    *
    * @param sqlQuery the input query that contain parameter
    * @param params list of all parameter(key, value) pass to the query
    * @return SQL query after replacing the parameter with value
    */
   public static String buildQuery(String sqlQuery, HashMap<String, String> params) {
     if (!hasParam(sqlQuery) || params == null || params.isEmpty()) {
       return sqlQuery;
     }
     String query = sqlQuery;
     for (String param : params.keySet()) {
       query = query.replaceAll("\\$\\{" + param + "\\}", params.get(param));
     }
     return query;
   }
 
   /**
    * Check if the input SQL query contains any parameter or not.
    *
    * @param sqlQuery
    * @return <code>false</code> if input SQL query does not contain any
    *         parameter <br>
    *         <code>true</code> if input SQL query one or more parameter
    */
   public static boolean hasParam(String sqlQuery) {
     if (sqlQuery == null || sqlQuery.trim().length() == 0) {
       return false;
     }
     if (Pattern.compile(SQL_PARAM_PATTERN).matcher(sqlQuery).find()) {
       return true;
     }
     return false;
   }
 
   /**
    * Get download link of a node which stored binary data
    * @param node Node
    * @return download link
    * @throws Exception
    */
   public static String getDownloadLink(Node node) throws Exception {
 
     if (!Utils.getRealNode(node).isNodeType(NT_FILE)) return null;
 
     // Get binary data from node
     DownloadService dservice = WCMCoreUtils.getService(DownloadService.class);
     Node jcrContentNode = node.getNode(JCR_CONTENT);
     InputStream input = jcrContentNode.getProperty(JCR_DATA).getStream();
 
     // Get mimeType of binary data
     String mimeType = jcrContentNode.getProperty(JCR_MIMETYPE).getString() ;
 
     // Make download stream
     InputStreamDownloadResource dresource = new InputStreamDownloadResource(input, mimeType);
 
     // Make extension part for file if it have not yet
     DMSMimeTypeResolver mimeTypeSolver = DMSMimeTypeResolver.getInstance();
     String ext = "." + mimeTypeSolver.getExtension(mimeType) ;
     String fileName = Utils.getRealNode(node).getName();
     if (fileName.lastIndexOf(ext) < 0 && !mimeTypeSolver.getMimeType(fileName).equals(mimeType)) {
       dresource.setDownloadName(fileName + ext);
     } else {
       dresource.setDownloadName(fileName);
     }
 
     return dservice.getDownloadLink(dservice.addDownloadResource(dresource)) ;
   }
 
   /**
    * Get node nt:file if node support multi-language
    *
    * @param currentNode Current Node
    * @return Node which has type nt:file
    * @throws Exception
    */
   public static Node getFileLangNode(Node currentNode) throws Exception {
     if(currentNode.isNodeType(NT_UNSTRUCTURED)) {
       if(currentNode.getNodes().getSize() > 0) {
         NodeIterator nodeIter = currentNode.getNodes() ;
         while(nodeIter.hasNext()) {
           Node ntFile = nodeIter.nextNode() ;
           if(ntFile.isNodeType(NT_FILE)) {
             return ntFile ;
           }
         }
         return currentNode ;
       }
     }
     return currentNode ;
   }
 
   /**
    * Allows you to add a lock token to the given node
    */
   public static void addLockToken(Node node) throws Exception {
     if (node.isLocked()) {
       String lockToken = LockUtil.getLockToken(node);
       if(lockToken != null) {
         node.getSession().addLockToken(lockToken);
       }
     }
   }
   
   /**
    * sets to lower case n first elements of string
    * @param st
    * @param n
    */
   public static String toLowerCase(String st, int n) {
     StringBuilder sb = new StringBuilder(st);
     for (int i = 0; i < n; i++) {
       if (i < sb.length()) {
         sb.setCharAt(i, Character.toLowerCase(st.charAt(i)));
       }
     }
     return sb.toString();
   }
   /**
    * 
    * @return true if current user is administrative user; false if current user is normal user
    */
   public static boolean isAdministratorUser() {
     UserACL userACL = WCMCoreUtils.getService(UserACL.class);
     return userACL.isUserInGroup(userACL.getAdminGroups());
   }
   
   public static String getProfileLink(String userId) {
     RequestContext ctx = RequestContext.getCurrentInstance();
     NodeURL nodeURL = ctx.createURL(NodeURL.TYPE);
     NavigationResource resource =
         new NavigationResource(SiteType.PORTAL, Util.getPortalRequestContext().getPortalOwner(), "profile");
     return nodeURL.setResource(resource).toString() + "/" + userId;
   }
 
   /**
    * Remove refences of node
    * @param destNode
    * @throws Exception
    */
   public static void removeReferences(Node destNode) throws Exception {
     NodeType[] mixinTypes = destNode.getMixinNodeTypes();
     Session session = destNode.getSession();
     for (int i = 0; i < mixinTypes.length; i++) {
       if (mixinTypes[i].getName().equals(org.exoplatform.ecm.webui.utils.Utils.EXO_CATEGORIZED)
               && destNode.hasProperty(org.exoplatform.ecm.webui.utils.Utils.EXO_CATEGORIZED)) {
         Node valueNode = null;
         Value valueAdd = session.getValueFactory().createValue(valueNode);
         destNode.setProperty(org.exoplatform.ecm.webui.utils.Utils.EXO_CATEGORIZED, new Value[] { valueAdd });
       }
     }
     destNode.save();
   }
 
 }