Bundle-ManifestVersion: 2
Bundle-Name: ${project.artifactId}
Bundle-Vendor: Osgiliath Inc.
Bundle-SymbolicName: ${project.groupId}_${project.artifactId}
Bundle-Version: ${user.osgi.version}
Excluded-Imports: net.osgiliath.social.business.services
Import-Package: org.apache.activemq.command,
org.springframework.integration.config,
org.springframework.integration.config.xml,
org.springframework.integration.jms,
org.springframework.integration.channel,
org.springframework.integration.endpoint,
org.springframework.scheduling.concurrent,
org.springframework.integration.handler,
org.springframework.jms.listener,
org.springframework.scheduling.support,
org.springframework.integration.json,
org.springframework.integration.config.annotation,
org.springframework.integration.aop,
org.springframework.integration.transformer

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:security="http://www.springframework.org/schema/security"
	xmlns:int="http://www.springframework.org/schema/integration"
	xmlns:osgi="http://www.springframework.org/schema/osgi" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jms="http://www.springframework.org/schema/integration/jms"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
	http://www.springframework.org/schema/integration/jms http://www.springframework.org/schema/integration/jms/spring-integration-jms.xsd
	http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi.xsd
	http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms.xsd
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd
">
<osgi:reference id="connectionFactory" interface="javax.jms.ConnectionFactory" />
	<int:poller default="true" max-messages-per-poll="1000"
		time-unit="MILLISECONDS" fixed-delay="100" id="defaultpoller" />
	<context:annotation-config />
	<int:annotation-config />
<!-- + service de validation, scan des packages, repository utilisateurs...-->
<int:channel id="subscribeChannel">
	</int:channel>
	<int:channel id="subscriptionErrorChannel">
		<int:queue />
	</int:channel>
<int:channel id="userInformationChannelOut">
		<int:queue />
	</int:channel>
<jms:message-driven-channel-adapter
		channel="subscribeChannel" destination="subscribeDestination"
		connection-factory="connectionFactory" />
 
	<bean id="subscribeDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg value="local.subscribe" />
	</bean>
<jms:outbound-channel-adapter channel="userInformationChannelOut"
		destination="userInformationOutDestination" connection-factory="connectionFactory" />
 
	<bean id="userInformationOutDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg value="local.userInformation" />
	</bean>
	<jms:outbound-channel-adapter channel="subscriptionErrorChannel"
		destination="subscribedErrorDestination" connection-factory="connectionFactory" />
 
	<bean id="subscribedErrorDestination" class="org.apache.activemq.command.ActiveMQQueue">
		<constructor-arg value="local.error" />
	</bean>
</beans>

package net.osgiliath.security.manager.internal;</code>
 
import java.util.List;
import java.util.Set;
 
import javax.inject.Inject;
import javax.validation.ConstraintViolation;
import javax.validation.Validator;
 
import lombok.extern.slf4j.Slf4j;
import net.osgiliath.security.manager.SubscriptionService;
import net.osgiliath.user.authorization.AUTHORITY;
import net.osgiliath.user.model.MUser;
import net.osgiliath.user.model.authorization.MAuthority;
import net.osgiliath.user.model.authorization.builder.MAuthorityBuilder;
import net.osgiliath.user.repository.MUserRepository;
import net.osgiliath.user.repository.authorization.MAuthorityRepository;
 
import org.springframework.integration.Message;
import org.springframework.integration.MessageChannel;
import org.springframework.integration.annotation.MessageEndpoint;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.security.authentication.dao.SaltSource;
import org.springframework.security.authentication.encoding.PasswordEncoder;
 
import com.google.common.collect.Lists;
 
@Slf4j
@MessageEndpoint
public class RepositorySubscriptionService implements SubscriptionService {
@Inject
private Validator validator;
@Inject
private MUserRepository mUserRepository;
@Inject
private MAuthorityRepository mAuthorityRepository;
@Inject
private PasswordEncoder passwordEncoder;
@Inject
private SaltSource saltSource;
@Inject
private MessageChannel subscriptionErrorChannel;
 
@Override
@ServiceActivator(inputChannel = "subscribeChannel", outputChannel = "userInformationChannelOut" )
public Message onSubscription(Message arg0) {
log.info("received message for Subscription");
try {
MUser user = (MUser) arg0.getPayload();
Set&lt;ConstraintViolation&gt; validationResults = validator
.validate(user);
if (!validationResults.isEmpty()) {
log.info("subscription error, validating user:" + validationResults.iterator().next().getMessage());
// création du message d'erreur, puis envoi
subscriptionErrorChannel.send(MessageBuilder.withPayload(
validationResults.iterator().next().getMessage()).build());
return null;
} else if (!mUserRepository.findByPseudo(user.getPseudo()).isEmpty()) {
log.info("subscription error: user already exists");
subscriptionErrorChannel.send(MessageBuilder.withPayload(
"Pseudo already exists").build());
return null;
} else if (!mUserRepository.findByEmail(user.getEmail()).isEmpty()) {
log.info("subscription error: email already registered");
subscriptionErrorChannel.send(MessageBuilder.withPayload(
"Email already registered").build());
return null;
} else {
String password = user.getPassword();
password = passwordEncoder.encodePassword(password,
saltSource.getSalt(user));
user.setPassword(password);
MAuthority auth;
List auths = mAuthorityRepository
.findByAuthority(AUTHORITY.SLOGGED);
if (auths.isEmpty()) {
auth = new MAuthorityBuilder().withAuthority(AUTHORITY.LOGGED)
.build();
auth = mAuthorityRepository.save(auth);
} else {
auth = auths.iterator().next();
}
 
user.setMAuthorities(Lists.newArrayList(auth));
user = mUserRepository.save(user);
log.info("user saved with pseudo:" + user.getPseudo()
+ " saved with id: " + user.getId());
// renvoi le message dans l'output channel
return MessageBuilder.withPayload(user).build();
}
}catch (Exception e) {
log.error("Error during subscription", e);
 
}
throw new RuntimeException(
"Unexpected error on the onsubscription method");
}
 
}