fireeagleupdateservice.cs

Some time ago, I stated in another article that I d take the idea of location broadcasting and devel

        {
            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.
        /// </summary>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        protected string NormalizeRequestParameters(IList<QueryParameter> parameters)
        {
            StringBuilder builder = new StringBuilder();
            QueryParameter query = null;

            for (int i = 0; i < parameters.Count; i++)
            {
                query = parameters[i];
                builder.AppendFormat("{0}={1}", query.Name, query.Value);

                if (i < parameters.Count - 1)
                {
                    builder.Append("&");
                }
            }

            return builder.ToString();
        }
        /// <summary>
        /// Generates the signature needed for calling Fire Eagle.
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="token">The token.</param>
        /// <param name="tokenSecret">The token secret.</param>
        /// <param name="httpMethod">The HTTP method.</param>
        /// <param name="timeStamp">The time stamp.</param>
        /// <param name="nonce">The nonce.</param>
        /// <param name="signatureType">Type of the signature.</param>
        /// <returns></returns>
        public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType)
        {
            if (token == null)
            {
                token = string.Empty;
            }

            if (tokenSecret == null)
            {
                tokenSecret = string.Empty;
            }

            // Build a list of query parameters
            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(token))
            {
                parameters.Add(new QueryParameter(OAuthTokenKey, token));
            }

            // The parameters have to be in order for the hash to succeed when calling 
            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>
        /// Hashes the input using an HmacSha1 algorithm.
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="token">The token.</param>
        /// <param name="tokenSecret">The token secret.</param>
        /// <param name="httpMethod">The HTTP method.</param>
        /// <param name="timeStamp">The time stamp.</param>
        /// <param name="nonce">The nonce.</param>
        /// <returns></returns>
        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce)
        {
            string signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType);

            HmacSha1 hmacsha1 = new HmacSha1();

            hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), 
                string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));

            normalizedRequestParameters += "&oauth_signature=" + UrlEncode(ComputeHash(hmacsha1, signatureBase));
            return normalizedUrl + "?" + normalizedRequestParameters;
        }
        /// <summary>
        /// Generates the time stamp, Unix style.
        /// </summary>
        /// <returns></returns>
        public virtual string GenerateTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return ts.TotalSeconds.ToString();
        }
        /// <summary>
        /// Generates the nonce value.
        /// </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();
        }
        #endregion

        #region Properties
        /// <summary>
        /// Gets or sets the oauth token.
        /// </summary>
        /// <value>The oauth token.</value>
        public string OauthToken { get; set; }
        /// <summary>
        /// Gets or sets the oauth token secret.
        /// </summary>
        /// <value>The oauth token secret.</value>
        public string OauthTokenSecret { get; set; }
        #endregion

        /// <summary>
        /// Updates the specified location with Fire Eagle.
        /// </summary>
        /// <param name="location">The location.</param>
        internal override void Update(GeoLocation location)
        {
            try
            {
                if (!string.IsNullOrEmpty(Settings.FireEagleSecret) && !string.IsNullOrEmpty(Settings.FireEagleToken))
                {
                    CallHttp("update", new NameValueCollection() 
                    { 
                        {"lat", location.Latitude.ToStringNumeric() }, 
                        {"lon", location.Longitude.ToStringNumeric() } 
                    });
                }
            }
            catch { }
        }
        /// <summary>
        /// Gets the service's friendly name.
        /// </summary>
        /// <value>The name.</value>
        internal override string Name
        {
            get { return "FireEagle"; }
        }
    }

    internal 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; }
        }
    }

    internal 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
    }
}