yavsc/GoogleCode/GoogleTranslate/GoogleTranslate.cs

using System;
using System.Collections.Generic;
using System.Text;
using GoogleTranslateNET.Misc;
using GoogleTranslateNET.Objects.Error;
using GoogleTranslateNET.Objects.LanguageDetection;
using GoogleTranslateNET.Objects.SupportedLanguages;
using GoogleTranslateNET.Objects.Translation;
using RestSharp;
using RestSharp.Deserializers;
using System.Linq;

namespace GoogleTranslateNET
{
    public class GoogleTranslate
    {
        private string _key;
        private static RestClient _client = new RestClient("https://www.googleapis.com/language/translate/v2");

        public GoogleTranslate(string key)
        {
            if (string.IsNullOrEmpty(key))
                throw new ArgumentException("Key is required.", "key");

            _key = key;
        }

        /// <summary>
        /// When true, the output from google is in human readable format.
        /// Default: Not set, Google defaults to true
        /// </summary>
        public bool? PrettyPrint { get; set; }

        /// <summary>
        /// When true, queries will be sent using HTTP POST instead of GET.
        /// GET queries have a limit of 2000 characters, POST queries have a limit of 5000 characters.
        /// Default: Not set, Google defaults to false
        /// </summary>
        public bool? LargeQuery { get; set; }

        /// <summary>
        /// Translates a text from one language to another.
        /// You can input multiple texts and get them translated all at once.
        /// Warning: Setting source and destination languages to the same language will result in an error.
        /// </summary>
        /// <param name="sourceLanguage">The language to translate from. Set it to Language.Automatic to let Google Translate determine the language.</param>
        /// <param name="destinationLanaguage">The language to translate to.</param>
        /// <param name="text">The text to translate. You may input more than one text.</param>
        /// <returns>The translated text.</returns>
        public List<Translation> Translate(Language sourceLanguage, Language destinationLanaguage, params string[] text)
        {
            //https://www.googleapis.com/language/translate/v2?key=key&q=hello%20world&source=en&target=de
            RestRequest request = CreateRequest(string.Empty);

            CheckRequest(text);

            //Required
            foreach (string q in text)
            {
                request.AddParameter("q", q);
            }
            request.AddParameter("target", destinationLanaguage.GetStringValue());

            //Optional
            if (sourceLanguage != Language.Automatic)
                request.AddParameter("source", sourceLanguage.GetStringValue());

            //Output
            TranslateResult results = GetResponse<TranslateResult>(request);
            return results.Data.Translations;
        }

        /// <summary>
        /// Gives you a list of supported languages.
        /// </summary>
        /// <param name="targetLanguage">When defined, gives you a list of languages that translates into the target language.</param>
        /// <returns>A list of supported languages</returns>
        public List<TranslationLanaguage> GetSupportedLanguages(Language targetLanguage = Language.Unknown)
        {
            //https://www.googleapis.com/language/translate/v2/languages?key=key&target=zh-TW
            RestRequest request = CreateRequest("languages");

            //Optional
            if (targetLanguage != Language.Unknown)
                request.AddParameter("target", targetLanguage.GetStringValue());

            //Output
            SupportedLanguageResult results = GetResponse<SupportedLanguageResult>(request);
            return results.Data.Languages;
        }

        /// <summary>
        /// Detects the languages that might be used in the text.
        /// You can send more than one text in a single request to detect multiple texts.
        /// </summary>
        /// <param name="text">The text to use when detecting languages.</param>
        /// <returns>A list of languages that might be used in the text.</returns>
        public List<LanguageDetection> DetectLanguage(params string[] text)
        {
            //https://www.googleapis.com/language/translate/v2/detect?key=key&q=google+translate+is+fast
            RestRequest request = CreateRequest("detect");

            CheckRequest(text);

            //Required
            foreach (string q in text)
            {
                request.AddParameter("q", q);
            }

            //Output
            LanguageDetectionResult results = GetResponse<LanguageDetectionResult>(request);

            //Flatten the results from Google Translate API
            List<LanguageDetection> detections = new List<LanguageDetection>();
            foreach (List<LanguageDetection> languageDetections in results.Data.Detections)
            {
                detections.AddRange(languageDetections);
            }

            return detections;
        }

        private void CheckRequest(IEnumerable<string> requestContent)
        {
            //Compute the total size of the content
            int sum = requestContent.Sum(item => item.Length);

            if (((LargeQuery.HasValue && !LargeQuery.Value) || !LargeQuery.HasValue) && sum >= 2000)
            {
                throw new ArgumentException("Your text content is larger than 2000 characters. Set LargeQuery to 'true' to enable support up to 5000 characters.");
            }

            if (sum > 5000)
                throw new ArgumentException("Your text content is larger than 5000 characters. Google Translate only allow up to 5000 characters");
        }

        private RestRequest CreateRequest(string function)
        {
            RestRequest request;

            if (LargeQuery.HasValue && LargeQuery.Value)
            {
                request = new RestRequest(function, Method.POST);

                //To use POST, you must use the X-HTTP-Method-Override header to tell the Translate API to treat the request as a GET (use X-HTTP-Method-Override: GET).
                request.AddHeader("X-HTTP-Method-Override", "GET");
            }
            else
            {
                request = new RestRequest(function, Method.GET);
            }

            request.AddParameter("key", _key);

            if (PrettyPrint.HasValue)
                request.AddParameter("prettyprint", PrettyPrint.ToString().ToLower());

            return request;
        }

        private T GetResponse<T>(RestRequest request)
        {
            RestResponse response = (RestResponse)_client.Execute(request);
            JsonDeserializer deserializer = new JsonDeserializer();
            T results = deserializer.Deserialize<T>(response);

            //Try to deserialize it as an error - it is a hack since I'm using generics here.
            ErrorResponse errorResponse = deserializer.Deserialize<ErrorResponse>(response);

            if (errorResponse.Error != null)
                throw new Exception(GetErrorText(errorResponse.Error));

            return results;
        }

        private string GetErrorText(Error error)
        {
            if (error != null)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(error.Message);

                if (error.Errors.Count >= 1)
                {
                    ErrorData errorData = error.Errors.First();
                    sb.Append("Reason: " + errorData.Reason);
                }

                return sb.ToString();
            }

            return "There was an error. Unable to determine the cause.";
        }
    }
}