// Spring Social
 git clone git://git.springsource.org/spring-social/spring-social.git
 // Spring Mobile
 git clone git://git.springsource.org/spring-mobile/spring-mobile.git

//Creamos una instancia de Twitter, usemos el TwitterFactory , trabajamos con la version de Twitter4j 2.3.1
this.twitter = new TwitterFactory().getInstance();
// Las 2 llaves que nos da Twitter al registrar la aplicacion, estas son fundamentales las
// usaremos mucho, se deben almacenar en la base de datos
this.twitter.setOAuthConsumer("consumer_key", "consumer_secret");
//Solicitamos un REQUEST TOKEN, este objeto solo se debe crear una sola vez.
this.requestToken = twitter.getOAuthRequestToken();
//Obtenemos el URL, este url lo podemos presentar en JSF con un link y nos enviara a la página
// de twitter, daremos permiso a nuestra aplicacion
// y obtendremos el pin que usaremos a continuacion.
final String url = this.requestToken.getAuthorizationURL();

//El objeto AccessToken, este objeto lo usaremos constantemente, cada vez que querramos 
//comunicarnos con Twitter, en este caso para validar nuestro
// RequesToken y obtener 2 llaves mas, que son las definitivas y las que nos permitiran 
//publicar, hasta el momento no hemos terminado
this.accessToken = this.twitter.getOAuthAccessToken(this.requestToken, "PIN");
//Si despues de esto todo sale bien (sin TwitterExceptions) tendremos ya acceso a los TOKENS, 
// son 2 cadenas que almacenaremos en nuestra base de datos
// y usaremos posteriormente para publicar nuestros tweets o obtener algo de informacion de nuestra cuenta.
//El token
log.debug("New Token {"+this.accessToken.getToken());
//El Token Secret
log.debug("New Secret Token {"+this.accessToken.getTokenSecret());
 //Testing send twitter, WORKS !!
//Si queremos probar que todo funciona, seteamos el ACCESS TOKEN que validamos anteriormente con el objeto Twitter.
 this.twitter.setOAuthAccessToken(accessToken);
// Publicamos algo para comprobar.
 this.twitter.updateStatus("test accessToken");
//Guardamos los dos tokens en la base de datos.

//Para poder acceder a nuestra cuenta, postear o obtener algo de info, recuperamos nuestros
// 4 datos principales, creamos un ACCESSTOKEN seteando en el // constructor el Token y el Secret Token validos
final AccessToken accessToken = new AccessToken("Token", "Secret Token");
//Creamos una nueva instancia de Twitter y creamos una nueva instancia de autorizacion 
// con nuestras otras 2 llaves Consumer y el objeto creado 
// anteriormente ACCESS TOKEN 
Twitter twitter = new TwitterFactory().getOAuthAuthorizedInstance("Consumer Key", "Consumer Secret", accessToken);
//Una vez echo esto, ya tenemos el objeto Twitter cargado y listo para ser usado, podemos probar las credenciales.
twitter.verifyCredentials();

public final class MyViewFeedRssView extends AbstractRssFeedView {
 
    /**
     * En el caso de los RSS debemos crear el Channel, parece la gente de Spring se olvido de hacerlo por nosotros, ojo
     * con llenar bien el Channel.
     */
    @Override
    protected Channel newFeed() {
        final Channel channel = new Channel("rss_2.0");
        channel.setPubDate(new Date());
        channel.setDescription("RSS Description");
        channel.setTitle("TITLE");
        channel.setLink("link");
        channel.setCopyright("2010");
        channel.setPubDate(new Date());
        return  channel;
    }
 
