Package com.dotmarketing.portlets.folders.model

Examples of com.dotmarketing.portlets.folders.model.Folder


    String hostName = getHostname(fromPath);
    String toParentPath = getFolderName(getPath(toPath));

    Host host;
    Folder toParentFolder;
    try {
      host = hostAPI.findByName(hostName, user, false);
        toParentFolder = folderAPI.findFolderByPath(toParentPath,host,user,false);
    } catch (DotDataException e) {
      Logger.error(DotWebdavHelper.class, e.getMessage(), e);
      throw new IOException(e.getMessage());
    } catch (DotSecurityException e) {
      Logger.error(DotWebdavHelper.class, e.getMessage(), e);
      throw new IOException(e.getMessage());
    }
    if (isResource(fromPath,user)) {
      try {
        if (!perAPI.doesUserHavePermission(toParentFolder,
            PermissionAPI.PERMISSION_READ, user, false)) {
          throw new IOException("User doesn't have permissions to move file to folder");
        }
      } catch (DotDataException e1) {
        Logger.error(DotWebdavHelper.class,e1.getMessage(),e1);
        throw new IOException(e1.getMessage());
      }
      if (toParentFolder == null || !InodeUtils.isSet(toParentFolder.getInode())) {
        throw new IOException("Cannot move a file to the root of the host.");
      }

      try{
        Identifier identifier  = APILocator.getIdentifierAPI().find(host, getPath(fromPath));

        Identifier identTo  = APILocator.getIdentifierAPI().find(host, getPath(toPath));
        boolean destinationExists=identTo!=null && InodeUtils.isSet(identTo.getId());

        if(identifier!=null && identifier.getAssetType().equals("contentlet")){
          Contentlet fileAssetCont = APILocator.getContentletAPI().findContentletByIdentifier(identifier.getId(), false, APILocator.getLanguageAPI().getDefaultLanguage().getId(), user, false);
          if(!destinationExists) {
              if (getFolderName(fromPath).equals(getFolderName(toPath))) {
                String fileName = getFileName(toPath);
                if(fileName.contains(".")){
                  fileName = fileName.substring(0, fileName.lastIndexOf("."));
                }
                APILocator.getFileAssetAPI().renameFile(fileAssetCont, fileName, user, false);
              } else {
                APILocator.getFileAssetAPI().moveFile(fileAssetCont, toParentFolder, user, false);
              }
          }
          else {
              // if the destination exists lets just create a new version and delete the original file
              Contentlet origin = APILocator.getContentletAPI().findContentletByIdentifier(identifier.getId(), false, APILocator.getLanguageAPI().getDefaultLanguage().getId(), user, false);
              Contentlet toContentlet = APILocator.getContentletAPI().findContentletByIdentifier(identTo.getId(), false, APILocator.getLanguageAPI().getDefaultLanguage().getId(), user, false);
              Contentlet newversion = APILocator.getContentletAPI().checkout(toContentlet.getInode(), user, false);

              // get a copy in a tmp folder to avoid filename change
              java.io.File tmpDir=new java.io.File(APILocator.getFileAPI().getRealAssetPathTmpBinary()
                                +java.io.File.separator+UUIDGenerator.generateUuid());
              java.io.File tmp=new java.io.File(tmpDir, toContentlet.getBinary(FileAssetAPI.BINARY_FIELD).getName());
              FileUtil.copyFile(origin.getBinary(FileAssetAPI.BINARY_FIELD), tmp);

              newversion.setBinary(FileAssetAPI.BINARY_FIELD, tmp);
              newversion = APILocator.getContentletAPI().checkin(newversion, user, false);
              if(autoPublish) {
                  APILocator.getContentletAPI().publish(newversion, user, false);
              }

              APILocator.getContentletAPI().unlock(newversion, user, false);

              APILocator.getContentletAPI().delete(origin, APILocator.getUserAPI().getSystemUser(), false);
              while(APILocator.getContentletAPI().isInodeIndexed(origin.getInode(),1));
          }
        }else{
          File f = fileAPI.getFileByURI(getPath(fromPath), host, false, user, false);
          if (getFolderName(fromPath).equals(getFolderName(toPath))) {

            String fileName = getFileName(toPath);
            if(fileName.contains(".")){
              fileName = fileName.substring(0, fileName.lastIndexOf("."));
            }
            fileAPI.renameFile(f, fileName, user, false);

          } else {
            fileAPI.moveFile(f, toParentFolder, user, false);
          }
          if (autoPublish && perAPI.doesUserHavePermission(f, PermissionAPI.PERMISSION_PUBLISH, user)) {

            PublishFactory.publishAsset(f, user, false);

          }
          APILocator.getFileAPI().invalidateCache(f);
          CacheLocator.getIdentifierCache().removeFromCacheByVersionable(f);
          LiveCache.removeAssetFromCache(f);
          WorkingCache.removeAssetFromCache(f);
        }

      }catch (Exception e) {
        throw new DotDataException(e.getMessage(),e);
      }
    } else {
      if (UtilMethods.isSet(toParentPath) && !toParentPath.equals("/")) {
        try {
          if (!perAPI.doesUserHavePermission(toParentFolder,  PermissionAPI.PERMISSION_READ, user, false)) {
            throw new IOException("User doesn't have permissions to move file to folder");
          }
        } catch (DotDataException e1) {
          Logger.error(DotWebdavHelper.class,e1.getMessage(),e1);
          throw new IOException(e1.getMessage());
        }
        if (getFolderName(fromPath).equals(getFolderName(toPath))) {
          Logger.debug(this, "Calling Folderfactory to rename " + fromPath + " to " + toPath);
          try{
            Folder folder = folderAPI.findFolderByPath(getPath(toPath), host,user,false);
            removeObject(toPath, user);
            fc.removeFolder(folder,idapi.find(folder));
          }catch (Exception e) {
            Logger.debug(this, "Unable to delete toPath " + toPath);
          }
          boolean renamed = false;
          try{
            Folder folder = folderAPI.findFolderByPath(getPath(fromPath), host,user,false);
            renamed = folderAPI.renameFolder(folder, getFileName(toPath),user,false);
            fc.removeFolder(folder,idapi.find(folder));
            //folderAPI.updateMovedFolderAssets(folder);
          }catch (Exception e) {
            throw new DotDataException(e.getMessage(), e);
          }
          if(!renamed){
            Logger.error(this, "Unable to remame folder");
            throw new IOException("Unable to rename folder");
          }
        } else {
          Logger.debug(this, "Calling folder factory to move from " + fromPath + " to " + toParentPath);
          Folder fromFolder;
          try {
            fromFolder = folderAPI.findFolderByPath(getPath(fromPath), host,user,false);
          } catch (Exception e1) {
            Logger.error(DotWebdavHelper.class, e1.getMessage(), e1);
            throw new DotRuntimeException(e1.getMessage(), e1);
          }
          if(fromFolder != null){
            Logger.debug(this, "Calling folder factory to move from " + idapi.find(fromFolder).getPath() + " to " + toParentPath);
            Logger.debug(this, "the from folder inode is " + fromFolder.getInode());
          }else{
            Logger.debug(this, "The from folder is null");
          }
          try {
            folderAPI.move(fromFolder, toParentFolder,user,false);
            fc.removeFolder(fromFolder,idapi.find(fromFolder));
            fc.removeFolder(toParentFolder,idapi.find(toParentFolder));
            //folderAPI.updateMovedFolderAssets(fromFolder);
          } catch (Exception e) {
            Logger.error(DotWebdavHelper.class, e.getMessage(), e);
            throw new DotDataException(e.getMessage(), e);
          }
        }
      } else {
        try {
          if (!perAPI.doesUserHavePermission(host,PermissionAPI.PERMISSION_READ, user, false)) {
            throw new IOException("User doesn't have permissions to move file to host");
          }
        } catch (DotDataException e) {
          Logger.error(DotWebdavHelper.class,e.getMessage(),e);
          throw new IOException(e.getMessage());
        }
        if (getFolderName(fromPath).equals(getFolderName(toPath))) {
          try{
            Folder fromfolder = folderAPI.findFolderByPath(getPath(fromPath), host,user,false);
            folderAPI.renameFolder(fromfolder, getFileName(toPath),user,false);
            fc.removeFolder(fromfolder,idapi.find(fromfolder));
          }catch (Exception e) {
            throw new DotDataException(e.getMessage(), e);
          }
        } else {
          Folder fromFolder;
          try {
            fromFolder = folderAPI.findFolderByPath(getPath(fromPath), host,user,false);
            folderAPI.move(fromFolder, host,user,false);
            fc.removeFolder(fromFolder,idapi.find(fromFolder));
            //folderAPI.updateMovedFolderAssets(fromFolder);
View Full Code Here


      throw new IOException(e.getMessage());
    } catch (DotSecurityException e) {
      Logger.error(DotWebdavHelper.class, e.getMessage(), e);
      throw new IOException(e.getMessage());
    }
    Folder folder = folderAPI.findFolderByPath(folderName, host,user,false);
    if (isResource(uri,user)) {
      Identifier identifier  = APILocator.getIdentifierAPI().find(host, path);

      Long timeOfPublishing = fileResourceCache.get(uri + "|" + user.getUserId());
      Date currentDate = new Date();
      long diff = -1;
      long minTimeAllowed = Config.getIntProperty("WEBDAV_MIN_TIME_AFTER_PUBLISH_TO_ALLOW_DELETING_OF_FILES", 10);
      boolean canDelete= true;

      if(UtilMethods.isSet(timeOfPublishing)) {
        diff = (currentDate.getTime()-timeOfPublishing)/1000;
        canDelete = diff >= minTimeAllowed;
      }

      if(identifier!=null && identifier.getAssetType().equals("contentlet")){
          Contentlet fileAssetCont = APILocator.getContentletAPI()
              .findContentletByIdentifier(identifier.getId(), false, APILocator.getLanguageAPI().getDefaultLanguage().getId(), user, false);
         
          //Webdav calls the delete method when is creating a new file. But it creates the file with 0 content length.
          //No need to wait 10 seconds with files with 0 length.
          if(canDelete
              || (fileAssetCont.getBinary(FileAssetAPI.BINARY_FIELD) != null
                && fileAssetCont.getBinary(FileAssetAPI.BINARY_FIELD).length() <= 0)){
           
            try{
                APILocator.getContentletAPI().archive(fileAssetCont, user, false);
            }catch (Exception e) {
                Logger.error(DotWebdavHelper.class, e.getMessage(), e);
                throw new DotDataException(e.getMessage(), e);
            }
           
            WorkingCache.removeAssetFromCache(fileAssetCont);
            LiveCache.removeAssetFromCache(fileAssetCont);
            fileResourceCache.remove(uri + "|" + user.getUserId());
          }
      } else {
          webAsset = fileAPI.getFileByURI(path, host, false, user, false);
          // This line just archive the assets
          // WebAssetFactory.deleteAsset(file, user.getUserId());
          // This line delete the assets (no archive)
          try{
              WebAssetFactory.archiveAsset(webAsset, user);
          }catch (Exception e) {
              Logger.error(DotWebdavHelper.class, e.getMessage(), e);
              throw new DotDataException(e.getMessage(), e);
          }
          WorkingCache.removeAssetFromCache(webAsset);
          LiveCache.removeAssetFromCache(webAsset);
      }

    } else if (isFolder(uri,user)) {
      if(!path.endsWith("/"))
        path += "/";
      folder = folderAPI.findFolderByPath(path, host,user,false);
      if (folder.isShowOnMenu()) {
        // RefreshMenus.deleteMenus();
        RefreshMenus.deleteMenu(folder);
        CacheLocator.getNavToolCache().removeNav(folder.getHostId(), folder.getInode());
        if(!path.equals("/")) {
            Identifier ii=APILocator.getIdentifierAPI().find(folder);
            CacheLocator.getNavToolCache().removeNavByPath(ii.getHostId(), ii.getParentPath());
        }
      }
View Full Code Here

          }
        } else {
          // ### GET THE FOLDERS, HTMLPAHES AND FILES AT SECOND LEVEL
          // AND LOWERS ###
          path += "/";
          Folder folder = folderAPI.findFolderByPath(path, host, user, false);
          if (InodeUtils.isSet(folder.getInode())) {
            List<Folder> folders = new ArrayList<Folder>();
            // List<HTMLPage> pages = new ArrayList<HTMLPage>();
            List<Versionable> files = new ArrayList<Versionable>();
            // List<Link> links = new ArrayList<Link>();

            try {
              folders = (ArrayList<Folder>)APILocator.getFolderAPI().findSubFolders(folder, user, false);
              // pages = (ArrayList<HTMLPage>)
              // InodeFactory.getChildrenClassByCondition(folder,HTMLPage.class,
              // conditionAsset);
              files.addAll(folderAPI.getWorkingFiles(folder, user,false));
              if(folder.getInode().equals(FolderAPI.SYSTEM_FOLDER)){
                files.addAll(APILocator.getFileAssetAPI().findFileAssetsByHost(APILocator.getHostAPI().find(folder.getHostId(), user,false), user,false));
              }else{
                files.addAll(APILocator.getFileAssetAPI().findFileAssetsByFolder(folder, user,false));
              }
              // links = (ArrayList<Link>)
              // InodeFactory.getChildrenClassByCondition(folder,Link.class,
View Full Code Here

    InputStream returnValue = null;
    String hostName = getHostname(resourceUri);
    String path = getPath(resourceUri);
    String folderName = getFolderName(path);
    Host host;
    Folder folder;
    try {
      host = hostAPI.findByName(hostName, user, false);
      folder = folderAPI.findFolderByPath(folderName, host,user,false);
    } catch (DotDataException e) {
      Logger.error(DotWebdavHelper.class, e.getMessage(), e);
      throw new IOException(e.getMessage());
    } catch (DotSecurityException e) {
      Logger.error(DotWebdavHelper.class, e.getMessage(), e);
      throw new IOException(e.getMessage());
    }
    if (host != null && InodeUtils.isSet(host.getInode()) && InodeUtils.isSet(folder.getInode())) {
      java.io.File workingFile  = null;
      Identifier identifier  = APILocator.getIdentifierAPI().find(host, path);
      if(identifier!=null && identifier.getAssetType().equals("contentlet")){
                Contentlet cont  = APILocator.getContentletAPI().findContentletByIdentifier(identifier.getId(), false, APILocator.getLanguageAPI().getDefaultLanguage().getId(), user, false);
          workingFile = cont.getBinary(FileAssetAPI.BINARY_FIELD);
View Full Code Here

        }
    }
   
    @Override
    public void removeNav(String hostid, String folderInode) {
        Folder folder;
        try {
            if(!folderInode.equals(FolderAPI.SYSTEM_FOLDER)) {
                try {
                    folder = APILocator.getFolderAPI().find(folderInode, APILocator.getUserAPI().getSystemUser(), false);
                }
                catch(Exception ex) {
                    // here we catch the when it have been deleted
                    folder = null;
                }
                if(folder==null || !UtilMethods.isSet(folder.getIdentifier()) || !folder.isShowOnMenu()) {
                    // if the folder have been deleted or should not be shown on menu lets
                    // remove cache recursively
                    LinkedList<String> ids=new LinkedList<String>();
                    ids.add(folderInode);
                    while(!ids.isEmpty()) {
View Full Code Here

       
    }

    @Override
    public void removeNavByPath(String hostid, String path) {
        Folder folder;
        try {
            folder = APILocator.getFolderAPI().findFolderByPath(path, hostid, APILocator.getUserAPI().getSystemUser(), false);
            if(folder != null)
              removeNav(hostid,folder.getInode());
        } catch (Exception e) {
            Logger.warn(this, e.getMessage(), e);
        }
    }
View Full Code Here

  public  boolean renameFile (File file, String newName) throws DotStateException, DotDataException, DotSecurityException {

      //getting old file properties
      String oldFileName = file.getFileName();
      String ext = UtilMethods.getFileExtension(oldFileName);
      Folder folder = APILocator.getFolderAPI().findParentFolder(file, APILocator.getUserAPI().getSystemUser(), false);

      Identifier ident = APILocator.getIdentifierAPI().find(file);

      String newFileName = newName;
      if(UtilMethods.isSet(ext)){
        newFileName = newFileName + "." + ext;
      }

      if(fileNameExists(folder, newFileName) || file.isLocked())
        return false;

      List<Versionable> versions = APILocator.getVersionableAPI().findAllVersions(ident);

      boolean islive = false;


    for (Versionable version : versions) {
      File f = (File)version;


        // sets filename for this new file
        f.setFileName(newFileName);

        HibernateUtil.saveOrUpdate(f);

        if (f.isLive())
          islive = true;
      }

    LiveCache.removeAssetFromCache(file);
    WorkingCache.removeAssetFromCache(file);
       CacheLocator.getIdentifierCache().removeFromCacheByVersionable(file);

    ident.setURI(APILocator.getIdentifierAPI().find(folder).getPath() + newFileName);
      //HibernateUtil.saveOrUpdate(ident);
    APILocator.getIdentifierAPI().save(ident);

      if (islive){
        LiveCache.removeAssetFromCache(file);
        LiveCache.addToLiveAssetToCache(file);
      }
      WorkingCache.removeAssetFromCache(file);
       WorkingCache.addToWorkingAssetToCache(file);
       CacheLocator.getIdentifierCache().removeFromCacheByVersionable(file);

      //RefreshMenus.deleteMenus();
       RefreshMenus.deleteMenu(file);
       CacheLocator.getNavToolCache().removeNav(folder.getHostId(), folder.getInode());

      return true;

    }
View Full Code Here

            LiveCache.removeAssetFromCache( liveWebAsset );
        }
        WorkingCache.removeAssetFromCache( workingWebAsset );

        // gets old parent
        Folder oldParent = APILocator.getFolderAPI().findParentFolder( workingWebAsset, APILocator.getUserAPI().getSystemUser(), false );

        /*oldParent.deleteChild(workingWebAsset);
          if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
              oldParent.deleteChild(liveWebAsset);
          }
          //add new Parent
          parent.addChild(workingWebAsset);
          if ((liveWebAsset != null) && (InodeUtils.isSet(liveWebAsset.getInode()))) {
              parent.addChild(liveWebAsset);
          }*/

        // gets identifier for this webasset and changes the uri and persists it
        User systemUser;
        try {
            systemUser = APILocator.getUserAPI().getSystemUser();
            if ( host == null ) {
                host = hostAPI.findParentHost( parent, systemUser, false );
            }
        } catch ( DotDataException e ) {
            Logger.error( FileFactory.class, e.getMessage(), e );
            throw new DotRuntimeException( e.getMessage(), e );

        } catch ( DotSecurityException e ) {
            Logger.error( FileFactory.class, e.getMessage(), e );
            throw new DotRuntimeException( e.getMessage(), e );
        }
        identifier.setHostId( host.getIdentifier() );
        identifier.setURI( parent != null ? workingWebAsset.getURI( parent ) : workingWebAsset.getURI() );
        //HibernateUtil.saveOrUpdate(identifier);
        APILocator.getIdentifierAPI().save( identifier );

        if ( UtilMethods.isSet( liveWebAsset ) )
            CacheLocator.getIdentifierCache().removeFromCacheByVersionable( liveWebAsset );
//    IdentifierCache.addAssetToIdentifierCache(liveWebAsset);

        // Add to Preview and Live Cache
        if ( (liveWebAsset != null) && (InodeUtils.isSet( liveWebAsset.getInode() )) ) {
            LiveCache.removeAssetFromCache( liveWebAsset );
            LiveCache.addToLiveAssetToCache( liveWebAsset );
        }
        WorkingCache.removeAssetFromCache( workingWebAsset );
        WorkingCache.addToWorkingAssetToCache( workingWebAsset );

        if ( file.isShowOnMenu() ) {
            //existing folder with different show on menu ... need to regenerate menu
            if ( parent != null ) {
                RefreshMenus.deleteMenu( oldParent, parent );
                CacheLocator.getNavToolCache().removeNav(parent.getHostId(), parent.getInode());
            } else {
                RefreshMenus.deleteMenu( oldParent );
            }
            CacheLocator.getNavToolCache().removeNav(oldParent.getHostId(), oldParent.getInode());
        }

        return true;
    }
View Full Code Here

   
    public List<NavResult> getChildren() throws Exception {
        if(children==null && hostId!=null && folderId!=null) {
            // lazy loadinge children
            Host host=APILocator.getHostAPI().find(hostId, sysuser, true);
            Folder folder=APILocator.getFolderAPI().find(folderId, sysuser, true);
            Identifier ident=APILocator.getIdentifierAPI().find(folder);
            NavResult lazyMe=NavTool.getNav(host, ident.getPath());
            children=lazyMe.getChildren();
            childrenFolderIds=lazyMe.getChildrenFolderIds();
        }
View Full Code Here

    }
   
    public String getParentPath() throws DotDataException, DotSecurityException {
        if(parent==null) return null; // no parent! I'm the root folder
        if(parent.equals(FolderAPI.SYSTEM_FOLDER)) return "/";
        Folder folder=APILocator.getFolderAPI().find(parent, sysuser, true);
        Identifier ident=APILocator.getIdentifierAPI().find(folder);
        return ident.getURI();
    }
View Full Code Here

TOP

Related Classes of com.dotmarketing.portlets.folders.model.Folder

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.