import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * List all file names and subfolders of the specified path traversing into subfolders to the given depth.
 *
 * @param path path of the folder
 * @param depth depth of recursion while listing folder contents
 * @return found file names and subfolders
 */
public List<String> listFolderContent(String path, int depth)
{
    String url = (_serverConfig.isUseHTTPS() ? "https" : "http") +"://"+_serverConfig.getServerName()+"/"+WEB_DAV_BASE_PATH+path ;

    List<String> retVal= new LinkedList<>();
    Sardine sardine = SardineFactory.begin();
    sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
    List<DavResource> resources;
    try {
        resources = sardine.list(url, depth);
    } catch (IOException e) {
        throw new NextcloudApiException(e);
    }
    for (DavResource res : resources)
    {
        retVal.add(res.getName());
    }
    return retVal;
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/** Uploads a file at the specified path with the data from the InputStream
   *
   * @param inputStream          InputStream of the file which should be uploaded
   * @param remotePath           path where the file should be uploaded to
   */
  public void uploadFile(InputStream inputStream, String remotePath)
  {
  	String path = (_serverConfig.isUseHTTPS() ? "https" : "http") + "://" + _serverConfig.getServerName() + "/" + WEB_DAV_BASE_PATH + remotePath;

Sardine sardine = SardineFactory.begin();

      sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
      sardine.enablePreemptiveAuthentication(_serverConfig.getServerName());

      try {
          sardine.put(path, inputStream);
      } catch (IOException e) {
          throw new NextcloudApiException(e);
      }
  }
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void put(InputStream in, long length, String remotePath)
		throws Throwable {
	String url = PathUtil.join(_serverAddress, remotePath);
	String uri = URIEncoder.encode(url);
	Sardine sardine = getSardineInstance();
	try {
		if (length >= 0) {
			try {
				((SardineImpl) sardine).put(uri, new InputStreamEntity(in,
						length), null, false);
			} catch (SardineException e) {
				// log it in the server log.
				System.out.println("WebDav Error: " + e.getMessage());
				throw e;
			}
		} else {
			// unknown length. It will fail if the server requires
			// Content-Length.
			sardine.put(uri, in);
		}
	} finally {
		sardine.shutdown();
	}
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void deleteDocument(String filePath)throws Exception 
{
    
    if(filePath == null)
    {
        throw new Exception("The filepath is not vaild");
    }
    else
    {
        try {
            String fileUrl = "" + apiRepositoryUrl + filePath;

            if(projectExists(fileUrl))
            {
                Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                method.delete(fileUrl);
            }
        } 
        catch (IOException ioe) 
        {
             String error = "Could not delete the document in the repository because : " + ioe.getMessage();
             throw new Exception( error, ioe );
        }
  }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void ingest() {
    long failedRecordsCount = 0;
    Sardine sardine = null;
    try {
        sardine = SardineFactory.begin();
        failedRecordsCount = processWebdavFolder(sardine, ingest.getActualUrl());
    } catch (Exception e) {
        saveException(e, IngestReportErrorType.SYSTEM_ERROR);
    } finally {
        if (sardine != null) {
            sardine.shutdown();
        }
    }
    report.setFailedRecordsCount(failedRecordsCount);
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * Checks if the folder at the specified path exists
 *
 * @param rootPath path of the folder
 * @return true if the folder exists
 */
public boolean exists(String rootPath)
{
    String path=  (_serverConfig.isUseHTTPS() ? "https" : "http") +"://"+_serverConfig.getServerName()+"/"+WEB_DAV_BASE_PATH+rootPath ;

    Sardine sardine = SardineFactory.begin();
    sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
    try {
        return sardine.exists(path);
    } catch (IOException e) {
        throw new NextcloudApiException(e);
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * Creates a folder at the specified path
 *
 * @param rootPath path of the folder
 */
public void createFolder(String rootPath)
{
    String path=  (_serverConfig.isUseHTTPS() ? "https" : "http") +"://"+_serverConfig.getServerName()+"/"+WEB_DAV_BASE_PATH+rootPath ;

    Sardine sardine = SardineFactory.begin();
    sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
    try {
        sardine.createDirectory(path);
    } catch (IOException e) {
        throw new NextcloudApiException(e);
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * Deletes the folder at the specified path
 *
 * @param rootPath path of the folder
 */
public void deleteFolder(String rootPath)
{
    String path=  (_serverConfig.isUseHTTPS() ? "https" : "http") +"://"+_serverConfig.getServerName()+"/"+WEB_DAV_BASE_PATH+rootPath ;

    Sardine sardine = SardineFactory.begin();
    sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
    try {
        sardine.delete(path);
    } catch (IOException e) {
        throw new NextcloudApiException(e);
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * method to check if a file already exists
 * 
 * @param rootPath path of the file
 * @return boolean value if the given file exists or not
 */
public boolean fileExists(String rootPath){
	String path = (_serverConfig.isUseHTTPS() ? "https" : "http") + "://" + _serverConfig.getServerName() + "/" + WEB_DAV_BASE_PATH + rootPath;
	
	Sardine sardine = SardineFactory.begin();
	
	sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
	sardine.enablePreemptiveAuthentication(_serverConfig.getServerName());
	
	try {
		return sardine.exists(path);
	} catch (IOException e) {
		throw new NextcloudApiException(e);
	}
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
/**
 * method to remove files
 * @param rootPath path of the file which should be removed
 */
public void removeFile(String rootPath) {
	String path = (_serverConfig.isUseHTTPS() ? "https" : "http") + "://" + _serverConfig.getServerName() + "/" + WEB_DAV_BASE_PATH + rootPath;
	
	Sardine sardine = SardineFactory.begin();
	
	sardine.setCredentials(_serverConfig.getUserName(), _serverConfig.getPassword());
       sardine.enablePreemptiveAuthentication(_serverConfig.getServerName());
	try {
		sardine.delete(path);
	} catch ( IOException e ) {
		throw new NextcloudApiException(e);
	}
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public InputStream get(String remotePath) throws Throwable {
	String url = PathUtil.join(_serverAddress, remotePath);
	String uri = URIEncoder.encode(url);
	Sardine sardine = getSardineInstance();
	InputStream in = null;
	try {
		in = sardine.get(uri);
	} finally {
		sardine.shutdown();
	}
	return in;
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void mkdir(String remotePath, boolean parents) throws Throwable {
	if (remotePath == null) {
		return;
	}
	remotePath = remotePath.trim();
	if (remotePath.isEmpty() || remotePath.equals("/")) {
		return;
	}
	remotePath = PathUtil.trimTrailingSlash(remotePath);
	String url = PathUtil.join(_serverAddress,
			PathUtil.appendSlash(remotePath));
	String uri = URIEncoder.encode(url);
	if (exists(uri)) {
		// already exists
		return;
	}
	Sardine sardine = getSardineInstance();
	if (parents) {
		// create parent directories. If parent directories do not exist and
		// you will not be able to create the child directory.
		mkdir(PathUtil.getParentDirectory(remotePath, true), true);
	}
	try {
		sardine.createDirectory(uri);
	} catch (SardineException e) {
		String msg = e.getMessage();
		if (msg != null && msg.contains("405 Method Not Allowed")) {
			// NOTE: if http response 405, means the directory already
			// exists. That might be created by other threads.
			System.out
					.println("WebDAV Sink: HTTP Response: '405 Method Not Allowed' when creating directory "
							+ uri
							+ ". It indicates the directory already exists.");
		} else {
			// log it in the server log.
			System.out.println("WebDav Error: " + e.getMessage());
			throw e;
		}
	}
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void delete(String remotePath) throws Throwable {
	String url = PathUtil.join(_serverAddress, remotePath);
	String uri = URIEncoder.encode(url);
	Sardine sardine = getSardineInstance();
	sardine.delete(uri);
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void deleteComponentFeatureConfig ( String component, String feature) throws Exception
{
    if(component == null)
    {
        throw new Exception("Component is invalid");
    }
    else if(feature == null)
    {
        throw new Exception("Feature is not valid");
    }
    else
    {   
        String configUrl = "" + getProjectUrl() + "/" + component + "/" + feature + "/config.json";
        
        if(projectExists(configUrl))
        {
            try 
            {
                Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                method.delete( configUrl );
            
             } 
            catch (IOException ioe) 
            {
                 String error = "Could not delete the document in the repository because : " + ioe.getMessage();
                 throw new Exception( error, ioe );
            }   
        }
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void createComponentFeature (String component, String feature) throws Exception
{
    if(component == null)
    {
        throw new Exception("The component is invalid");
    }
    else if(feature == null)
    {
        throw new Exception("The feature is invalid");
    }
    else
    {   
        String componentUrl = "" + getProjectUrl() + "/" + component + "/";
        String componentFeatureUrl = "" + getProjectUrl() + "/" + component + "/" + feature + "/";
        
        if(!projectExists(componentFeatureUrl))
        {
            Sardine method =  SardineFactory.begin(apiUserName, apiPassword);
            try
           {
               if(!projectExists(componentUrl))
               {
                   method.createDirectory(componentUrl);
               }   
               
               method.createDirectory( componentFeatureUrl );                   
           }
           catch (IOException ioe)
           {
                String error = "Could add a new component feature because : " + ioe.getMessage();
                throw new Exception( error, ioe );
           }
            
        }
        
    }
    
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void createDefaultComponentFeature (String component, String feature) throws Exception
{
    if(component == null)
    {
        throw new Exception("The component is invalid");
    }
    else if(feature == null)
    {
        throw new Exception("The feature is invalid");
    }
    else
    {   
        String componentUrl = "" + apiDefaultPath + "/" + component + "/";
        String componentFeatureUrl = "" + apiDefaultPath + "/" + component + "/" + feature + "/";
        
        if(!projectExists(componentFeatureUrl))
        {
            Sardine method =  SardineFactory.begin(apiUserName, apiPassword);
            try
           {
               if(!projectExists(componentUrl))
               {
                   method.createDirectory(componentUrl);
               }   
               
               method.createDirectory( componentFeatureUrl );                   
           }
           catch (IOException ioe)
           {
                String error = "Could add a new component feature because : " + ioe.getMessage();
                throw new Exception( error, ioe );
           }
            
        }
        
    }
    
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void addDirectory(String directoryName) throws Exception
{
    if(directoryName == null)
    {
        throw new Exception("The directory name is invalid");
    }
    else
    {
    
        try {

             String directoryUrl = "" + apiRepositoryUrl + directoryName + "/";

             if(!projectExists(directoryUrl))
             {
                 Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                 method.createDirectory(directoryUrl);
             }
             else
             {
                 throw new Exception("A directory with this name already exists");
             }

        } 
        catch (IOException ioe) 
        {
            String error = "Could add a new directory because : " + ioe.getMessage();
            throw new Exception( error, ioe );
        }
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
    public void deleteDirectory(String directoryName)throws Exception 
    {
        if(directoryName == null)
        {
            throw new Exception("The directory name is invalid");
        }
        else
        {
            try {

                 String directoryUrl = "" + apiRepositoryUrl + directoryName + "/";

                 if(projectExists(directoryUrl))
                 {
                    Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                    method.delete(directoryUrl); 
                 }
                 else
                 {
                     throw new Exception("This directory does not exist");
                 }


            } 
            catch (IOException ioe) 
            {
                String error = "Could not delete the directory because : " + ioe.getMessage();
                throw new Exception( error, ioe );
            }
        }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void putDocument(String sourceFilePath, String destinationFilePath )throws Exception 
{
    
    if(sourceFilePath == null)
    {
        throw new Exception("The source file path is invalid");
    }
    else if(destinationFilePath == null)
    {
        throw new Exception("The destination file path is invalid");
    }
    else
    {
        String fileUrl = "" + apiRepositoryUrl + destinationFilePath;
        try {
            if(!projectExists(fileUrl))
            {
                 Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                 byte[] data = FileUtils.readFileToByteArray(new File(sourceFilePath));
                 method.put(fileUrl, data);
            }
            else
            {
                throw new Exception("The configuration document exists");
            }

        } 
        catch (IOException ioe) 
        {
            String error = "Could not upload the document to the repository because : " + ioe.getMessage();
            throw new Exception( error, ioe );
        }
    }
}
 

import com.github.sardine.Sardine; //导入依赖的package包/类
@Override
public void moveDocument(String sourceFilePath, String destinationFilePath) throws Exception
{
    if(sourceFilePath == null)
    {
        throw new Exception("The source filepath is not valid");
    }
    else if (destinationFilePath == null)
    {
        throw new Exception("The destination filepath is not valid");
    }
    else
    {
        try {
             String sourceUrl = "" + apiRepositoryUrl + sourceFilePath;
             String destinationUrl = "" + apiRepositoryUrl + destinationFilePath;

             if(projectExists(sourceUrl))
             {
                 Sardine method = SardineFactory.begin(apiUserName, apiPassword);
                 method.move(sourceUrl, destinationUrl); 
             }

        } 
        catch (IOException ioe) 
        {
             String error = "Could not move the document because : " + ioe.getMessage();
             throw new Exception( error, ioe );
        }
    }
}