Java BaseCredentialsInfo類代碼示例

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public void deleteCredentials(BaseCredentialsInfo credentialsInfo)
{
    if (credentialsInfo.getNodeRef() == null)
    {
        throw new IllegalArgumentException("Cannot delete Credentials which haven't been persisted yet!");
    }
    nodeService.deleteNode(credentialsInfo.getNodeRef());
    
    if (logger.isDebugEnabled())
        logger.debug("Deleted credentials " + credentialsInfo + " from " + credentialsInfo.getNodeRef() + 
                     " from Remote System " + credentialsInfo.getRemoteSystemName());
    
    // Leave the Remote System Container, in case special permissions
    //  were previously applied to it that should be retained
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public BaseCredentialsInfo getPersonCredentials(String remoteSystem)
{
    NodeRef personContainer = getPersonContainer(remoteSystem, false);
    if (personContainer == null) return null;

    // Grab the children
    List<ChildAssociationRef> credentials = 
        nodeService.getChildAssocs(personContainer, RemoteCredentialsModel.ASSOC_CREDENTIALS, RegexQNamePattern.MATCH_ALL);
    if (credentials.size() > 0)
    {
        NodeRef nodeRef = credentials.get(0).getChildRef();
        return loadCredentials(remoteSystem, personContainer, nodeRef);
    }
    return null;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
private BaseCredentialsInfo loadCredentials(String remoteSystem, NodeRef remoteSystemNodeRef, NodeRef credentialsNodeRef)
{
    QName type = nodeService.getType(credentialsNodeRef);
    RemoteCredentialsInfoFactory factory = credentialsFactories.get(type);
    if (factory == null)
    {
        throw new TypeConversionException("No Factory registered for type " + type);
    }
    
    // Wrap as an object
    return factory.createCredentials(
            type, credentialsNodeRef,
            remoteSystem, remoteSystemNodeRef,
            nodeService.getProperties(credentialsNodeRef)
    );
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
/**
 * Serializes the given {@link BaseCredentialsInfo} object to node properties.
 * 
 * @param info The Credentials object to serialize
 * @return The final set of properties to be serialized for the node
 */
public Map<QName,Serializable> serializeCredentials(BaseCredentialsInfo info)
{
    if (! (info instanceof PasswordCredentialsInfo))
    {
        throw new IllegalStateException("Incorrect registration, info must be a PasswordCredentialsInfo");
    }
    
    // Encrypt the password
    PasswordCredentialsInfo credentials = (PasswordCredentialsInfo)info;
    Serializable passwordEncrypted = metadataEncryptor.encrypt(
            RemoteCredentialsModel.PROP_REMOTE_PASSWORD, credentials.getRemotePassword());

    // Store our specific types and return
    Map<QName,Serializable> properties = new HashMap<QName, Serializable>();
    properties.put(RemoteCredentialsModel.PROP_REMOTE_PASSWORD, passwordEncrypted);
    return properties;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
/**
 * Serializes the given {@link BaseCredentialsInfo} object to node properties.
 * 
 * @param info The Credentials object to serialize
 * @return The final set of properties to be serialized for the node
 */
public Map<QName,Serializable> serializeCredentials(BaseCredentialsInfo info)
{
    if (! (info instanceof OAuth2CredentialsInfo))
    {
        throw new IllegalStateException("Incorrect registration, info must be a OAuth2CredentialsInfo");
    }
    
    // Encrypt the token details
    OAuth2CredentialsInfo credentials = (OAuth2CredentialsInfo)info;
    
    Serializable accessTokenEncrypted = metadataEncryptor.encrypt(
            RemoteCredentialsModel.PROP_OAUTH2_ACCESS_TOKEN, credentials.getOAuthAccessToken());
    Serializable refreshTokenEncrypted = metadataEncryptor.encrypt(
            RemoteCredentialsModel.PROP_OAUTH2_REFRESH_TOKEN, credentials.getOAuthRefreshToken());

    // Store our specific types and return
    Map<QName,Serializable> properties = new HashMap<QName, Serializable>();
    properties.put(RemoteCredentialsModel.PROP_OAUTH2_ACCESS_TOKEN, accessTokenEncrypted);
    properties.put(RemoteCredentialsModel.PROP_OAUTH2_REFRESH_TOKEN, refreshTokenEncrypted);
    properties.put(RemoteCredentialsModel.PROP_OAUTH2_TOKEN_ISSUED_AT, credentials.getOAuthTicketIssuedAt());
    properties.put(RemoteCredentialsModel.PROP_OAUTH2_TOKEN_EXPIRES_AT, credentials.getOAuthTicketExpiresAt());
    return properties;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
/**
 * Serializes the given {@link BaseCredentialsInfo} object to node properties.
 * 
 * @param info The Credentials object to serialize
 * @return The final set of properties to be serialized for the node
 */
public Map<QName,Serializable> serializeCredentials(BaseCredentialsInfo info)
{
    if (! (info instanceof OAuth1CredentialsInfo))
    {
        throw new IllegalStateException("Incorrect registration, info must be a OAuth1CredentialsInfo");
    }
    
    // Encrypt the details
    OAuth1CredentialsInfo credentials = (OAuth1CredentialsInfo)info;
    
    Serializable tokenEncrypted = metadataEncryptor.encrypt(
            RemoteCredentialsModel.PROP_OAUTH1_TOKEN, credentials.getOAuthToken());
    Serializable secretEncrypted = metadataEncryptor.encrypt(
            RemoteCredentialsModel.PROP_OAUTH1_TOKEN_SECRET, credentials.getOAuthSecret());

    // Store our specific types and return
    Map<QName,Serializable> properties = new HashMap<QName, Serializable>();
    properties.put(RemoteCredentialsModel.PROP_OAUTH1_TOKEN, tokenEncrypted);
    properties.put(RemoteCredentialsModel.PROP_OAUTH1_TOKEN_SECRET, secretEncrypted);
    return properties;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
private BaseCredentialsInfo createCredentials(String remoteSystem, NodeRef remoteSystemNodeRef, BaseCredentialsInfo credentials)
{
    if (credentials.getNodeRef() != null)
    {
        throw new IllegalArgumentException("Cannot create Credentials which have already been persisted!");
    }
    
    // Check we know about the type
    RemoteCredentialsInfoFactory factory = credentialsFactories.get(credentials.getCredentialsType());
    if (factory == null)
    {
        throw new TypeConversionException("No Factory registered for type " + credentials.getCredentialsType());
    }
    
    // Build the properties
    Map<QName,Serializable> properties = RemoteCredentialsInfoFactory.FactoryHelper.getCoreCredentials(credentials);
    properties.putAll( factory.serializeCredentials(credentials) );
    
    // Generate a name for it, which will be unique and doesn't need updating
    QName name = QName.createQName(GUID.generate()); 
    
    // Add the node
    NodeRef nodeRef = nodeService.createNode(
            remoteSystemNodeRef, RemoteCredentialsModel.ASSOC_CREDENTIALS,
            name, credentials.getCredentialsType(), properties
    ).getChildRef();
    
    if (logger.isDebugEnabled())
        logger.debug("Created new credentials at " + nodeRef + " for " + remoteSystem + " in " + 
                     remoteSystemNodeRef + " of " + credentials);
    
    // Return the new object
    return factory.createCredentials(
            credentials.getCredentialsType(), nodeRef,
            remoteSystem, remoteSystemNodeRef,
            nodeService.getProperties(nodeRef)
    );
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public BaseCredentialsInfo updateCredentials(BaseCredentialsInfo credentials)
{
    if (credentials.getNodeRef() == null)
    {
        throw new IllegalArgumentException("Cannot update Credentials which haven't been persisted yet!");
    }
    
    RemoteCredentialsInfoFactory factory = credentialsFactories.get(credentials.getCredentialsType());
    if (factory == null)
    {
        throw new TypeConversionException("No Factory registered for type " + credentials.getCredentialsType());
    }
    
    // Grab the current set of properties
    Map<QName,Serializable> oldProps = nodeService.getProperties(credentials.getNodeRef());
    
    // Overwrite them with the credentials ones
    Map<QName,Serializable> props = new HashMap<QName,Serializable>(oldProps);
    props.putAll( RemoteCredentialsInfoFactory.FactoryHelper.getCoreCredentials(credentials) );
    props.putAll( factory.serializeCredentials(credentials) );
    
    // Store
    nodeService.setProperties(credentials.getNodeRef(), props);
    
    // For now, return as-is
    return credentials;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public BaseCredentialsInfo updateCredentialsAuthenticationSucceeded(boolean succeeded, BaseCredentialsInfo credentials)
{
    // We can't help with credentials that have never been stored
    if (credentials.getNodeRef() == null)
    {
        throw new IllegalArgumentException("Cannot update Credentials which haven't been persisted yet!");
    }
    
    // Return quickly if the credentials are already in the correct state 
    if (succeeded == credentials.getLastAuthenticationSucceeded())
    {
        return credentials;
    }

    
    // Do the update 
    nodeService.setProperty(credentials.getNodeRef(), RemoteCredentialsModel.PROP_LAST_AUTHENTICATION_SUCCEEDED, succeeded);
    
    // Update the object if we can
    if (credentials instanceof AbstractCredentialsImpl)
    {
        ((AbstractCredentialsImpl)credentials).setLastAuthenticationSucceeded(succeeded);
        return credentials;
    }
    else
    {
        // Need to re-load
        return loadCredentials(credentials.getRemoteSystemName(),
                credentials.getRemoteSystemContainerNodeRef(), credentials.getNodeRef());
    }
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public PagingResults<? extends BaseCredentialsInfo> listSharedCredentials(String remoteSystem,
        QName credentialsType, PagingRequest paging)
{
    // Get the container for that system
    NodeRef container = getSharedContainer(remoteSystem, false);
    if (container == null)
    {
        return new EmptyPagingResults<BaseCredentialsInfo>();
    }
    return listCredentials(new NodeRef[] {container}, remoteSystem, credentialsType, paging);
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public PagingResults<? extends BaseCredentialsInfo> listPersonCredentials(String remoteSystem,
        QName credentialsType, PagingRequest paging)
{
    // Get the container for that system
    NodeRef container = getPersonContainer(remoteSystem, false);
    if (container == null)
    {
        return new EmptyPagingResults<BaseCredentialsInfo>();
    }
    return listCredentials(new NodeRef[] {container}, remoteSystem, credentialsType, paging);
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
@Override
public PagingResults<? extends BaseCredentialsInfo> listAllCredentials(String remoteSystem, QName credentialsType,
        PagingRequest paging)
{
    NodeRef personContainer = getPersonContainer(remoteSystem, false);
    NodeRef systemContainer = getSharedContainer(remoteSystem, false);
    if (personContainer == null && systemContainer == null)
    {
        return new EmptyPagingResults<BaseCredentialsInfo>();
    }
    return listCredentials(new NodeRef[] {personContainer, systemContainer}, remoteSystem, credentialsType, paging);
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
private CredentialsPagingResults(List<ChildAssociationRef> refs, int size, boolean hasMore, String remoteSystem)
{
    this.size = size;
    this.hasMore = hasMore; 
    
    this.results = new ArrayList<BaseCredentialsInfo>(refs.size());
    for (ChildAssociationRef ref : refs)
    {
        this.results.add( loadCredentials(remoteSystem, ref.getParentRef(), ref.getChildRef()) );
    }
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
/**
 * Generates the core properties for a {@link BaseCredentialsInfo}
 */
public static Map<QName,Serializable> getCoreCredentials(BaseCredentialsInfo credentials)
{
    Map<QName,Serializable> properties = new HashMap<QName, Serializable>();
    properties.put(RemoteCredentialsModel.PROP_REMOTE_USERNAME, credentials.getRemoteUsername());
    properties.put(RemoteCredentialsModel.PROP_LAST_AUTHENTICATION_SUCCEEDED, credentials.getLastAuthenticationSucceeded());
    return properties;
}
 

import org.alfresco.service.cmr.remotecredentials.BaseCredentialsInfo; //導入依賴的package包/類
protected PasswordCredentialsInfo ensureCredentialsFound(String remoteSystemId, BaseCredentialsInfo credentails)
{
    // Check they exist, and are of the right type
    if (credentails == null)
    {
        throw new NoCredentialsFoundException(remoteSystemId);
    }
    if (! (credentails instanceof PasswordCredentialsInfo))
    {
        throw new AlfrescoRuntimeException("Credentials found, but of the wrong type, needed PasswordCredentialsInfo but got " + credentails); 
    }
    return (PasswordCredentialsInfo)credentails;
}