public static async Task<string> GetCopyrightForTranslationAsync (Translation translation)
		{
			var request = BiblesDotOrgRequest.FormatVerseRequest ("Genesis 1:1", translation);
			var response = await BiblesDotOrgResponse.RequestVerseAsync (request);

			return Convert.ToCopyrightText (response);
		}

        public void ctor_T()
        {
            const int expected = 123;
            var actual = new Translation<int>(expected).Value;

            Assert.Equal(expected, actual);
        }

		public static async Task<VerseResponse> GetVerseAsync (string verse, Translation translation)
		{
			var request = BiblesDotOrgRequest.FormatVerseRequest (verse, translation);
			var response = await BiblesDotOrgResponse.RequestVerseAsync (request);

			return Convert.ToVerse (verse, response);
		}

		public static async Task<string> GetVerseTextWithoutHtmlOrDigitsAsync (string verse, Translation translation)
		{
			var request = BiblesDotOrgRequest.FormatVerseRequest (verse, translation);
			var response = await BiblesDotOrgResponse.RequestVerseAsync (request);

			return Convert.ToVerseTextWithoutHtmlOrDigits (response);
		}

        public void opEquality_Language_Language()
        {
            var obj = new Translation<int>(123, "en");
            var comparand = new Translation<int>(123, "en");

            Assert.True(obj == comparand);
        }

        public void ctor_T_Language()
        {
            var obj = new Translation<int>(123, "en");

            Assert.Equal(new Language("en"), obj.Language);
            Assert.Equal(123, obj.Value);
        }

        private void Import(string file, TranslateSet set, TranslateCategory category, Language language)
        {
            var xmlText = System.IO.File.ReadAllText(file);
            var xml = XElement.Parse(xmlText);
            foreach (var data in xml.Descendants("data"))
            {
                string key = data.Attribute("name").Value;
                string value = data.Descendants("value").Single().Value;

                var translateKey = set.TranslateKeys.Where(x => x.Label == key && x.Set == set).SingleOrDefault();
                if (translateKey == null)
                {
                    translateKey = new TranslateKey
                        {
                            Label = key,
                            Set = set,
                            Category = category
                        };

                    set.TranslateKeys.Add(translateKey);
                }

                var translation = new Translation() { Key = translateKey, Language = language, Translator = null, Value = value };

                DbSession.Save(translateKey);
                DbSession.Save(translation);
            }

            Global.CurrentSession.Update(set);
        }

        public void opInequality_Language_Language()
        {
            var obj = new Translation<int>(123, "en");
            var comparand = new Translation<int>(123, "en");

            Assert.False(obj != comparand);
        }

 public bool DeleteTranslation(Translation entity)
 {
     if (entity == null) return false;
     _unitOfWork.TranslationRepository.Delete(entity);
     _unitOfWork.Save();
     return true;
 }

        public static void InsertNewTerm(string term)
        {
            // I'm missing something here but could not figure it out right now!
            var item = new Translation { Phrase = term, TranslatedText = "", LanguageID = DEFAULT_LANGUAGE_ID };

            db.Insert(TRANSLATION_TABLE, TRANSLATION_ID, true, item);
        }

 public static TranslationVote FindVote(Translation translation, Translator translator)
 {
     return Global.CurrentSession.QueryOver<TranslationVote>()
         .Where(x => x.Translation == translation)
         .And(x => x.Translator == translator)
         .SingleOrDefault();
 }

    public static int Set(string screen, string key, Bm2s.Poco.Common.Parameter.Language language, string value)
    {
      Translation translation = new Translation();
      translation.Request.Application = TranslationUtils.ApplicationName;
      translation.Request.Screen = screen;
      translation.Request.Key = key;
      translation.Request.LanguageId = language.Id;
      translation.Get();
      Bm2s.Poco.Common.Parameter.Translation tran = translation.Response.Translations.FirstOrDefault();

      translation.Request.Translation = new Bm2s.Poco.Common.Parameter.Translation();
      translation.Request.Translation.Application = TranslationUtils.ApplicationName;
      translation.Request.Translation.Screen = screen;
      translation.Request.Translation.Key = key;
      translation.Request.Translation.Language = language;
      translation.Request.Translation.Value = value;
      if (tran != null)
      {
        translation.Request.Translation.Id = tran.Id;
      }
      translation.Post();

      HttpContext.Current.Session[TranslationUtils.TranslationSessionKey + "_" + screen + "_" + key + "_" + translation.Request.LanguageId] = value;

      return translation.Response.Translations.FirstOrDefault().Id;
    }

    public static string Get(string screen, string key, Bm2s.Poco.Common.Parameter.Language language, string defaultValue, params string[] parameters)
    {
      string result = (string)HttpContext.Current.Session[TranslationUtils.TranslationSessionKey + "_" + screen + "_" + key + "_" + language.Id];

      if (string.IsNullOrWhiteSpace(result))
      {
        Translation translation = new Translation();
        translation.Request.Application = TranslationUtils.ApplicationName;
        translation.Request.LanguageId = language.Id;
        translation.Request.Screen = screen;
        translation.Request.Key = key;
        translation.Get();

        if (!translation.Response.Translations.Any())
        {
          translation.Request.Translation = new Bm2s.Poco.Common.Parameter.Translation()
          {
            Application = TranslationUtils.ApplicationName,
            Key = key,
            Language = language,
            Screen = screen,
            Value = defaultValue
          };
          translation.Post();
        }

        result = translation.Response.Translations.FirstOrDefault().Value;
        HttpContext.Current.Session[TranslationUtils.TranslationSessionKey + "_" + screen + "_" + key + "_" + language.Id] = result;
      }

      return string.Format(result, parameters);
    }

        /**
         * Builds the list of translation
         *
         * @return the list of translation
         */
        public Translation Build() {
            Translation result = new Translation();
            result.Name = name;
            result.Description = description;
            result.Language = language;

            return result;
        }

        public static HttpWebRequest FormatVerseRequest(string verse, Translation translation)
        {
            var request = "https://www.bibles.org/v2/search.js?query=" + verse + "&version="
                + GetVersionText (translation);

            var webRequest = WebRequest.Create (request) as HttpWebRequest;
            webRequest.Credentials = new NetworkCredential (APIKey.BiblesDotOrg, "X");
            return webRequest;
        }

        /**
         * Builds the list of translation
         *
         * @return the list of translation
         */
        public Translation Build() {
			Support.LogMethodEntry();
            Translation result = new Translation();
            result.Name = name;
            result.Description = description;
            result.Language = language;
			Support.LogMethodExit(result);
            return result;
        }

 public static TranslationDto Create(Translation translation)
 {
     return new TranslationDto()
     {
         Id = translation.Id,
         Label = translation.Label,
         HelpText = translation.HelpText,
         TranslationId = translation.TranslationId
     };
 }

        public void op_Contains_Translation()
        {
            var item = new Translation<int>(123, "en");
            var obj = new TranslationDictionary<int>
                          {
                              item
                          };

            Assert.True(obj.Contains(item));
        }

        public static void RemoveVote(Translation translation)
        {
            var voter = TranslatorService.FindByEmail(HttpContext.Current.User.Identity.Name);
            var vote = FindVote(translation, voter);

            if (vote != null)
            {
                if(vote.IsPublished == false)
                    Global.CurrentSession.Delete(vote);
            }
        }

        /// <summary>
        /// Convert a number of seconds into a human readable form. Rounds up.
        /// To be consistent with zxcvbn, it returns the unit + 1 (i.e. 60 * 10 seconds = 10 minutes would come out as "11 minutes"
        /// this is probably to avoid ever needing to deal with plurals
        /// </summary>
        /// <param name="seconds">The time in seconds</param>
        /// <param name="translation">The language in which the string is returned</param>
        /// <returns>A human-friendly time string</returns>
        public static string DisplayTime(double seconds, Translation translation = Translation.English)
        {
            long minute = 60, hour = minute * 60, day = hour * 24, month = day * 31, year = month * 12, century = year * 100;

            if (seconds < minute) return GetTranslation("instant", translation);
            else if (seconds < hour) return string.Format("{0} " + GetTranslation("minutes", translation), (1 + Math.Ceiling(seconds / minute)));
            else if (seconds < day) return string.Format("{0} " + GetTranslation("hours", translation), (1 + Math.Ceiling(seconds / hour)));
            else if (seconds < month) return string.Format("{0} " + GetTranslation("days", translation), (1 + Math.Ceiling(seconds / day)));
            else if (seconds < year) return string.Format("{0} " + GetTranslation("months", translation), (1 + Math.Ceiling(seconds / month)));
            else if (seconds < century) return string.Format("{0} " + GetTranslation("years", translation), (1 + Math.Ceiling(seconds / year)));
            else return GetTranslation("centuries", translation);
        }