@Before
  public void setUp() throws Exception {
    repository = mock(IUnifiedRepository.class);

    session = mock(IPentahoSession.class);
    when(session.getName()).thenReturn("test");
    PentahoSessionHolder.setSession(session);

    userSettings =
        new HashMap<String, Serializable>() {
          {
            put(USER_SETTING_NAME_1, USER_SETTING_VALUE_1);
            put(UserSettingService.SETTING_PREFIX + COMMON_SETTING_NAME, COMMON_USER_SETTING_VALUE);
            put(USER_SETTING_NAME_2, USER_SETTING_VALUE_2);
            put(UserSettingService.SETTING_PREFIX + USER_SETTING_NAME_3, USER_SETTING_VALUE_3);
          }
        };
    globalSettings =
        new HashMap<String, Serializable>() {
          {
            put(GLOBAL_SETTING_NAME_1, GLOBAL_SETTING_VALUE_1);
            put(
                UserSettingService.SETTING_PREFIX + COMMON_SETTING_NAME,
                COMMON_GLOBAL_SETTING_VALUE);
            put(GLOBAL_SETTING_NAME_2, GLOBAL_SETTING_VALUE_2);
            put(UserSettingService.SETTING_PREFIX + GLOBAL_SETTING_NAME_3, GLOBAL_SETTING_VALUE_3);
          }
        };

    when(repository.getFileMetadata(eq(USER_FOLDER_ID))).thenReturn(userSettings);
    when(repository.getFileMetadata(eq(TENANT_FOLDER_ID))).thenReturn(globalSettings);

    final RepositoryFile tenantRepositoryFile = mock(RepositoryFile.class);
    when(tenantRepositoryFile.getId()).thenReturn(TENANT_FOLDER_ID);
    when(repository.getFile(eq(ClientRepositoryPaths.getEtcFolderPath())))
        .thenReturn(tenantRepositoryFile);

    final RepositoryFile userRepositoryFile = mock(RepositoryFile.class);
    when(userRepositoryFile.getId()).thenReturn(USER_FOLDER_ID);
    when(repository.getFile(eq(ClientRepositoryPaths.getUserHomeFolderPath(session.getName()))))
        .thenReturn(userRepositoryFile);

    securityHelper = mock(ISecurityHelper.class);
    when(securityHelper.runAsSystem(any(Callable.class)))
        .thenAnswer(
            new Answer<Object>() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {
                final Callable callable = (Callable) invocation.getArguments()[0];
                if (callable != null) {
                  return callable.call();
                }
                return null;
              }
            });
    SecurityHelper.setMockInstance(securityHelper);

    userSettingService = new UserSettingService(repository);
    userSettingService.init(session);
  }
 public void setUp() throws Exception {
   IUnifiedRepository repository =
       new MockUnifiedRepository(new MockUnifiedRepository.SpringSecurityCurrentUserProvider());
   datasourceMgmtService =
       new JcrBackedDatasourceMgmtService(repository, new DatabaseDialectService());
   datasourceMgmtWebService = new DefaultDatasourceMgmtWebService(datasourceMgmtService);
   dbConnectionAdapter = new DatabaseConnectionAdapter();
   SecurityContextHolder.getContext()
       .setAuthentication(
           new UsernamePasswordAuthenticationToken(
               MockUnifiedRepository.root().getName(), null, new GrantedAuthority[0]));
   repository.createFolder(
       repository.getFile("/etc").getId(),
       new RepositoryFile.Builder(FOLDER_PDI).folder(true).build(),
       new RepositoryFileAcl.Builder(MockUnifiedRepository.root())
           .ace(MockUnifiedRepository.everyone(), READ, READ_ACL, WRITE, WRITE_ACL)
           .build(),
       null);
   repository.createFolder(
       repository.getFile("/etc/pdi").getId(),
       new RepositoryFile.Builder(FOLDER_DATABASES).folder(true).build(),
       null);
   SecurityContextHolder.getContext()
       .setAuthentication(
           new UsernamePasswordAuthenticationToken(EXP_LOGIN, null, new GrantedAuthority[0]));
 }
  /**
   * Creates a new repository file (with the supplied data) and applies the proper metadata to this
   * file.
   *
   * @param domainId the Domain id associated with this file
   * @param locale the locale associated with this file (or null for a domain file)
   * @param data the data to put in the file
   * @return the repository file created
   */
  protected RepositoryFile createUniqueFile(
      final String domainId, final String locale, final SimpleRepositoryFileData data) {
    // Generate a "unique" filename
    final String filename = UUID.randomUUID().toString();

    // Create the new file
    final RepositoryFile file =
        repository.createFile(
            getMetadataDir().getId(), new RepositoryFile.Builder(filename).build(), data, null);

    // Add metadata to the file
    final Map<String, Serializable> metadataMap = new HashMap<String, Serializable>();
    metadataMap.put(PROPERTY_NAME_DOMAIN_ID, domainId);
    if (StringUtils.isEmpty(locale)) {
      // This is a domain file
      metadataMap.put(PROPERTY_NAME_TYPE, TYPE_DOMAIN);
    } else {
      // This is a locale property file
      metadataMap.put(PROPERTY_NAME_TYPE, TYPE_LOCALE);
      metadataMap.put(PROPERTY_NAME_LOCALE, locale);
    }

    // Update the metadata
    repository.setFileMetadata(file.getId(), metadataMap);
    return file;
  }
  public static MasterReport createReport(final Serializable fileId)
      throws ResourceException, IOException {
    final ResourceManager resourceManager = new ResourceManager();
    resourceManager.registerDefaults();
    final HashMap helperObjects = new HashMap();
    // add the runtime context so that PentahoResourceData class can get access
    // to the solution repo

    ResourceKey key = null;

    IUnifiedRepository unifiedRepository =
        PentahoSystem.get(IUnifiedRepository.class, PentahoSessionHolder.getSession());
    RepositoryFile repositoryFile = unifiedRepository.getFileById(fileId);
    if (repositoryFile != null) {
      key =
          resourceManager.createKey(
              RepositoryResourceLoader.SOLUTION_SCHEMA_NAME
                  + RepositoryResourceLoader.SCHEMA_SEPARATOR
                  + repositoryFile.getPath(),
              helperObjects);
    } else {
      key =
          resourceManager.createKey(
              RepositoryResourceLoader.SOLUTION_SCHEMA_NAME
                  + RepositoryResourceLoader.SCHEMA_SEPARATOR
                  + fileId,
              helperObjects);
    }

    final Resource resource = resourceManager.create(key, null, MasterReport.class);
    return (MasterReport) resource.getResource();
  }
 public InputStream getInputStream() throws Exception {
   IUnifiedRepository repository = PentahoSystem.get(IUnifiedRepository.class);
   RepositoryFile repositoryFile = repository.getFile(inputFilePath);
   if ((repositoryFile == null) || repositoryFile.isFolder()) {
     throw new FileNotFoundException();
   }
   return new RepositoryFileInputStream(repositoryFile);
 }
 public static MasterReport createReportByName(final String fullFilePathAndName)
     throws ResourceException, IOException {
   IUnifiedRepository unifiedRepository =
       PentahoSystem.get(IUnifiedRepository.class, PentahoSessionHolder.getSession());
   RepositoryFile repositoryFile = unifiedRepository.getFile(fullFilePathAndName);
   if (repositoryFile == null) {
     throw new IOException("File " + fullFilePathAndName + " not found in repository");
   } else {
     return createReport(repositoryFile.getId());
   }
 }
 public void fileCreated(String filePath) {
   IUnifiedRepository repository = PentahoSystem.get(IUnifiedRepository.class);
   RepositoryFile outputFile = repository.getFile(filePath);
   if (outputFile != null) {
     Map<String, Serializable> fileMetadata = repository.getFileMetadata(outputFile.getId());
     RepositoryFile inputFile = repository.getFile(inputFilePath);
     if (inputFile != null) {
       fileMetadata.put(PentahoJcrConstants.PHO_CONTENTCREATOR, inputFile.getId());
       repository.setFileMetadata(outputFile.getId(), fileMetadata);
     }
   }
 }
  /** Performs the process of reloading the domain information from the repository */
  private void internalReloadDomains() {
    lock.writeLock().lock();
    try {
      metadataMapping.reset();

      // Reload the metadata about the metadata (that was fun to say)
      final List<RepositoryFile> children = repository.getChildren(getMetadataDir().getId(), "*");
      if (logger.isTraceEnabled()) {
        logger.trace("\tFound " + children.size() + " files in the repository");
      }
      for (final RepositoryFile child : children) {
        if (getAclHelper().canAccess(child, READ)) {
          // Get the metadata for this file
          final Map<String, Serializable> fileMetadata = repository.getFileMetadata(child.getId());
          if (fileMetadata == null
              || StringUtils.isEmpty((String) fileMetadata.get(PROPERTY_NAME_DOMAIN_ID))) {
            if (logger.isWarnEnabled()) {
              logger.warn(
                  messages.getString(
                      "PentahoMetadataDomainRepository.WARN_0001_FILE_WITHOUT_METADATA",
                      child.getName()));
            }
            continue;
          }
          final String domainId = (String) fileMetadata.get(PROPERTY_NAME_DOMAIN_ID);
          final String type = (String) fileMetadata.get(PROPERTY_NAME_TYPE);
          final String locale = (String) fileMetadata.get(PROPERTY_NAME_LOCALE);
          if (logger.isTraceEnabled()) {
            logger.trace(
                "\tprocessing file [type="
                    + type
                    + " : domainId="
                    + domainId
                    + " : locale="
                    + locale
                    + "]");
          }

          // Save the data in the map
          if (StringUtils.equals(type, TYPE_DOMAIN)) {
            metadataMapping.addDomain(domainId, child);
          } else if (StringUtils.equals(type, TYPE_LOCALE)) {
            metadataMapping.addLocale(domainId, locale, child);
          }
        }
      }

      needToReload = false;
    } finally {
      lock.writeLock().unlock();
    }
  }
 static void deleteContentItem(IContentItem contentItem, IUnifiedRepository unifiedRepository) {
   if (contentItem instanceof RepositoryFileContentItem) {
     String path = contentItem.getPath();
     RepositoryFile repositoryFile = unifiedRepository.getFile(path);
     // repositoryFile can be null if we have not access or file does not exist
     if (repositoryFile != null) {
       unifiedRepository.deleteFile(repositoryFile.getId(), true, null);
     }
   } else if (contentItem instanceof FileContentItem) {
     // Files in the file system must not be deleted here
     String path = ((FileContentItem) contentItem).getFile().getName();
     logger.warn(Messages.getInstance().getString("XactionUtil.SKIP_REMOVING_OUTPUT_FILE", path));
   }
 }
  @Test
  public void testDoNewTenant() throws Exception {
    loginAsRepositoryAdmin();
    ITenant systemTenant =
        tenantManager.createTenant(
            null,
            ServerRepositoryPaths.getPentahoRootFolderName(),
            adminAuthorityName,
            tenantAuthenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        systemTenant, sysAdminUserName, "password", "", new String[] {adminAuthorityName});
    ITenant mainTenant_1 =
        tenantManager.createTenant(
            systemTenant,
            MAIN_TENANT_1,
            adminAuthorityName,
            tenantAuthenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        mainTenant_1,
        "admin",
        "password",
        "",
        new String[] {adminAuthorityName, tenantAuthenticatedAuthorityName});
    login(
        "admin", mainTenant_1, new String[] {adminAuthorityName, tenantAuthenticatedAuthorityName});
    JcrRepositoryDumpToFile dumpToFile =
        new JcrRepositoryDumpToFile(
            testJcrTemplate,
            jcrTransactionTemplate,
            repositoryAdminUsername,
            "c:/build/testrepo_3",
            Mode.CUSTOM);
    dumpToFile.execute();
    metadataRepositoryLifecycleManager.newTenant(mainTenant_1);
    String metadataPath = ClientRepositoryPaths.getEtcFolderPath() + "/metadata";
    RepositoryFile metadataRepositoryPath = repo.getFile(metadataPath);
    assertTrue(metadataRepositoryPath.getPath() != null);

    // Nothing should change if we run it again
    metadataRepositoryLifecycleManager.newTenant(mainTenant_1);
    metadataPath = ClientRepositoryPaths.getEtcFolderPath() + "/metadata";
    metadataRepositoryPath = repo.getFile(metadataPath);
    assertTrue(metadataRepositoryPath.getPath() != null);
    cleanupUserAndRoles(mainTenant_1);
    cleanupUserAndRoles(systemTenant);
  }
  @Test
  public void testDeleteUserSettingsByName() throws Exception {
    IAuthorizationPolicy policy = mock(IAuthorizationPolicy.class);
    when(policy.isAllowed(anyString())).thenReturn(true);
    PentahoSystem.registerObject(policy);

    final RepositoryFile repositoryFile = mock(RepositoryFile.class);
    when(repositoryFile.getId()).thenReturn(USER_FOLDER_ID);
    when(repository.getFile(anyString())).thenReturn(repositoryFile);

    doAnswer(
            new Answer() {
              @Override
              public Object answer(InvocationOnMock invocation) throws Throwable {

                final Map<String, Serializable> settings =
                    (Map<String, Serializable>) invocation.getArguments()[1];

                assertNotNull(settings);
                assertEquals(2, settings.size());

                final Iterator<String> iterator = settings.keySet().iterator();
                assertFalse(iterator.next().startsWith(UserSettingService.SETTING_PREFIX));
                assertFalse(iterator.next().startsWith(UserSettingService.SETTING_PREFIX));

                return null;
              }
            })
        .when(repository)
        .setFileMetadata(eq(USER_FOLDER_ID), anyMap());

    userSettingService.deleteUserSettings("test");
  }
  @Override
  public String[] getUserParameters(String kettleFilePath) {

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

    if (!StringUtils.isEmpty(kettleFilePath)) {

      RepositoryFile file = unifiedRepository.getFile(kettleFilePath);

      if (file != null) {

        try {

          NamedParams np = getMeta(file);

          if (!isEmpty(np = filterUserParameters(np))) {

            return np.listParameters();
          }

        } catch (KettleException e) {
          log.error(e);
        }
      }
    }

    return userParams.toArray(new String[] {});
  }
 public RepositoryFileDto updateFile(
     RepositoryFileDto file, NodeRepositoryFileDataDto data, String versionMessage) {
   return repositoryFileAdapter.marshal(
       repo.updateFile(
           repositoryFileAdapter.unmarshal(file),
           nodeRepositoryFileDataAdapter.unmarshal(data),
           versionMessage));
 }
 public List<VersionSummaryDto> getVersionSummaryInBatch(final List<RepositoryFileDto> files) {
   List<VersionSummaryDto> versions = new ArrayList<VersionSummaryDto>(files.size());
   for (RepositoryFileDto file : files) {
     versions.add(
         versionSummaryAdapter.marshal(repo.getVersionSummary(file.getId(), file.getVersionId())));
   }
   return versions;
 }
 public List<NodeRepositoryFileDataDto> getDataAsNodeForReadInBatch(
     final List<RepositoryFileDto> files) {
   List<NodeRepositoryFileDataDto> data = new ArrayList<NodeRepositoryFileDataDto>(files.size());
   for (RepositoryFileDto f : files) {
     if (f.getVersionId() == null) {
       data.add(
           nodeRepositoryFileDataAdapter.marshal(
               repo.getDataForRead(f.getId(), NodeRepositoryFileData.class)));
     } else {
       data.add(
           nodeRepositoryFileDataAdapter.marshal(
               repo.getDataAtVersionForRead(
                   f.getId(), f.getVersionId(), NodeRepositoryFileData.class)));
     }
   }
   return data;
 }
  public List<RepositoryFileDto> getReferrers(String fileId) {
    List<RepositoryFileDto> fileList = new ArrayList<RepositoryFileDto>();

    for (RepositoryFile file : repo.getReferrers(fileId)) {
      fileList.add(repositoryFileAdapter.marshal(file));
    }
    return fileList;
  }
 protected void validateEtcWriteAccess(String parentFolderId) {
   RepositoryFile etcFolder = repo.getFile("/etc");
   if (etcFolder != null) {
     String etcFolderId = etcFolder.getId().toString();
     if (etcFolderId.equals(parentFolderId)) {
       throw new RuntimeException("This service is not allowed to access the ETC folder in JCR.");
     }
   }
 }
 @Override
 public void createContent() throws Exception {
   this.session = PentahoSessionHolder.getSession();
   this.repository = PentahoSystem.get(IUnifiedRepository.class, session);
   final RepositoryFile BIRTfile =
       (RepositoryFile) parameterProviders.get("path").getParameter("file");
   final String ExecBIRTFilePath = "../webapps/birt/" + BIRTfile.getId() + ".rptdocument";
   /*
    * Get BIRT report design from repository
    */
   final File ExecBIRTFile = new File(ExecBIRTFilePath);
   if (!ExecBIRTFile.exists()) {
     final FileOutputStream fos = new FileOutputStream(ExecBIRTFilePath);
     try {
       final SimpleRepositoryFileData data =
           repository.getDataForRead(BIRTfile.getId(), SimpleRepositoryFileData.class);
       final InputStream inputStream = data.getInputStream();
       final byte[] buffer = new byte[0x1000];
       int bytesRead = inputStream.read(buffer);
       while (bytesRead >= 0) {
         fos.write(buffer, 0, bytesRead);
         bytesRead = inputStream.read(buffer);
       }
     } catch (final Exception e) {
       Logger.error(getClass().getName(), e.getMessage());
     } finally {
       fos.close();
     }
   }
   /*
    * Redirect to BIRT Viewer
    */
   try {
     // Get informations about user context
     final IUserRoleListService service = PentahoSystem.get(IUserRoleListService.class);
     String roles = "";
     final ListIterator<String> li =
         service.getRolesForUser(null, session.getName()).listIterator();
     while (li.hasNext()) {
       roles = roles + li.next().toString() + ",";
     }
     // Redirect
     final HttpServletResponse response =
         (HttpServletResponse) this.parameterProviders.get("path").getParameter("httpresponse");
     response.sendRedirect(
         "/birt/frameset?__document="
             + BIRTfile.getId()
             + ".rptdocument&__showtitle=false&username="******"&userroles="
             + roles
             + "&reportname="
             + BIRTfile.getTitle());
   } catch (final Exception e) {
     Logger.error(getClass().getName(), e.getMessage());
   }
 }
  /**
   * retrieve a domain from the repo. This does lazy loading of the repo, so it calls
   * reloadDomains() if not already loaded.
   *
   * @param domainId domain to get from the repository
   * @return domain object
   */
  @Override
  public Domain getDomain(final String domainId) {
    if (logger.isDebugEnabled()) {
      logger.debug("getDomain(" + domainId + ")");
    }

    if (StringUtils.isEmpty(domainId)) {
      throw new IllegalArgumentException(
          messages.getErrorString(
              "PentahoMetadataDomainRepository.ERROR_0004_DOMAIN_ID_INVALID", domainId));
    }
    Domain domain = null;
    try {
      // Load the domain file
      final RepositoryFile file = getMetadataRepositoryFile(domainId);
      if (file != null) {
        if (hasAccessFor(file)) {
          SimpleRepositoryFileData data =
              repository.getDataForRead(file.getId(), SimpleRepositoryFileData.class);
          if (data != null) {
            domain = xmiParser.parseXmi(data.getStream());
            domain.setId(domainId);
            logger.debug("loaded domain");
            // Load any I18N bundles
            loadLocaleStrings(domainId, domain);
            logger.debug("loaded I18N bundles");
          } else {
            throw new UnifiedRepositoryException(
                messages.getErrorString(
                    "PentahoMetadataDomainRepository.ERROR_0005_ERROR_RETRIEVING_DOMAIN",
                    domainId,
                    "data not found"));
          }
        } else {
          throw new PentahoAccessControlException(
              messages.getErrorString(
                  "PentahoMetadataDomainRepository.ERROR_0005_ERROR_RETRIEVING_DOMAIN",
                  domainId,
                  "access denied"));
        }
      }
    } catch (Exception e) {
      if (!(e instanceof UnifiedRepositoryException
          || e instanceof PentahoAccessControlException)) {
        throw new UnifiedRepositoryException(
            messages.getErrorString(
                "PentahoMetadataDomainRepository.ERROR_0005_ERROR_RETRIEVING_DOMAIN",
                domainId,
                e.getLocalizedMessage()),
            e);
      }
    }

    // Return
    return domain;
  }
 /**
  * lookup the list of available locale values
  *
  * @param fileId
  * @return
  */
 private List<LocaleMapDto> getAvailableLocales(Serializable fileId) {
   List<LocaleMapDto> availableLocales = new ArrayList<LocaleMapDto>();
   List<Locale> locales = unifiedRepository.getAvailableLocalesForFileById(fileId);
   if (locales != null && !locales.isEmpty()) {
     for (Locale locale : locales) {
       availableLocales.add(new LocaleMapDto(locale.toString(), null));
     }
   }
   return availableLocales;
 }
 @Override
 public List<StringKeyStringValueDto> getFileMetadata(final String fileId) {
   final Map<String, Serializable> metadataMap = repo.getFileMetadata(fileId);
   final List<StringKeyStringValueDto> fileMetadataMap =
       new ArrayList<StringKeyStringValueDto>(metadataMap.size());
   for (final String key : metadataMap.keySet()) {
     fileMetadataMap.add(new StringKeyStringValueDto(key, metadataMap.get(key).toString()));
   }
   return fileMetadataMap;
 }
 @Override
 public void setFileMetadata(
     final String fileId, final List<StringKeyStringValueDto> fileMetadataMap) {
   Map<String, Serializable> metadataMap =
       new HashMap<String, Serializable>(fileMetadataMap.size());
   for (final StringKeyStringValueDto dto : fileMetadataMap) {
     metadataMap.put(dto.getKey(), dto.getValue());
   }
   repo.setFileMetadata(fileId, metadataMap);
 }
  @Test
  public void testDeleteFiles() {
    loginAsRepositoryAdmin();
    ITenant systemTenant =
        tenantManager.createTenant(
            null,
            ServerRepositoryPaths.getPentahoRootFolderName(),
            adminAuthorityName,
            authenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        systemTenant, sysAdminUserName, "password", "", new String[] {adminAuthorityName});
    ITenant mainTenant_1 =
        tenantManager.createTenant(
            systemTenant,
            MAIN_TENANT_1,
            adminAuthorityName,
            authenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        mainTenant_1, "admin", "password", "", new String[] {adminAuthorityName});
    try {
      login("admin", mainTenant_1, new String[] {authenticatedAuthorityName});

      String testFile1Id = "abc.txt";
      String testFile2Id = "def.txt";

      // set object in PentahoSystem
      mp.defineInstance(IUnifiedRepository.class, repo);

      String publicFolderPath = ClientRepositoryPaths.getPublicFolderPath();
      createTestFile(publicFolderPath.replaceAll("/", ":") + ":" + testFile1Id, "abcdefg");
      createTestFile(publicFolderPath.replaceAll("/", ":") + ":" + testFile2Id, "abcdefg");
      createTestFolder(":home:admin");

      RepositoryFile file1 = repo.getFile(publicFolderPath + "/" + testFile1Id);
      RepositoryFile file2 = repo.getFile(publicFolderPath + "/" + testFile2Id);
      WebResource webResource = resource();
      webResource.path("repo/files/delete").entity(file1.getId() + "," + file2.getId()).put();

      RepositoryFileDto[] deletedFiles =
          webResource
              .path("repo/files/deleted")
              .accept(APPLICATION_XML)
              .get(RepositoryFileDto[].class);
      assertEquals(2, deletedFiles.length);

      webResource.path("repo/files/deletepermanent").entity(file2.getId()).put();
    } catch (Throwable ex) {
      TestCase.fail();
    } finally {
      cleanupUserAndRoles(mainTenant_1);
      cleanupUserAndRoles(systemTenant);
    }
  }
 private boolean isValidOutputPath(String path) {
   try {
     RepositoryFile repoFile = repository.getFile(path);
     if (repoFile != null && repoFile.isFolder()) {
       return true;
     }
   } catch (Exception e) {
     logger.warn(e.getMessage(), e);
   }
   return false;
 }
 /**
  * Creates a new file in the repository
  *
  * @param bundle
  * @param destinationPath
  * @param bundlePath
  * @param ext
  * @param data
  * @param comment
  */
 protected RepositoryFile createFile(
     final ImportSource.IRepositoryFileBundle bundle,
     final String destinationPath,
     final boolean hidden,
     final IRepositoryFileData data,
     final String comment) {
   final RepositoryFile file =
       new RepositoryFile.Builder(bundle.getFile())
           .hidden(hidden)
           .title(RepositoryFile.DEFAULT_LOCALE, getTitle(bundle.getFile().getName()))
           .versioned(true)
           .build();
   final Serializable parentId = getParentId(destinationPath);
   final RepositoryFileAcl acl = bundle.getAcl();
   if (null == acl) {
     return repository.createFile(parentId, file, data, comment);
   } else {
     return repository.createFile(parentId, file, data, acl, comment);
   }
 }
 /**
  * create an entry in the export manifest for this file or folder
  *
  * @param repositoryFile
  * @throws ExportException
  */
 private void addToManifest(RepositoryFile repositoryFile) throws ExportException {
   if (this.withManifest) {
     // add this entity to the manifest
     RepositoryFileAcl fileAcl = unifiedRepository.getAcl(repositoryFile.getId());
     try {
       exportManifest.add(repositoryFile, fileAcl);
     } catch (ExportManifestFormatException e) {
       throw new ExportException(e.getMessage());
     }
   }
 }
 @Override
 public List<PentahoLocale> getAvailableLocalesForFileById(String fileId) {
   List<PentahoLocale> pentahoLocales = new ArrayList<PentahoLocale>();
   List<Locale> locales = repo.getAvailableLocalesForFileById(fileId);
   if (locales != null && !locales.isEmpty()) {
     for (Locale locale : locales) {
       pentahoLocales.add(new PentahoLocale(locale));
     }
   }
   return pentahoLocales;
 }
 public RepositoryFileDto createFolderWithAcl(
     String parentFolderId,
     RepositoryFileDto file,
     RepositoryFileAclDto acl,
     String versionMessage) {
   RepositoryFile newFile =
       repo.createFolder(
           parentFolderId,
           repositoryFileAdapter.unmarshal(file),
           repositoryFileAclAdapter.unmarshal(acl),
           versionMessage);
   return newFile != null ? repositoryFileAdapter.marshal(newFile) : null;
 }
 public RepositoryFileDto createFile(
     String parentFolderId,
     RepositoryFileDto file,
     NodeRepositoryFileDataDto data,
     String versionMessage) {
   validateEtcWriteAccess(parentFolderId);
   return repositoryFileAdapter.marshal(
       repo.createFile(
           parentFolderId,
           repositoryFileAdapter.unmarshal(file),
           nodeRepositoryFileDataAdapter.unmarshal(data),
           versionMessage));
 }
  @Test
  public void testCopyFiles() throws Exception {
    mp.defineInstance(IUnifiedRepository.class, repo);
    loginAsRepositoryAdmin();
    ITenant systemTenant =
        tenantManager.createTenant(
            null,
            ServerRepositoryPaths.getPentahoRootFolderName(),
            adminAuthorityName,
            authenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        systemTenant, sysAdminUserName, "password", "", new String[] {adminAuthorityName});
    login(
        sysAdminUserName,
        systemTenant,
        new String[] {adminAuthorityName, authenticatedAuthorityName});

    ITenant mainTenant_1 =
        tenantManager.createTenant(
            systemTenant,
            MAIN_TENANT_1,
            adminAuthorityName,
            authenticatedAuthorityName,
            "Anonymous");
    userRoleDao.createUser(
        mainTenant_1, "admin", "password", "", new String[] {adminAuthorityName});
    login("admin", mainTenant_1, new String[] {authenticatedAuthorityName});

    try {
      final String destFolderPath = "public:folder3:folder4";
      final String fileName = "file.txt";

      String publicFolderPath = ClientRepositoryPaths.getPublicFolderPath();
      createTestFile(publicFolderPath.replaceAll("/", ":") + ":" + fileName, "abcdefg");
      WebResource webResource = resource();
      RepositoryFile file =
          repo.getFile(ClientRepositoryPaths.getPublicFolderPath() + "/" + fileName);
      ClientResponse r =
          webResource
              .path("repo/files/" + destFolderPath + "/children")
              .accept(TEXT_PLAIN)
              .put(ClientResponse.class, file.getId());
      assertResponse(r, Status.OK);
    } catch (Throwable ex) {
      TestCase.fail();
    } finally {
      cleanupUserAndRoles(mainTenant_1);
      cleanupUserAndRoles(systemTenant);
    }
  }