--- a/Agendas/trunk/src/Agendas.Twitter/Agendas.Twitter.csproj	Tue May 31 16:31:24 2011 -0300
+++ b/Agendas/trunk/src/Agendas.Twitter/Agendas.Twitter.csproj	Fri Jun 03 21:35:59 2011 -0300
@@ -32,7 +32,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Web" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -40,6 +42,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="oAuth.cs" />
+    <Compile Include="oAuthTwitter.cs" />
     <Compile Include="TwitterPublicador.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Agendas/trunk/src/Agendas.Twitter/oAuth.cs	Fri Jun 03 21:35:59 2011 -0300
@@ -0,0 +1,373 @@
+using System;
+using System.Security.Cryptography;
+using System.Collections.Generic;
+using System.Text;
+using System.Web;
+
+namespace AltNetHispano.Agendas.Twitter
+{
+    public class OAuthBase
+    {
+
+        /// <summary>
+        /// Provides a predefined set of algorithms that are supported officially by the protocol
+        /// </summary>
+        public enum SignatureTypes
+        {
+            HMACSHA1,
+            PLAINTEXT,
+            RSASHA1
+        }
+
+        /// <summary>
+        /// Provides an internal structure to sort the query parameter
+        /// </summary>
+        protected class QueryParameter
+        {
+            private string name = null;
+            private string value = null;
+
+            public QueryParameter(string name, string value)
+            {
+                this.name = name;
+                this.value = value;
+            }
+
+            public string Name
+            {
+                get { return name; }
+            }
+
+            public string Value
+            {
+                get { return value; }
+            }
+        }
+
+        /// <summary>
+        /// Comparer class used to perform the sorting of the query parameters
+        /// </summary>
+        protected class QueryParameterComparer : IComparer<QueryParameter>
+        {
+
+            #region IComparer<QueryParameter> Members
+
+            public int Compare(QueryParameter x, QueryParameter y)
+            {
+                if (x.Name == y.Name)
+                {
+                    return string.Compare(x.Value, y.Value);
+                }
+                else
+                {
+                    return string.Compare(x.Name, y.Name);
+                }
+            }
+
+            #endregion
+        }
+
+        protected const string OAuthVersion = "1.0";
+        protected const string OAuthParameterPrefix = "oauth_";
+
+        //
+        // List of know and used oauth parameters' names
+        //        
+        protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
+        protected const string OAuthCallbackKey = "oauth_callback";
+        protected const string OAuthVersionKey = "oauth_version";
+        protected const string OAuthSignatureMethodKey = "oauth_signature_method";
+        protected const string OAuthSignatureKey = "oauth_signature";
+        protected const string OAuthTimestampKey = "oauth_timestamp";
+        protected const string OAuthNonceKey = "oauth_nonce";
+        protected const string OAuthTokenKey = "oauth_token";
+        protected const string OAuthTokenSecretKey = "oauth_token_secret";
+        protected const string OAuthVerifierKey = "oauth_verifier";
+
+        protected const string HMACSHA1SignatureType = "HMAC-SHA1";
+        protected const string PlainTextSignatureType = "PLAINTEXT";
+        protected const string RSASHA1SignatureType = "RSA-SHA1";
+
+        protected Random random = new Random();
+
+        protected string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";
+
+        /// <summary>
+        /// Helper function to compute a hash value
+        /// </summary>
+        /// <param name="hashAlgorithm">The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function</param>
+        /// <param name="data">The data to hash</param>
+        /// <returns>a Base64 string of the hash value</returns>
+        private string ComputeHash(HashAlgorithm hashAlgorithm, string data)
+        {
+            if (hashAlgorithm == null)
+            {
+                throw new ArgumentNullException("hashAlgorithm");
+            }
+
+            if (string.IsNullOrEmpty(data))
+            {
+                throw new ArgumentNullException("data");
+            }
+
+            byte[] dataBuffer = System.Text.Encoding.ASCII.GetBytes(data);
+            byte[] hashBytes = hashAlgorithm.ComputeHash(dataBuffer);
+
+            return Convert.ToBase64String(hashBytes);
+        }
+
+        /// <summary>
+        /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
+        /// </summary>
+        /// <param name="parameters">The query string part of the Url</param>
+        /// <returns>A list of QueryParameter each containing the parameter name and value</returns>
+        private List<QueryParameter> GetQueryParameters(string parameters)
+        {
+            if (parameters.StartsWith("?"))
+            {
+                parameters = parameters.Remove(0, 1);
+            }
+
+            List<QueryParameter> result = new List<QueryParameter>();
+
+            if (!string.IsNullOrEmpty(parameters))
+            {
+                string[] p = parameters.Split('&');
+                foreach (string s in p)
+                {
+                    if (!string.IsNullOrEmpty(s) && !s.StartsWith(OAuthParameterPrefix))
+                    {
+                        if (s.IndexOf('=') > -1)
+                        {
+                            string[] temp = s.Split('=');
+                            result.Add(new QueryParameter(temp[0], temp[1]));
+                        }
+                        else
+                        {
+                            result.Add(new QueryParameter(s, string.Empty));
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
+        /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
+        /// </summary>
+        /// <param name="value">The value to Url encode</param>
+        /// <returns>Returns a Url encoded string</returns>
+        public string UrlEncode(string value)
+        {
+            StringBuilder result = new StringBuilder();
+
+            foreach (char symbol in value)
+            {
+                if (unreservedChars.IndexOf(symbol) != -1)
+                {
+                    result.Append(symbol);
+                }
+                else
+                {
+                    result.Append('%' + String.Format("{0:X2}", (int)symbol));
+                }
+            }
+
+            return result.ToString();
+        }
+
+        /// <summary>
+        /// Normalizes the request parameters according to the spec
+        /// </summary>
+        /// <param name="parameters">The list of parameters already sorted</param>
+        /// <returns>a string representing the normalized parameters</returns>
+        protected string NormalizeRequestParameters(IList<QueryParameter> parameters)
+        {
+            StringBuilder sb = new StringBuilder();
+            QueryParameter p = null;
+            for (int i = 0; i < parameters.Count; i++)
+            {
+                p = parameters[i];
+                sb.AppendFormat("{0}={1}", p.Name, p.Value);
+
+                if (i < parameters.Count - 1)
+                {
+                    sb.Append("&");
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Generate the signature base that is used to produce the signature
+        /// </summary>
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>        
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
+        /// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
+        /// <returns>The signature base</returns>
+        public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            if (token == null)
+            {
+                token = string.Empty;
+            }
+
+            if (tokenSecret == null)
+            {
+                tokenSecret = string.Empty;
+            }
+
+            if (string.IsNullOrEmpty(consumerKey))
+            {
+                throw new ArgumentNullException("consumerKey");
+            }
+
+            if (string.IsNullOrEmpty(httpMethod))
+            {
+                throw new ArgumentNullException("httpMethod");
+            }
+
+            if (string.IsNullOrEmpty(signatureType))
+            {
+                throw new ArgumentNullException("signatureType");
+            }
+
+            normalizedUrl = null;
+            normalizedRequestParameters = null;
+
+            List<QueryParameter> parameters = GetQueryParameters(url.Query);
+            parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
+            parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
+            parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
+            parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
+            parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));
+
+            if (!string.IsNullOrEmpty(callBackUrl))
+            {
+                parameters.Add(new QueryParameter(OAuthCallbackKey, UrlEncode(callBackUrl)));
+            }
+
+
+            if (!string.IsNullOrEmpty(oauthVerifier))
+            {
+                parameters.Add(new QueryParameter(OAuthVerifierKey, oauthVerifier));
+            }
+
+            if (!string.IsNullOrEmpty(token))
+            {
+                parameters.Add(new QueryParameter(OAuthTokenKey, token));
+            }
+
+            parameters.Sort(new QueryParameterComparer());
+
+            normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
+            if (!((url.Scheme == "http" && url.Port == 80) || (url.Scheme == "https" && url.Port == 443)))
+            {
+                normalizedUrl += ":" + url.Port;
+            }
+            normalizedUrl += url.AbsolutePath;
+            normalizedRequestParameters = NormalizeRequestParameters(parameters);
+
+            StringBuilder signatureBase = new StringBuilder();
+            signatureBase.AppendFormat("{0}&", httpMethod.ToUpper());
+            signatureBase.AppendFormat("{0}&", UrlEncode(normalizedUrl));
+            signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));
+
+            return signatureBase.ToString();
+        }
+
+        /// <summary>
+        /// Generate the signature value based on the given signature base and hash algorithm
+        /// </summary>
+        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
+        /// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
+        {
+            return ComputeHash(hash, signatureBase);
+        }
+
+        /// <summary>
+        /// Generates a signature using the HMAC-SHA1 algorithm
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
+        /// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, callBackUrl, oauthVerifier, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
+        }
+
+        /// <summary>
+        /// Generates a signature using the specified signatureType 
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
+        /// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="signatureType">The type of signature to use</param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            normalizedUrl = null;
+            normalizedRequestParameters = null;
+
+            switch (signatureType)
+            {
+                case SignatureTypes.PLAINTEXT:
+                    return HttpUtility.UrlEncode(string.Format("{0}&{1}", consumerSecret, tokenSecret));
+                case SignatureTypes.HMACSHA1:
+                    string signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, callBackUrl, oauthVerifier, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);
+
+                    HMACSHA1 hmacsha1 = new HMACSHA1();
+                    hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));
+
+                    return GenerateSignatureUsingHash(signatureBase, hmacsha1);
+                case SignatureTypes.RSASHA1:
+                    throw new NotImplementedException();
+                default:
+                    throw new ArgumentException("Unknown signature type", "signatureType");
+            }
+        }
+
+        /// <summary>
+        /// Generate the timestamp for the signature        
+        /// </summary>
+        /// <returns></returns>
+        public virtual string GenerateTimeStamp()
+        {
+            // Default implementation of UNIX time of the current UTC time
+            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+            return Convert.ToInt64(ts.TotalSeconds).ToString();
+        }
+
+        /// <summary>
+        /// Generate a nonce
+        /// </summary>
+        /// <returns></returns>
+        public virtual string GenerateNonce()
+        {
+            // Just a simple implementation of a random number between 123400 and 9999999
+            return random.Next(123400, 9999999).ToString();
+        }
+
+    }
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Agendas/trunk/src/Agendas.Twitter/oAuthTwitter.cs	Fri Jun 03 21:35:59 2011 -0300
@@ -0,0 +1,275 @@
+using System;
+using System.Configuration;
+using System.Web;
+using System.Net;
+using System.IO;
+using System.Collections.Specialized;
+
+namespace AltNetHispano.Agendas.Twitter
+{
+    public class oAuthTwitter : OAuthBase
+    {
+        public enum Method { GET, POST, DELETE };
+        public const string REQUEST_TOKEN = "http://twitter.com/oauth/request_token";
+        public const string AUTHORIZE = "http://twitter.com/oauth/authorize";
+        public const string ACCESS_TOKEN = "http://twitter.com/oauth/access_token";
+
+        private string _consumerKey = "";
+        private string _consumerSecret = "";
+        private string _token = "";
+        private string _tokenSecret = "";
+        private string _callBackUrl = "oob";
+        private string _oauthVerifier = "";
+
+
+#region Properties
+        public string ConsumerKey 
+        {
+            get
+            {
+                if (_consumerKey.Length == 0)
+                {
+                    _consumerKey = ConfigurationManager.AppSettings["consumerKey"];
+                }
+                return _consumerKey; 
+            } 
+            set { _consumerKey = value; } 
+        }
+        
+        public string ConsumerSecret { 
+            get {
+                if (_consumerSecret.Length == 0)
+                {
+                    _consumerSecret = ConfigurationManager.AppSettings["consumerSecret"];
+                }
+                return _consumerSecret; 
+            } 
+            set { _consumerSecret = value; } 
+        }
+
+        public string Token { get { return _token; } set { _token = value; } }
+        public string TokenSecret { get { return _tokenSecret; } set { _tokenSecret = value; } }
+        public string CallBackUrl { get { return _callBackUrl; } set { _callBackUrl = value; } }
+        public string OAuthVerifier { get { return _oauthVerifier; } set { _oauthVerifier = value; } }
+
+#endregion
+
+        /// <summary>
+        /// Get the link to Twitter's authorization page for this application.
+        /// </summary>
+        /// <returns>The url with a valid request token, or a null string.</returns>
+        public string AuthorizationLinkGet()
+        {
+            string ret = null;
+
+            string response = oAuthWebRequest(Method.GET, REQUEST_TOKEN, String.Empty);
+            if (response.Length > 0)
+            {
+                //response contains token and token secret.  We only need the token.
+                NameValueCollection qs = HttpUtility.ParseQueryString(response);
+
+                if (qs["oauth_callback_confirmed"] != null)
+                {
+                    if (qs["oauth_callback_confirmed"] != "true")
+                    {
+                        throw new Exception("OAuth callback not confirmed.");
+                    }
+                }
+
+                if (qs["oauth_token"] != null)
+                {
+                    ret = AUTHORIZE + "?oauth_token=" + qs["oauth_token"];
+                }
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Exchange the request token for an access token.
+        /// </summary>
+        /// <param name="authToken">The oauth_token is supplied by Twitter's authorization page following the callback.</param>
+        /// <param name="oauthVerifier">An oauth_verifier parameter is provided to the client either in the pre-configured callback URL</param>
+        public void AccessTokenGet(string authToken, string oauthVerifier)
+        {
+            this.Token = authToken;
+            this.OAuthVerifier = oauthVerifier;
+
+            string response = oAuthWebRequest(Method.GET, ACCESS_TOKEN, String.Empty);
+
+            if (response.Length > 0)
+            {
+                //Store the Token and Token Secret
+                NameValueCollection qs = HttpUtility.ParseQueryString(response);
+                if (qs["oauth_token"] != null)
+                {
+                    this.Token = qs["oauth_token"];
+                }
+                if (qs["oauth_token_secret"] != null)
+                {
+                    this.TokenSecret = qs["oauth_token_secret"];
+                }
+            }
+        }
+        
+        /// <summary>
+        /// Submit a web request using oAuth.
+        /// </summary>
+        /// <param name="method">GET or POST</param>
+        /// <param name="url">The full url, including the querystring.</param>
+        /// <param name="postData">Data to post (querystring format)</param>
+        /// <returns>The web server response.</returns>
+        public string oAuthWebRequest(Method method, string url, string postData)
+        {
+            string outUrl = "";
+            string querystring = "";
+            string ret = "";
+
+
+            //Setup postData for signing.
+            //Add the postData to the querystring.
+            if (method == Method.POST || method == Method.DELETE)
+            {
+                if (postData.Length > 0)
+                {
+                    //Decode the parameters and re-encode using the oAuth UrlEncode method.
+                    NameValueCollection qs = HttpUtility.ParseQueryString(postData);
+                    postData = "";
+                    foreach (string key in qs.AllKeys)
+                    {
+                        if (postData.Length > 0)
+                        {
+                            postData += "&";
+                        }
+                        qs[key] = HttpUtility.UrlDecode(qs[key]);
+                        qs[key] = this.UrlEncode(qs[key]);
+                        postData += key + "=" + qs[key];
+
+                    }
+                    if (url.IndexOf("?") > 0)
+                    {
+                        url += "&";
+                    }
+                    else
+                    {
+                        url += "?";
+                    }
+                    url += postData;
+                }
+            }
+
+            Uri uri = new Uri(url);
+            
+            string nonce = this.GenerateNonce();
+            string timeStamp = this.GenerateTimeStamp();
+
+            //Generate Signature
+            string sig = this.GenerateSignature(uri,
+                this.ConsumerKey,
+                this.ConsumerSecret,
+                this.Token,
+                this.TokenSecret,
+                this.CallBackUrl,
+                this.OAuthVerifier,
+                method.ToString(),
+                timeStamp,
+                nonce,
+                out outUrl,
+                out querystring);
+
+            querystring += "&oauth_signature=" + this.UrlEncode(sig);
+
+            //Convert the querystring to postData
+            if (method == Method.POST || method == Method.DELETE)
+            {
+                postData = querystring;
+                querystring = "";
+            }
+
+            if (querystring.Length > 0)
+            {
+                outUrl += "?";
+            }
+
+            ret = WebRequest(method, outUrl +  querystring, postData);
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Web Request Wrapper
+        /// </summary>
+        /// <param name="method">Http Method</param>
+        /// <param name="url">Full url to the web resource</param>
+        /// <param name="postData">Data to post in querystring format</param>
+        /// <returns>The web server response.</returns>
+        public string WebRequest(Method method, string url, string postData)
+        {
+            HttpWebRequest webRequest = null;
+            StreamWriter requestWriter = null;
+            string responseData = "";
+
+            webRequest = System.Net.WebRequest.Create(url) as HttpWebRequest;
+            webRequest.Method = method.ToString();
+            webRequest.ServicePoint.Expect100Continue = false;
+            //webRequest.UserAgent  = "Identify your application please.";
+            //webRequest.Timeout = 20000;
+
+            if (method == Method.POST || method == Method.DELETE)
+            {
+                webRequest.ContentType = "application/x-www-form-urlencoded";
+
+                //POST the data.
+                requestWriter = new StreamWriter(webRequest.GetRequestStream());
+                try
+                {
+                    requestWriter.Write(postData);
+                }
+                catch
+                {
+                    throw;
+                }
+                finally
+                {
+                    requestWriter.Close();
+                    requestWriter = null;
+                }
+            }
+
+            responseData = WebResponseGet(webRequest);
+
+            webRequest = null;
+
+            return responseData;
+
+        }
+
+        /// <summary>
+        /// Process the web response.
+        /// </summary>
+        /// <param name="webRequest">The request object.</param>
+        /// <returns>The response data.</returns>
+        public string WebResponseGet(HttpWebRequest webRequest)
+        {
+            StreamReader responseReader = null;
+            string responseData = "";
+
+            try
+            {
+                responseReader = new StreamReader(webRequest.GetResponse().GetResponseStream());
+                responseData = responseReader.ReadToEnd();
+            }
+            catch
+            {
+                throw;
+            }
+            finally
+            {
+                webRequest.GetResponse().GetResponseStream().Close();
+                responseReader.Close();
+                responseReader = null;
+            }
+
+            return responseData;
+        }
+    }
+}

--- a/Agendas/trunk/src/Agendas.Web/Agendas.Web.csproj	Tue May 31 16:31:24 2011 -0300
+++ b/Agendas/trunk/src/Agendas.Web/Agendas.Web.csproj	Fri Jun 03 21:35:59 2011 -0300
@@ -164,6 +164,10 @@
       <Project>{444D25FB-FC1C-48DC-9EAD-D4C78F2A10CA}</Project>
       <Name>Agendas.Resources</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Agendas.Twitter\Agendas.Twitter.csproj">
+      <Project>{D8DA7ED2-A274-4DF6-9DD2-A9DC65F4C2F5}</Project>
+      <Name>Agendas.Twitter</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Content Include="Views\Shared\_Menu.cshtml" />
@@ -193,7 +197,7 @@
       <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
         <WebProjectProperties>
           <UseIIS>False</UseIIS>
-          <AutoAssignPort>True</AutoAssignPort>
+          <AutoAssignPort>False</AutoAssignPort>
           <DevelopmentServerPort>1424</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
           <IISUrl>

--- a/Agendas/trunk/src/Agendas.Web/Controllers/AccountController.cs	Tue May 31 16:31:24 2011 -0300
+++ b/Agendas/trunk/src/Agendas.Web/Controllers/AccountController.cs	Fri Jun 03 21:35:59 2011 -0300
@@ -1,6 +1,8 @@
-using System.Web.Mvc;
+using System;
+using System.Web.Mvc;
 using System.Web.Routing;
 using System.Web.Security;
+using AltNetHispano.Agendas.Twitter;
 using AltNetHispano.Agendas.Web.Models;
 
 namespace AltNetHispano.Agendas.Web.Controllers
@@ -55,7 +57,61 @@
             return View(model);
         }
 
-        // **************************************
+		public ActionResult TwitterLogOn()
+		{
+			var oAuth = new oAuthTwitter();
+
+			if (Request["oauth_token"] == null)
+			{
+				//Redirect the user to Twitter for authorization.
+				//Using oauth_callback for local testing.
+				oAuth.CallBackUrl = "http://localhost:1424/Account/TwitterLogOn";
+				Response.Redirect(oAuth.AuthorizationLinkGet());
+			}
+			else
+			{
+				//Get the access token and secret.
+				oAuth.AccessTokenGet(Request["oauth_token"], Request["oauth_verifier"]);
+				if (oAuth.TokenSecret.Length > 0)
+				{
+					//We now have the credentials, so make a call to the Twitter API.
+					const string url = "http://twitter.com/account/verify_credentials.xml";
+					string xml = oAuth.oAuthWebRequest(oAuthTwitter.Method.GET, url, String.Empty);
+
+					var username = GetXmlContent(xml, "screen_name");
+					//TODO: Validar que este usuario de twitter corresponde a un usuario del sitio
+
+					FormsService.SignIn(username, false);
+					return RedirectToAction("Index", "Home");
+
+					//POST Test
+					//url = "http://twitter.com/statuses/update.xml";
+					//xml = oAuth.oAuthWebRequest(oAuthTwitter.Method.POST, url, "status=" + oAuth.UrlEncode("Hello @swhitley - Testing the .NET oAuth API"));
+					//apiResponse.InnerHtml = Server.HtmlEncode(xml);
+				}
+			}
+
+			return RedirectToAction("LogOn");
+		}
+
+    	private string GetXmlContent(string xml, string tagName)
+    	{
+    		var tagStart = "<" + tagName + ">";
+    		var tagEnd = "</" + tagName + ">";
+
+    		var start = xml.IndexOf(tagStart)+tagStart.Length;
+			if (start>tagStart.Length)
+			{
+				var end = xml.IndexOf(tagEnd, start);
+				if (end>0)
+				{
+					return xml.Substring(start, end - start);
+				}
+			}
+    		return string.Empty;
+    	}
+
+    	// **************************************
         // URL: /Account/LogOff
         // **************************************
 

--- a/Agendas/trunk/src/Agendas.Web/Views/Account/LogOn.cshtml	Tue May 31 16:31:24 2011 -0300
+++ b/Agendas/trunk/src/Agendas.Web/Views/Account/LogOn.cshtml	Fri Jun 03 21:35:59 2011 -0300
@@ -9,6 +9,7 @@
 
 @Html.ValidationSummary(true, "Login was unsuccessful. Please correct the errors and try again.")
 
+@Html.ActionLink("Twitter", "TwitterLogOn")
 @using (Html.BeginForm()) {
     <div>
         <fieldset>

--- a/Agendas/trunk/src/Agendas.Web/Web.config	Tue May 31 16:31:24 2011 -0300
+++ b/Agendas/trunk/src/Agendas.Web/Web.config	Fri Jun 03 21:35:59 2011 -0300
@@ -14,12 +14,15 @@
 	</connectionStrings>
 
 	<appSettings>
+		<add key="consumerKey" value="uUSzC5EZ2LCNoBmaQXcUFA"/>
+		<add key="consumerSecret" value="CNN2uUwza4nGNoZf3FlAqC0xoUEKXKFWxZn3Frow"/>
+		
 		<add key="ClientValidationEnabled" value="true"/>
 		<add key="UnobtrusiveJavaScriptEnabled" value="true"/>
 	</appSettings>
 
 	<system.web>
-		<customErrors mode="On"/>
+		<customErrors mode="Off"/>
 		<compilation debug="true" targetFramework="4.0">
 			<assemblies>
 				<add assembly="System.Web.Abstractions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />