import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
@Transactional(
    readOnly = false,
    propagation = Propagation.REQUIRED
)
public RemoteUser createRemoteUser(String userId, String providerId, String providerUserId, int rank, String displayName, String profileUrl, String imageUrl, String accessToken, String secret, String refreshToken, Long expireTime) {
    AbstractUserConnection remoteUser = this.createNewUserConnection(userId, providerId, providerUserId, rank, displayName, profileUrl, imageUrl, accessToken, secret, refreshToken, expireTime);

    try {
        RemoteUser e = this.get(userId, providerId, providerUserId);
        if(e != null) {
            throw new DuplicateConnectionException(new ConnectionKey(providerId, providerUserId));
        }
    } catch (EmptyResultDataAccessException var14) {
        ;
    }

    this.save(remoteUser);
    return remoteUser;
}
 

import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
@Override
@Transactional
public void addConnection(final Connection<?> connection) {

    final ConnectionData connectionData = connection.createData();
    final String providerId = connectionData.getProviderId();
    final String providerUserId = connectionData.getProviderUserId();

    final int rank = userConnectionRepository.findRank(user, providerId);

    final UserConnection userConnection = Functions.toUserConnection(textEncryptor, rank, user)
                                                   .apply(connectionData);

    if (userConnectionRepository.findOne(user, providerId, providerUserId) != null) {
        throw new DuplicateConnectionException(connection.getKey());
    }
    userConnectionRepository.save(userConnection);
}
 

import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
@Test(expected = DuplicateConnectionException.class)
public void testAddConnectionWithDuplicate() throws Exception {
    final ConnectionData connectionData = new ConnectionData("twitter",
                                                             "provider user id 3",
                                                             "display name",
                                                             "profile url",
                                                             "image url",
                                                             "access token",
                                                             "secret",
                                                             "refresh token",
                                                             1234L);
    final Connection<?> connection = new ConnectionStub<>(connectionData);

    subject.addConnection(connection);
    subject.addConnection(connection);
}
 

import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
public void addConnection(Connection<?> connection) {
	try {
		ConnectionData data = connection.createData();
		SQLiteDatabase db = repositoryHelper.getWritableDatabase();

		// generate rank
		final String sql = "select coalesce(max(rank) + 1, 1) as rank from UserConnection where userId = ? and providerId = ?";
		final String[] selectionArgs = { userId, data.getProviderId() };
		Cursor c = db.rawQuery(sql, selectionArgs);
		c.moveToFirst();
		int rank = c.getInt(c.getColumnIndex("rank"));
		c.close();

		// insert connection
		ContentValues values = new ContentValues();
		values.put("userId", userId);
		values.put("providerId", data.getProviderId());
		values.put("providerUserId", data.getProviderUserId());
		values.put("rank", rank);
		values.put("displayName", data.getDisplayName());
		values.put("profileUrl", data.getProfileUrl());
		values.put("imageUrl", data.getImageUrl());
		values.put("accessToken", encrypt(data.getAccessToken()));
		values.put("secret", encrypt(data.getSecret()));
		values.put("refreshToken", encrypt(data.getRefreshToken()));
		values.put("expireTime", data.getExpireTime());
		db.insertOrThrow("UserConnection", null, values);
		db.close();
	} catch (SQLiteConstraintException e) {
		throw new DuplicateConnectionException(connection.getKey());
	}
}
 

import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Transactional
public void addConnection(Connection<?> connection) {
	try {
		ConnectionData cd = connection.createData();
		// Get next rank, default to 1
		TypedQuery<Integer> nextRankQuery = entityManager.createQuery(QUERY_NEXT_RANK, Integer.class)
				                                         .setParameter("userId", userId)
				                                         .setParameter("providerId", cd.getProviderId());
		Integer nextRank = nextRankQuery.getSingleResult();
		// Build & persist new AppUserSocialConnection object
		AppUser appUser = entityManager.find(AppUser.class, userId);
		AppUserSocialConnection ausc = new AppUserSocialConnection();
		ausc.setKey(new AppUserSocialConnectionKey(appUser, cd.getProviderId(), cd.getProviderUserId()));
		ausc.setRank(nextRank.intValue());
		ausc.setDisplayName(cd.getDisplayName());
		ausc.setProfileUrl(cd.getProfileUrl());
		ausc.setImageUrl(cd.getImageUrl());
		ausc.setAccessToken(encrypt(cd.getAccessToken()));
		ausc.setSecret(encrypt(cd.getSecret()));
		ausc.setRefreshToken(encrypt(cd.getRefreshToken()));
		ausc.setExpireTime(cd.getExpireTime());
		entityManager.persist(ausc);
	} catch (EntityExistsException eee) {
		throw new DuplicateConnectionException(connection.getKey());
	}
}
 

import org.springframework.social.connect.DuplicateConnectionException; //导入依赖的package包/类
public void addConnection(Connection<?> connection) {
    //check cardinality
    SocialAuthenticationService<?> socialAuthenticationService = 
            this.socialAuthenticationServiceLocator.getAuthenticationService(connection.getKey().getProviderId());
    if (socialAuthenticationService.getConnectionCardinality() == ConnectionCardinality.ONE_TO_ONE ||
            socialAuthenticationService.getConnectionCardinality() == ConnectionCardinality.ONE_TO_MANY){
        List<UserSocialConnection> storedConnections = 
                this.userSocialConnectionRepository.findByProviderIdAndProviderUserId(
                        connection.getKey().getProviderId(), connection.getKey().getProviderUserId());
        if (storedConnections.size() > 0){
            //not allow one providerId/providerUserId connect to multiple userId
            throw new DuplicateConnectionException(connection.getKey());
        }
    }
    
    UserSocialConnection userSocialConnection = this.userSocialConnectionRepository
            .findByUserIdAndProviderIdAndProviderUserId(userId, connection.getKey().getProviderId(), 
                    connection.getKey().getProviderUserId());
    if (userSocialConnection == null) {
        ConnectionData data = connection.createData();
        userSocialConnection = new UserSocialConnection(userId, data.getProviderId(), data.getProviderUserId(), 0,
                data.getDisplayName(), data.getProfileUrl(), data.getImageUrl(), encrypt(data.getAccessToken()),
                encrypt(data.getSecret()), encrypt(data.getRefreshToken()), data.getExpireTime());
        this.userSocialConnectionRepository.save(userSocialConnection);
    } else {
        throw new DuplicateConnectionException(connection.getKey());
    }
}