class LibraryServiceImpl implements LibraryService {

    @Override
    public AssetQueryResult getProjectAssets(final ProjectAssetsQuery query) {
        checkNotNull("query",
                     query);

        final boolean projectStillExists = ioService.exists(Paths.convert(query.getProject().getBranch().getPath()));
        if (!projectStillExists) {
            log.info("Asset lookup result: project [{}] does not exist.",
                     projectIdentifierFrom(query));
            return AssetQueryResult.nonexistent();
        } else if (!indexOracle.isIndexed(query.getProject())) {
            log.info("Asset lookup result: project [{}] is not indexed.",
                     projectIdentifierFrom(query));
            return AssetQueryResult.unindexed();
        }

        final HashSet<ValueIndexTerm> queryTerms = buildProjectAssetsQuery(query);

        final PageResponse<RefactoringPageRow> findRulesByProjectQuery = refactoringQueryService.query(new RefactoringPageRequest(FindAllLibraryAssetsQuery.NAME,
                                                                                                                                  queryTerms,
                                                                                                                                  query.getStartIndex(),
                                                                                                                                  query.getAmount(),
                                                                                                                                  Boolean.TRUE));
        final List<FolderItem> assets = findRulesByProjectQuery
                .getPageRowList()
                .stream()
                .map(row -> {
                    final Path path = (Path) row.getValue();
                    return new FolderItem(path,
                                          path.getFileName(),
                                          FolderItemType.FILE,
                                          false,
                                          Paths.readLockedBy(path),
                                          Collections.<String>emptyList(),
                                          explorerServiceHelper.getRestrictedOperations(path));
                })
                .collect(Collectors.toList());

        log.info("Asset lookup result: project [{}] is indexed with {} index hits.",
                 projectIdentifierFrom(query),
                 assets.size());
        return AssetQueryResult.normal(assets.stream()
                                               .map(asset -> {
                                                   AssetInfo info = null;
                                                   try {
                                                       final Map<String, Object> attributes = ioService.readAttributes(Paths.convert((Path) asset.getItem()));

                                                       final FileTime lastModifiedFileTime = (FileTime) getAttribute(LibraryService.LAST_MODIFIED_TIME,
                                                                                                                     attributes).get();
                                                       final FileTime createdFileTime = (FileTime) getAttribute(LibraryService.CREATED_TIME,
                                                                                                                attributes).get();
                                                       final Date lastModifiedTime = new Date(lastModifiedFileTime.toMillis());
                                                       final Date createdTime = new Date(createdFileTime.toMillis());
                                                       info = new AssetInfo(asset,
                                                                            lastModifiedTime,
                                                                            createdTime);
                                                   } catch (NoSuchFileException nfe) {
                                                       log.debug("File '" + asset.getFileName() + "' in LibraryIndex but not VFS. Suspected deletion. Skipping.");
                                                   }
                                                   return Optional.ofNullable(info);
                                               })
                                               .filter(Optional::isPresent)
                                               .map(Optional::get)
                                               .collect(Collectors.toList()));
    }

    public  LibraryServiceImpl();
    @Inject public  LibraryServiceImpl(final OrganizationalUnitService ouService,
                              final RefactoringQueryService refactoringQueryService,
                              final LibraryPreferences preferences,
                              final AuthorizationManager authorizationManager,
                              final SessionInfo sessionInfo,
                              final ExplorerServiceHelper explorerServiceHelper,
                              final WorkspaceProjectService projectService,
                              final KieModuleService moduleService,
                              final ExamplesService examplesService,
                              @Named("ioStrategy") final IOService ioService,
                              final UserManagerService userManagerService,
                              final IndexStatusOracle indexOracle,
                              final SpaceConfigStorageRegistry spaceConfigStorageRegistry,
                              final ClusterService clusterService,
                              final ArchetypeService archetypeService);

}