    /**
     * Build Feed Entries.
     */
    @SuppressWarnings("unchecked")
    @Override
    protected List buildFeedEntries(Map model, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
         // Obtenemos las entradas que vienen en el modelo desde el Controller
        List contentList = (List) model.get("entries");
        // Creamos una lista de clase de Item, el objeto de ROME que refleja cada elemento del RSS
        List entries = new ArrayList(contentList.size());
        // Iteramos nuestras entradas del blog
        for (EntriesBlog content : contentList) {
                   final Item item = new Item();
            String date = String.format("%1$tY-%1$tm-%1$td", content.getPublicationDateTweet());
            item.setTitle(String.format("On %s, %s publish", date, content.getQuestionBean().getQuestionName()));
            item.setPubDate(content.getPublicationDateTweet());
            item.setLink("http://www.encuestame.org");
            entries.add(entry);
        }
        return entries;
    }
}

@Controller
public class RSSFeedController extends AbstractFeedController {
 
    /**
     * Build Feed Body.
     */
    private void buildTweetPollFeedBody(String username, Model model, HttpServletRequest request, User user){
         model.addAttribute("username", username);
         model.addAttribute("feedTitle", String.format(TWEET_POLL_FEED_TITLE, username));
         model.addAttribute("url", buildDomainWithRequest(request));
         //buscamos nuestras entradas de nuestro blog, por poner un ejemplo
         final List entries = getEntries(user.getUsername());
          // las guardamos en el modelo que pasaremos a la vista y usaremos mas adelante.
         model.addAttribute("entries", entries);
    }
 
    /**
     * Display RSS Feed.
     */
     // Utilizar REST es sencillo, solo debemos definir la variable entre llaves y llamarla con la anotacion @PathVariable
    @RequestMapping(value = "/feed/{username}/entries.rss", method = RequestMethod.GET)
    public String tweetPollRss(@PathVariable String username, Model model, HttpServletRequest request) {
       // Como queremos utilizar el mismo RSS para diferentes usuarios, buscamos nuestro usuario.
        final User user = getByUsername(username);
        if(user == null){
            //TODO: if null do something.
        }
        else{
             // Como somos muy ordenados creamos otro metodo.
            this.buildTweetPollFeedBody(username, model, request, user);
        }
        // Aqui regresaremos una cadena, que no es mas que el ID de nuestra VISTA del Bean RSS.
        return "rssFeedView";
    }
}

#---------------------------------------------------------
# WEB
# THESE SETTINGS ARE USED ONLY IN STANDALONE MODE. IGNORED WHEN THE WAR IS DEPLOYED ON A JEE SERVER.
#---------------------------------------------------------
# Listen host/port and context path (for example / or /sonar). Default values are 0.0.0.0:9000/
#sonar.web.host:                           0.0.0.0
sonar.web.port:                           8080
#sonar.web.context:                        /

#----- MySQL 5.x/6.x
# Comment the embedded database and uncomment the following lines to use MySQL
sonar.jdbc.url:                                      jdbc:mysql://localhost:3306/sonar?useUnicode=true&characterEncoding=utf8
sonar.jdbc.driverClassName:                   com.mysql.jdbc.Driver
sonar.jdbc.validationQuery:                     select 1
 
#----- Global database settings
sonar.jdbc.username:                              sonar
sonar.jdbc.password:                              sonar
sonar.jdbc.maxActive:                             10
sonar.jdbc.maxIdle:                                 5
sonar.jdbc.minIdle:                                  2
sonar.jdbc.maxWait:                                5000
sonar.jdbc.minEvictableIdleTimeMillis:        600000
sonar.jdbc.timeBetweenEvictionRunsMillis:   30000

  <profile>
        <id>sonar</id>
        <activation>
                <activeByDefault>true</activeByDefault>
        </activation>
                <properties>
                <sonar.jdbc.url>jdbc:mysql://localhost:3306/sonar</sonar.jdbc.url>
                <sonar.jdbc.driver>com.mysql.jdbc.Driver</sonar.jdbc.driver>
                <sonar.jdbc.username>sonar</sonar.jdbc.username>
                <sonar.jdbc.password>password</sonar.jdbc.password>
                <sonar.host.url>http://tudominio:8080</sonar.host.url>
                </properties>
        </profile>
  </profiles>

         mvn sonar:sonar

   <bean id="securityFlowExecutionListener" class="org.springframework.webflow.security.SecurityFlowExecutionListener" />
 
   <webflow:flow-executor id="flowExecutor" flow-registry="flowRegistry">
        <webflow:flow-execution-listeners>
            <webflow:listener ref="securityFlowExecutionListener" />
        </webflow:flow-execution-listeners>
    </webflow:flow-executor>

 <secured attributes="ROLE_USER"/>
 
