/**
    * Standard Portlet Collection Project 7 
    * open source portlets every community needs
    *
    * Copyright (C) 2007  Phillip Merensky (phillip23@users.sourceforge.net)
    *
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package spcp7.imagegallery.impl.alfresco;
  
  import java.rmi.RemoteException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.Map;
  
  import org.alfresco.webservice.authentication.AuthenticationFault;
  import org.alfresco.webservice.repository.QueryResult;
  import org.alfresco.webservice.repository.RepositoryFault;
  import org.alfresco.webservice.repository.RepositoryServiceSoapBindingStub;
  import org.alfresco.webservice.repository.UpdateResult;
  import org.alfresco.webservice.types.CML;
  import org.alfresco.webservice.types.CMLCreate;
  import org.alfresco.webservice.types.CMLDelete;
  import org.alfresco.webservice.types.NamedValue;
  import org.alfresco.webservice.types.Node;
  import org.alfresco.webservice.types.ParentReference;
  import org.alfresco.webservice.types.Predicate;
  import org.alfresco.webservice.types.Query;
  import org.alfresco.webservice.types.Reference;
  import org.alfresco.webservice.types.ResultSet;
  import org.alfresco.webservice.types.ResultSetRow;
  import org.alfresco.webservice.types.Store;
  import org.alfresco.webservice.util.AuthenticationUtils;
  import org.alfresco.webservice.util.Constants;
  import org.alfresco.webservice.util.Utils;
  import org.alfresco.webservice.util.WebServiceFactory;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.beans.BeansException;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.ApplicationContextAware;
  
  import spcp7.imagegallery.abstractionlayer.enums.DefaultProperties;
  import spcp7.imagegallery.abstractionlayer.exception.ContentCouldNotBeAccessedException;
  import spcp7.imagegallery.abstractionlayer.exception.ContentProviderAuthenticationException;
  import spcp7.imagegallery.abstractionlayer.exception.NoContentFoundException;
  import spcp7.imagegallery.abstractionlayer.exception.PropertyValidationException;
  import spcp7.imagegallery.abstractionlayer.exception.RangeNotValidException;
  import spcp7.imagegallery.abstractionlayer.face.ContentFace;
  import spcp7.imagegallery.abstractionlayer.face.ImageFilterFace;
  import spcp7.imagegallery.abstractionlayer.face.persistence.PropertyModelFace;
  import spcp7.imagegallery.abstractionlayer.util.GeneralValidation;
  import spcp7.imagegallery.abstractionlayer.util.StandardUtils;
  import spcp7.imagegallery.contentprovider.face.ContentRetrievalFace;
  import spcp7.imagegallery.contentprovider.face.ContentSubmitterFace;
  import spcp7.imagegallery.impl.alfresco.utils.AlfrescoDefaultProperties;
  import spcp7.imagegallery.impl.alfresco.utils.AlfrescoUtils;
  import spcp7.imagegallery.impl.alfresco.utils.AlfrescoValidation;
  
  /**
   * Implementation of an Alfresco content provider.
   * 
   * @author Phillip Merensky
   * 
   */
  public class AlfrescoContentRetrievalImpl implements ContentRetrievalFace,
  	ApplicationContextAware {
      private Log log = LogFactory.getLog(AlfrescoContentRetrievalImpl.class);
  
      private RepositoryServiceSoapBindingStub repositoryService;
      private Comparator<ContentFace> contentComparator;
      private ImageFilterFace imageFilterFace;
      private AlfrescoValidation alfrescoValidation;
  
      private AlfrescoUtils alfrescoUtils;
  
      private GeneralValidation generalValidation;
  
      private ApplicationContext applicationContext;
  
      // TODO DOC adaption to other document styles
  
      /**
       * Empty standard constructor
       */
      public AlfrescoContentRetrievalImpl() {
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see spcp.imagegallery.abstractionlayer.face.external.ContentConnectionFace#close()
      */
     public void close() {
 	// End the session
 	AuthenticationUtils.endSession();
     }
 
     /**
      * This method and {@link #removeFolder(String, Map)} are currently only for
      * testing purposes. That is for inserting and deleting test content. Later
      * they could be used within a class implementing the
      * {@link ContentSubmitterFace} for example.
      * 
      * @param name
      *                The name of the folder
      * @param properties
      *                The following properties are required:
      *                {@link AlfrescoDefaultProperties#ALFRESCO_SPACES_STORE},
      *                {@link AlfrescoDefaultProperties#ALFRESCO_WORKSPACE_STORE},
      *                {@link DefaultProperties#SPCP7_CURRENT_PATH}
      * @return The id of the new folder *
      * @throws ContentCouldNotBeAccessedException
      *                 if the folder could not be deleted or the repository
      *                 could not be reached.
      */
     public synchronized String createFolder(String name,
 	    Map<String, PropertyModelFace> properties)
 	    throws ContentCouldNotBeAccessedException {
 
 	Store store = new Store(properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_WORKSPACE_STORE.toString())
 		.getWert(), properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_SPACES_STORE.toString())
 		.getWert());
 	String basepath = properties.get(
 		DefaultProperties.SPCP7_CURRENT_PATH.toString()).getWert();
 	String folderToCreateQName = Constants.createQNameString(
 		Constants.NAMESPACE_CONTENT_MODEL, name);
 	Reference folderToCreateReference = new Reference(store, null,
 		this.alfrescoUtils.normalizePathNamespace(basepath
 			+ "/"
 			+ Constants.createQNameString(
 				Constants.NAMESPACE_CONTENT_MODEL, name),
 			properties));
 	// Check to see if the sample folder has already been created or not
 	try {
 	    @SuppressWarnings("unused")
 	    Node[] node = WebServiceFactory.getRepositoryService().get(
 		    new Predicate(new Reference[] { folderToCreateReference },
 			    store, null));
 	} catch (Exception e1) {
 	    // Folder does not yet exist!
 	    UpdateResult[] results = null;
 	    // Create parent reference to company home
 	    ParentReference parentReference = new ParentReference(store, null,
 		    basepath, Constants.ASSOC_CONTAINS, folderToCreateQName);
 
 	    // Create folder
 	    NamedValue[] folderProperties = new NamedValue[] { Utils
 		    .createNamedValue(Constants.PROP_NAME, name) };
 	    CMLCreate create = new CMLCreate("1", parentReference, null, null,
 		    null, Constants.TYPE_FOLDER, folderProperties);
 	    CML cml = new CML();
 	    cml.setCreate(new CMLCreate[] { create });
 	    try {
 		results = this.repositoryService.update(cml);
 		return results[0].getDestination().getUuid();
 	    } catch (RepositoryFault e) {
 		// We print a stacktrace at this point and throw an exception
 		// because the detail data of the axisfault gets lost otherwise
 		e.printStackTrace();
 		throw new ContentCouldNotBeAccessedException(
 			"The repository threw an exception when trying to create a folder!",
 			e);
 	    } catch (RemoteException e) {
 		throw new ContentCouldNotBeAccessedException(
 			"The repository could not be reached when trying to create a folder!",
 			e);
 	    }
 	}
 	throw new ContentCouldNotBeAccessedException(
 		"The folder which should be created already exists!");
     }
 
     // TODO test method
 
     /**
      * Additionally to the properties mentioned in the interface
      * {@link AlfrescoDefaultProperties#ALFRESCO_MAX_RESULT_ROWS},
      * {@link AlfrescoDefaultProperties#ALFRESCO_SPACES_STORE} and
      * {@link AlfrescoDefaultProperties#ALFRESCO_WORKSPACE_STORE} properties are
      * needed.
      * 
      * @see spcp7.imagegallery.contentprovider.face.ContentRetrievalFace#getParent(spcp7.imagegallery.abstractionlayer.face.ContentFace,
      *      java.util.Map)
      */
     public synchronized ContentFace getParent(String proprietaryId,
 	    Map<String, PropertyModelFace> properties)
 	    throws ContentCouldNotBeAccessedException, NoContentFoundException {
 	List<ContentFace> retList = null;
 	if (proprietaryId != null) {
 	    String queryString = "+ISNODE:T +ID:\""
 		    + properties.get(
 			    AlfrescoDefaultProperties.ALFRESCO_WORKSPACE_STORE
 				    .toString()).getWert()
 		    + "://"
 		    + properties.get(
 			    AlfrescoDefaultProperties.ALFRESCO_SPACES_STORE
 				    .toString()).getWert() + "/"
 		    + proprietaryId + "\"";
 	    Store store = new Store(properties.get(
 		    AlfrescoDefaultProperties.ALFRESCO_WORKSPACE_STORE
 			    .toString()).getWert(), properties.get(
 		    AlfrescoDefaultProperties.ALFRESCO_SPACES_STORE.toString())
 		    .getWert());
 	    ResultSet resultSet = executeQuery(queryString, properties);
 	    ResultSetRow[] rows = resultSet.getRows();
 	    if (rows.length > 0) {
 
 		// Get the id of the first result
 		String firstResultId = rows[0].getNode().getId();
 		Reference reference = new Reference(store, firstResultId, null);
 
 		// Get the parent(s) of the first result
 		QueryResult parentQueryResult = null;
 		try {
 		    parentQueryResult = this.repositoryService
 			    .queryParents(reference);
 		} catch (RepositoryFault e) {
 		    throw new ContentCouldNotBeAccessedException(
 			    "The repository threw an exception when trying to get the parent!",
 			    e);
 		} catch (RemoteException e) {
 		    throw new ContentCouldNotBeAccessedException(
 			    "The repository could not be reached when trying to get the parent!!",
 			    e);
 		}
 		if (parentQueryResult != null) {
 		    retList = transformResultSet(properties, parentQueryResult
 			    .getResultSet(), 1, Integer.valueOf(properties.get(
 			    AlfrescoDefaultProperties.ALFRESCO_MAX_RESULT_ROWS
 				    .toString()).getWert()));
 		}
 		if (retList != null && retList.size() > 0) {
 		    return retList.get(0);
 		}
 	    } else {
 		throw new ContentCouldNotBeAccessedException(
 			"The specified parent could not be found");
 	    }
 	}
 	return null;
     }
 
     /**
      * Additionally to the properties mentioned in the interface
      * {@link AlfrescoDefaultProperties#ALFRESCO_MAX_RESULT_ROWS},
      * {@link AlfrescoDefaultProperties#ALFRESCO_SPACES_STORE} and
      * {@link AlfrescoDefaultProperties#ALFRESCO_WORKSPACE_STORE} properties are
      * needed.
      * 
      * @see spcp.imagegallery.abstractionlayer.face.external.ContentRetrievalFace#getVolumes(java.lang.String)
      */
     public synchronized List<ContentFace> getVolumes(
 	    Map<String, PropertyModelFace> properties, boolean isFolder)
 	    throws PropertyValidationException,
 	    ContentCouldNotBeAccessedException, NoContentFoundException {
 	List<ContentFace> retList = null;
 	try {
 	    retList = getVolumesFromTo(1, Integer.valueOf(properties.get(
 		    AlfrescoDefaultProperties.ALFRESCO_MAX_RESULT_ROWS
 			    .toString()).getWert()), properties, isFolder);
 	} catch (NumberFormatException e) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "Volumes could not be retrieved.", e);
 	} catch (RangeNotValidException e) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "Volumes could not be retrieved.", e);
 	}
 	if (retList == null) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "Volumes could not be retrieved.");
 	}
 	return retList;
     }
 
     /**
      * Additionally to the properties mentioned in the interface
      * {@link AlfrescoDefaultProperties#ALFRESCO_MAX_RESULT_ROWS},
      * {@link AlfrescoDefaultProperties#ALFRESCO_SPACES_STORE} and
      * {@link AlfrescoDefaultProperties#ALFRESCO_WORKSPACE_STORE} properties are
      * needed.
      * 
      * @see spcp7.imagegallery.contentprovider.face.ContentRetrievalFace#getVolumesFromTo(int,
      *      int, java.util.Map, boolean)
      */
     public synchronized List<ContentFace> getVolumesFromTo(int lowerLimit,
 	    int upperLimit, Map<String, PropertyModelFace> properties,
 	    boolean isFolder) throws RangeNotValidException,
 	    PropertyValidationException, ContentCouldNotBeAccessedException,
 	    NoContentFoundException {
 	List<ContentFace> retList = null;
 	this.generalValidation.validateRange(lowerLimit, upperLimit);
 	// validate properties
 	this.alfrescoValidation.validateAlfrescoQueryProperties(properties);
 	// The path must not end with a slash. If it does we do not only find
 	// folders and documents directly below the current folder but also
 	// of documents below all subfolders of the current folder
 	while (properties.get(DefaultProperties.SPCP7_CURRENT_PATH.toString())
 		.getWert().endsWith("/")) {
 	    PropertyModelFace prop = properties
 		    .get(DefaultProperties.SPCP7_CURRENT_PATH.toString());
 	    prop.setWert(prop.getWert().substring(0,
 		    prop.getWert().length() - 1));
 	    properties.put(DefaultProperties.SPCP7_CURRENT_PATH.toString(),
 		    prop);
 	}
 	String encodedPath = this.alfrescoUtils
 		.encodeAlfrescoAbbreviatedPathISO9075(properties.get(
 			DefaultProperties.SPCP7_CURRENT_PATH.toString())
 			.getWert());
 	String queryString = "+PATH:\"" + encodedPath;
 	if (isFolder) {
 	    // If we search for content within a folder, we look for subcontent
 	    queryString += "/*\"";
 	} else {
 	    // else we look eg for a single image and thus we only close quotes
 	    queryString += "\"";
 	}
 	ResultSet resultSet = executeQuery(queryString, properties);
 	retList = transformResultSet(properties, resultSet, lowerLimit,
 		upperLimit);
 	if (retList != null && this.contentComparator != null) {
 	    Collections.sort(retList, this.contentComparator);
 	}
 	return retList;
     }
 
 
     /**
      * Additionally to the properties mentioned in the interface
      * {@link AlfrescoDefaultProperties#ALFRESCO_USERNAME} and
      * {@link AlfrescoDefaultProperties#ALFRESCO_PASSWORD} properties are
      * needed.
      * 
      * @see spcp7.imagegallery.contentprovider.face.ContentConnectionFace#open(java.util.Map)
      */
     public void open(Map<String, PropertyModelFace> properties)
 	    throws PropertyValidationException,
 	    ContentProviderAuthenticationException {
 	if (!properties.containsKey(AlfrescoDefaultProperties.ALFRESCO_USERNAME
 		.toString())) {
 	    throw new PropertyValidationException("Property "
 		    + AlfrescoDefaultProperties.ALFRESCO_USERNAME.toString()
 		    + " not found", AlfrescoDefaultProperties.ALFRESCO_USERNAME
 		    .toString(), "not set");
 
 	}
 	if (!properties.containsKey(AlfrescoDefaultProperties.ALFRESCO_PASSWORD
 		.toString())) {
 	    throw new PropertyValidationException("Property "
 		    + AlfrescoDefaultProperties.ALFRESCO_PASSWORD.toString()
 		    + " not found", AlfrescoDefaultProperties.ALFRESCO_PASSWORD
 		    .toString(), "not set");
 
 	}
 	// Start the session
 	try {
 	    AuthenticationUtils.startSession(properties.get(
 		    AlfrescoDefaultProperties.ALFRESCO_USERNAME.toString())
 		    .getWert(), properties.get(
 		    AlfrescoDefaultProperties.ALFRESCO_PASSWORD.toString())
 		    .getWert());
 	} catch (AuthenticationFault e) {
 	    throw new ContentProviderAuthenticationException(
 		    "Authentication with the content provider failed! Maybe you provided wrong credentials. If so"
 			    + " change property \""
 			    + AlfrescoDefaultProperties.ALFRESCO_USERNAME
 				    .toString()
 			    + "\" and \""
 			    + AlfrescoDefaultProperties.ALFRESCO_USERNAME
 				    .toString() + "\" to correct values.", e,
 		    AlfrescoContentProviderImpl.contentProviderTypeID);
 	}
 	// Get a reference to the respository web service
 	this.repositoryService = WebServiceFactory.getRepositoryService();
     }
 
     /**
      * This method and {@link #createFolder(String, Map)} are currently only for
      * testing purposes. That is for inserting and deleting test content. Later
      * they could be used within a class implementing the
      * {@link ContentSubmitterFace}. The key
      * {@link DefaultProperties#SPCP7_CURRENT_PATH} defines the foldr which
      * should be deleted.
      * 
      * @param properties
      *                The following properties are required:
      *                {@link AlfrescoDefaultProperties#ALFRESCO_SPACES_STORE},
      *                {@link AlfrescoDefaultProperties#ALFRESCO_WORKSPACE_STORE},
      *                {@link DefaultProperties#SPCP7_CURRENT_PATH}
      * @throws ContentCouldNotBeAccessedException
      *                 if the folder could not be deleted or the repository
      *                 could not be reached.
      */
     public synchronized void removeFolder(
 	    Map<String, PropertyModelFace> properties)
 	    throws ContentCouldNotBeAccessedException {
 	if (properties == null) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "ProprietaryId and/or supplied properties must not be null!");
 	}
 	Store store = new Store(properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_WORKSPACE_STORE.toString())
 		.getWert(), properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_SPACES_STORE.toString())
 		.getWert());
 	PropertyModelFace currentPath = properties
 		.get(DefaultProperties.SPCP7_CURRENT_PATH.toString());
 	Reference folderToDeleteReference = new Reference(store, null,
 		currentPath.getWert());
 	// Check to see if the folder exists
 	Node[] node = null;
 	try {
 	    node = WebServiceFactory.getRepositoryService().get(
 		    new Predicate(new Reference[] { folderToDeleteReference },
 			    store, null));
 	} catch (Exception e1) {
 	    // The folder does not exist
 	    // We do nothing
 	    log.debug("We do nothing because the folder does not exist");
 	}
 	if (node != null) {
 	    // UpdateResult[] results = null;
 	    Predicate predicate = new Predicate();
 	    predicate.setStore(store);
 	    // Reference ref = new Reference();
 	    // ref.setStore(store);
 	    // ref.setPath(currentPath.getWert());
 	    predicate.setNodes(new Reference[] { folderToDeleteReference });
 
 	    // delete Folder
 	    CML cml = new CML();
 	    CMLDelete cmldelete = new CMLDelete();
 	    cmldelete.setWhere(predicate);
 	    cml.setDelete(new CMLDelete[] { cmldelete });
 
 	    try {
 		this.repositoryService.update(cml);
 	    } catch (RepositoryFault e) {
 		// We print a stacktrace at this point AND throw an exception
 		// because otherwise the detail data of the axisfault gets lost
 		e.printStackTrace();
 		throw new ContentCouldNotBeAccessedException(
 			"The repository threw an exception when trying to delete a folder!",
 			e);
 	    } catch (RemoteException e) {
 		throw new ContentCouldNotBeAccessedException(
 			"The repository could not be reached when trying to delete a folder!",
 			e);
 	    }
 	}
 
     }
 
     /**
      * Injected by Spring.
      * 
      * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
      */
     public void setApplicationContext(ApplicationContext arg0)
 	    throws BeansException {
 	this.applicationContext = arg0;
     }
 
     /**
      * Injected by Spring.
      * 
      * @param contentComparator
      *                the contentComparator to set
      */
     public void setContentComparator(Comparator<ContentFace> contentComparator) {
 	this.contentComparator = contentComparator;
     }
 
     /**
      * Injected by Spring.
      * 
      * @param imageFilterFace
      *                the imageFilterFace to set
      */
     public void setImageFilter(ImageFilterFace imageFilterFace) {
 	this.imageFilterFace = imageFilterFace;
     }
 
     private ResultSet executeQuery(String queryString,
 	    Map<String, PropertyModelFace> properties)
 	    throws ContentCouldNotBeAccessedException, NoContentFoundException {
 	ResultSet resultSet = null;
 	Store store = new Store(properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_WORKSPACE_STORE.toString())
 		.getWert(), properties.get(
 		AlfrescoDefaultProperties.ALFRESCO_SPACES_STORE.toString())
 		.getWert());
 	// encode the string the right way so that we find everything
 	log.debug("getting volumes from query \"" + queryString + "\"");
 	Query query = new Query(Constants.QUERY_LANG_LUCENE, queryString);
 	// Execute the query
 	QueryResult queryResult;
 	try {
 	    queryResult = this.repositoryService.query(store, query, false);
 	    // organize the results
 	    resultSet = queryResult.getResultSet();
 	} catch (RepositoryFault e) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "The repository threw an Exception when trying to execute a query!",
 		    e);
 	} catch (RemoteException e) {
 	    throw new ContentCouldNotBeAccessedException(
 		    "The repository could not be reached when trying to execute a query!",
 		    e);
 	}
 	if (resultSet.getRows() == null) {
 	    throw new NoContentFoundException(
 		    "No volumes at given path found!", queryString);
 	}
 	return resultSet;
     }
 
     private List<ContentFace> transformResultSet(
 	    Map<String, PropertyModelFace> properties, ResultSet resultSet,
 	    int lowerLimit, int upperLimit) {
 	List<ContentFace> retList = new ArrayList<ContentFace>();
 	ResultSetRow[] rows = resultSet.getRows();
 	if (rows == null) {
 	    // Exception is handled before. Only for preventing nullpointers
 	    // Normally this should never be reached
 	    log.warn("No volumes for query found!");
 	} else {
 	    if (rows.length < upperLimit) {
 		upperLimit = rows.length;
 	    }
 	    if (rows.length < lowerLimit) {
 		lowerLimit = rows.length;
 	    }
 	    // Regrettably the webservice api from alfresco does not allow a
 	    // lucene limitation of results, so we have to do this manually
 	    for (int x = lowerLimit - 1; x < upperLimit; x++) {
 		ResultSetRow row = rows[x];
 		NamedValue[] columns = row.getColumns();
 		ContentFace cf = (ContentFace) this.applicationContext
 			.getBean("ContentDTO");
 		cf.setDirectory(true);
 		for (int y = 0; y < columns.length; y++) {
 		    if (row.getColumns(y).getName().endsWith("node-uuid")) {
 			cf.setProprietaryId(row.getColumns(y).getValue());
 		    } else if (row.getColumns(y).getName().endsWith("name")) {
 			cf.setName(row.getColumns(y).getValue());
 		    } else if (row.getColumns(y).getName().endsWith("path")) {
 			cf.setPath(this.alfrescoUtils.normalizePathNamespace(
 				row.getColumns(y).getValue(), properties));
 		    } else if (row.getColumns(y).getName().endsWith("content")) {
 			cf.setDirectory(false);
 			if (this.imageFilterFace != null) {
 			    if (this.imageFilterFace.acceptImageMimetype(row
 				    .getColumns(y).getValue())) {
 				cf.setImage(true);
 			    } else {
 				// Maybe the mimetype was not correctly set.
 				if (this.imageFilterFace.accept(cf.getName())) {
 				    cf.setImage(true);
 				}
 			    }
 			}
 		    }
 		    cf.setParentContentFolderProperties(StandardUtils
 			    .deepCopy(properties));
 		    cf
 			    .setContentProviderTypeId(AlfrescoContentProviderImpl.contentProviderTypeID);
 		}
 		cf.setUrl(properties.get(
 			AlfrescoDefaultProperties.ALFRESCO_BASE_URL.toString())
 			.getWert()
 			+ "/" + cf.getProprietaryId() + "/" + cf.getName());
 		String[] splitName = cf.getName().split("\\.");
 		cf.setFileExtension(splitName[splitName.length - 1]);
 		retList.add(cf);
 		// }
 	    }
 	}
 	return retList;
     }
 
     /**
      * Injected by Spring.
      * 
      * @param alfrescoValidation
      *                the alfrescoValidation to set
      */
     public void setAlfrescoValidation(AlfrescoValidation alfrescoValidation) {
 	this.alfrescoValidation = alfrescoValidation;
     }
 
     /**
      * Injected by Spring.
      * 
      * @param generalValidation
      *                the generalValidation to set
      */
     public void setGeneralValidation(GeneralValidation generalValidation) {
 	this.generalValidation = generalValidation;
     }
 
     /**
      * Injected by Spring.
      * 
      * @param alfrescoUtils
      *                the alfrescoUtils to set
      */
     public void setAlfrescoUtils(AlfrescoUtils alfrescoUtils) {
 	this.alfrescoUtils = alfrescoUtils;
     }
 
 }