Returns whether folder is archived

@param folder folder
@return whether folder is archived
198349
public boolean isFolderArchived(Folder folder) {
    if (folder.getArchived()) {
      return true;
    }
    
    Folder parentFolder = folder.getParentFolder();
    if (parentFolder != null) {
      return isFolderArchived(parentFolder);
    } else {
      Panel panel = panelDAO.findByRootFolder(parentFolder);
      if (panel != null) {
        return panelController.isPanelArchived(panel);
      }
    }

    return false;
  }
1164157
def is_valid_folder(parser, arg):
    """"""
    arg = os.path.abspath(arg)
    if not os.path.isdir(arg):
        parser.error("The folder %s does not exist!" % arg)
    else:
        return arg
1208899
@Override
  public boolean isDirectory(final Path f) throws IOException {
    if (stocatorPath.isTemporaryPath(f)) {
      return false;
    }
    final Path path = storageClient.qualify(f);
    try {
      FileStatus fileStatus = getFileStatus(path);
      LOG.debug("is directory: {} : {}", path.toString(), fileStatus.isDirectory());
      return fileStatus.isDirectory();
    } catch (FileNotFoundException e) {
      return false;
    }
  }
274686
public static long getOldestLastModified (File dir)
    {
        long oldest = dir.lastModified();
        File[] files = dir.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    oldest = Math.min(oldest, getOldestLastModified(file));
                } else {
                    oldest = Math.min(oldest, file.lastModified());
                }
            }
        }
        return oldest;
    }
52199
public boolean isDirectory(String path) {

		boolean isDirectory = false;
		String realPath = getRealResourcePath(path);
		if (isFileSystemPath(path, realPath)) { // The resource has been
												// remapped to a file system
												// path
			isDirectory = new File(realPath).isDirectory();
		} else {
			isDirectory = super.isDirectory(realPath);
		}
		return isDirectory;
	}
1124888
public function getHighestStatus(ExtendedFolderInterface $folder)
    {
        $status = $this->getStatus($folder);

        if ($status & 8) {
            return 8;
        } elseif ($status & 4) {
            return 4;
        } elseif ($status & 2) {
            return 2;
        } elseif ($status & 1) {
            return 1;
        }

        return 0;
    }
970507
protected boolean isRarArchive(URL url)
   {
      if (url == null)
         return false;

      return isRarFile(url) || isRarDirectory(url);
   }
856014
def isdir(self, relpath):
    """"""
    if self._isdir_raw(relpath):
      if not self.isignored(relpath, directory=True):
        return True

    return False
676183
DownloadableFileType getArchiveType() {
        try {
            return DownloadableFileType.valueOf(FilenameUtils.getExtension(decompressedFilename).toUpperCase());
        } catch (IllegalArgumentException e) {
            LOG.debug("Not a recognised Archive type");
            return null;
        }
    }
1219780
public static boolean isMergeFolders() {
        Configuration config = ConfigUtils.getCurrentConfig();
        if (config != null) {
            return config.getBoolean(MERGE_FOLDERS_CONFIG_KEY, false);
        } else {
            return false;
        }
    }
1141642
public function isDir($folder)
    {
        $metadata = $this->dropbox->getMetadata($this->pathRoot.$folder);
        return is_array($metadata) && isset($metadata['is_dir']) && $metadata['is_dir']==true;
    }
536392
function (folder, oldPath, newPath, callback) {
	var cb = callback || function () {};
	if (typeof newPath === 'function') {
		cb = newPath;
		newPath = oldPath.split( '/' ).pop();
	} else if (!newPath) {
		newPath = oldPath.split( '/' ).pop();
	}
	// check for valid arguments
	if (folder && oldPath && (typeof folder === 'string') && (typeof oldPath === 'string') && fs.existsSync( oldPath )) {
		// check for existing folder
		if (this.folders[folder]) {
			// set target
			newPath = path.resolve( this.folders[folder], newPath );
			newPath = checkSafeName.call( this, newPath );
			return {newPath: newPath, callback: cb};
		} else {
			cb( 'invalid folder' );
			return false;
		}
	} else {
		cb( 'folder or origin not valid' );
		return false;
	}
}
987559
public boolean isQueryPageArchived(QueryPage queryPage) {
    if (queryPage.getArchived()) {
      return true;
    }
    
    QuerySection querySection = queryPage.getQuerySection();
    if (querySection.getArchived()) {
      return true;
    }
    
    return isQueryArchived(querySection.getQuery());
  }
476928
public static void checkFileToBeRead(File archive, String fileDesc) throws IllegalArgumentException
    {
        if (archive == null)
            throw new IllegalArgumentException(fileDesc + " must not be null.");
        if (!archive.exists())
            throw new IllegalArgumentException(fileDesc + " does not exist: " + archive.getAbsolutePath());
        if (archive.isDirectory())
            throw new IllegalArgumentException(fileDesc + " is a directory, expected a file: " + archive.getPath());
    }
174147
public function isDeletable(MediaFolderInterface $folder)
    {
        return $this->mediaRepository->countByFolderId($folder->getId()) == 0
            && $this->folderRepository->countChildren($folder->getId(), $folder->getSiteId()) == 0;
    }
434660
@Override
  public FileStatus getFileStatus(Path f) throws IOException {
    FileStatus archiveStatus = fs.getFileStatus(archiveIndex);
    HarStatus hstatus = getFileHarStatus(f, archiveStatus);
    return new FileStatus(hstatus.isDir()?0:hstatus.getLength(), hstatus.isDir(),
        (int)archiveStatus.getReplication(), archiveStatus.getBlockSize(),
        hstatus.getModificationTime(), hstatus.getAccessTime(),
        new FsPermission(
        hstatus.getPermission()), hstatus.getOwner(),
        hstatus.getGroup(),
            makeRelative(this.uri.getPath(), new Path(hstatus.getName())));
  }
99124
def is_archive(self):
        '''
            
        '''
        try:
            if zipfile.is_zipfile(self.attachment.path) or tarfile.is_tarfile(self.attachment.path):
                return True
        except Exception:
            pass
        return False