<view-state id="main">
        <on-render>
            <render fragments="zona3"/>
        </on-render>
        <transition on="paso1" to="reviewHotels">
              <secured attributes="ROLE_EDITOR"/>
             <evaluate expression="bean.metodo1()" />
             <render fragments="zona1"/>
        </transition>
        <transition on="paso2" >
              <secured attributes="ROLE_ADMIN"/>
             <evaluate expression="bean.metodo2() />
             <render fragments="zona1"/>
        </transition>
    </view-state>

Caused by: java.lang.ClassNotFoundException: org.springframework.security.vote.AffirmativeBased
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1387)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1233)
... 65 more

import org.springframework.security.Authentication;
import org.springframework.security.context.SecurityContext;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.context.SecurityContextImpl;
import org.springframework.security.providers.openid.OpenIDAuthenticationStatus;
import org.springframework.security.providers.openid.OpenIDAuthenticationToken;
import org.springframework.security.userdetails.UserDetails;
import org.springframework.security.userdetails.UserDetailsService;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.openid.OpenIDAuthenticationStatus;
import org.springframework.security.openid.OpenIDAuthenticationToken;

 
 <properties>
    <spring.security.version>3.0.2.RELEASE</spring.security.version>
 </properties>
 
<dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-config</artifactId>
      <version>${spring.security.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-core</artifactId>
      <version>${spring.security.version}</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-ldap</artifactId>
      <version>${spring.security.version}</version>
    </dependency>
  <dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-openid</artifactId>
    <version>${spring.security.version}</version>
    <scope>compile</scope>
  </dependency>
    <dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-taglibs</artifactId>
      <version>${spring.security.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.security</groupId>
      <artifactId>spring-security-web</artifactId>
      <version>${spring.security.version}</version>
</dependency>

 
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:security="http://www.springframework.org/schema/security"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/security
          http://www.springframework.org/schema/security/spring-security-3.0.xsd">
</beans>

 
<http auto-config='true'>
  <intercept-url pattern="/**" access="ROLE_USER" />
</http>

  <security:http auto-config="false"
                 entry-point-ref="authenticationEntryPoint"
                 access-decision-manager-ref="voteAccessDecisionManager" >
    <security:intercept-url pattern="/**" access="ENCUESTAME_ANONYMOUS" />
    <security:intercept-url pattern="/admon/**/*" access="ENCUESTAME_ADMIN" />
    <security:intercept-url pattern="/tweet/" access="ENCUESTAME_ANONYMOUS" />
    <security:intercept-url pattern="/" access="ENCUESTAME_ANONYMOUS" />
    <security:intercept-url pattern="/**/*.xhtml" filters="none" />
    <security:intercept-url pattern="/**/*.css"  filters="none" />
    <security:intercept-url pattern="/images/**" filters="none" />
    <security:intercept-url pattern="/js/**" filters="none" />
    <security:remember-me key="12345" services-alias="_rememberMeServices" />
    <security:anonymous key="12345" />
    <security:logout logout-success-url="/index.html" logout-url="/logout"/>
    <security:custom-filter position="FORM_LOGIN_FILTER" ref="authenticationFilter" />
    <security:custom-filter position="ANONYMOUS_FILTER"  ref="anonymousAuthFilter" />
  </security:http>

git clone git://github.com/jquery/jquery.git

./gitstats /pathToGitRepo/ pathToGenerateHTMLStats/