Пример #1
0
        /// <summary>
        /// Возвращает count данных, которые нужно повторить
        /// </summary>
        /// <param name="sourceLanguageId">идентификатор языка с которого переводят</param>
        /// <param name="translationLanguageId">идентификатор языка на который переводят</param>
        /// <param name="count">кол-во записей</param>
        /// <returns>если есть, то данные которые нужно повторить, иначе пустой набор</returns>
        public List <UserRepetitionIntervalItem> GetRepetitionIntervalItems(long sourceLanguageId,
                                                                            long translationLanguageId,
                                                                            int count)
        {
            List <UserRepetitionIntervalItem> result = Adapter.ReadByContext(c => {
                DateTime dateTimeNow = DateTime.Now;
                //получать данные для которых подошло данные для показа
                List <Tuple <UserKnowledge, UserRepetitionInterval> > joinedData = _repetitionQuery.GetRepetitionQuery(c,
                                                                                                                       DateTime
                                                                                                                       .
                                                                                                                       MinValue,
                                                                                                                       dateTimeNow,
                                                                                                                       count);
                //NOTE: определяем время для показа, для данных, которые никогда и никому не показывали - чтобы эти данные всегда были перед данными
                //NOTE: время для показа, которых еще не подошло, но после данных, время которых просрочено
                DateTime unknownNextTimeToShow = EnumerableValidator.IsEmpty(joinedData)
                                                     ? new DateTime().GetDbDateTime()
                                                     : dateTimeNow.AddMilliseconds(1);
                if (_repetitionType == RepetitionType.All)
                {
                    //получать данные, которые ни разу не показывали пользователю
                    AddOtherData(count, joinedData, wantage => _repetitionQuery.GetRepetitionNewQuery(c, wantage));
                    //получать данные для которых время показа - еще не подошло
                    AddOtherData(count, joinedData,
                                 wantage =>
                                 _repetitionQuery.GetRepetitionQuery(c, dateTimeNow, DateTime.MaxValue, wantage));
                }

                return(ConvertToItems(sourceLanguageId, translationLanguageId, joinedData, unknownNextTimeToShow));
            }, new List <UserRepetitionIntervalItem>(0));

            return(result);
        }
Пример #2
0
        private static void AddSubmenu(HashSet <SectionId> availableSectionIds,
                                       string title,
                                       IEnumerable <MenuItem> menuItems,
                                       List <MenuItem> result)
        {
            var children = menuItems.Where(menuItem => menuItem.SectionId == SectionId.No || availableSectionIds.Contains(menuItem.SectionId)).ToList();

            if (EnumerableValidator.IsEmpty(children))
            {
                return;
            }

            MenuItem item;

            if (children.Count == 1)
            {
                item = children[0];
            }
            else
            {
                item = new MenuItem(SectionId.No, title + " <b class=\"caret\"></b>", null, null)
                {
                    Children = children
                };
            }
            result.Add(item);
        }
Пример #3
0
        public List <string> FindSentences(string words, OrderWordsInSearch orderWordsInSearch)
        {
            var             uniqueWords = new HashSet <string>(words.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
            List <Sentence> sentences   = _sentenceWordsQuery.FindSentencesByWords(uniqueWords.Select(e => e.Trim()).ToList(),
                                                                                   orderWordsInSearch);

            if (EnumerableValidator.IsEmpty(sentences))
            {
                NLPWrapper.ExternalObjects.Sentence sentence = _textAnalyzer.ParseSentence(words, false);
                var normalWords = new List <string>();
                foreach (Word word in sentence.Words)
                {
                    if (EnumerableValidator.IsNotEmpty(word.NormalForms))
                    {
                        normalWords.AddRange(word.NormalForms);
                    }
                    else
                    {
                        normalWords.Add(word.GetAppropriateWordText());
                    }
                }
                sentences = _sentenceWordsQuery.FindSentencesByWords(normalWords, orderWordsInSearch);
            }
            return(sentences.Select(e => e.Text).ToList());
        }
Пример #4
0
        public ActionResult Index(long userId, UserLanguages userLanguages)
        {
            const string EMPTY_WALL_VIEW = "EmptyWall";

            if (WebSettingsConfig.Instance.IsSectionForbidden(SectionId.MyKnowledge))
            {
                return(RedirectToAction("Index", RouteConfig.MAIN_CONTROLLER_NAME));
            }

            if (IdValidator.IsInvalid(userId) || UserLanguages.IsInvalid(userLanguages))
            {
                return(View(EMPTY_WALL_VIEW));
            }

            IUserKnowledgeQuery      userKnowledgeQuery = CreateUserKnowledgeQuery(userId);
            List <UserKnowledgeItem> items = GetData(userKnowledgeQuery, userLanguages, long.MaxValue);

            if (items == null || EnumerableValidator.IsEmpty(items))
            {
                return(View(EMPTY_WALL_VIEW));
            }

            //TODO: если будет тормозить - получать ajax'ом данные через action GetStatistic
            UserKnowledgeStatistic statistic = userKnowledgeQuery.GetStatistic();

            return(View("Index", new KnowledgeWallModel(userLanguages, items)
            {
                Statistic = statistic
            }));
        }
Пример #5
0
        public void Create(string file)
        {
            var csvReader = new CsvReader(file);
            //var sentences = IoCModule.Create<SentencesQuery>();
            var      languages = new LanguagesQuery(LanguageShortName.Unknown, LanguageShortName.Unknown);
            Language from      = languages.GetByShortName(_from);
            Language russian   = languages.GetByShortName(LanguageShortName.Ru);

            string[] firstLine = csvReader.ReadLine();
            if (firstLine == null || EnumerableValidator.IsEmpty(firstLine))
            {
                return;
            }

            string groupName = TextFormatter.FirstUpperCharAndTrim(firstLine[0]);

            if (string.IsNullOrEmpty(groupName) || groupName.Length < 2)
            {
                return;
            }
            var groupsQuery = new GroupsQuery(from.Id);

            string fileName = firstLine.Length > 1 && !string.IsNullOrWhiteSpace(firstLine[1])
                                  ? firstLine[1].Trim()
                                  : groupName;
            string imageFileName = Path.Combine(@"C:\Projects\StudyLanguages\Источники для групп\Источники картинок\",
                                                fileName + ".jpg");

            //создает или получает раннее созданную группу
            byte[]       image        = !string.IsNullOrEmpty(imageFileName) ? File.ReadAllBytes(imageFileName) : null;
            GroupForUser groupForUser = groupsQuery.GetOrCreate(GroupType, groupName, image);

            do
            {
                string[] line = csvReader.ReadLine();
                if (line == null)
                {
                    break;
                }
                if (line.Length < 2)
                {
                    continue;
                }
                image = line.Length > 2 && !string.IsNullOrEmpty(line[2]) ? File.ReadAllBytes(line[2]) : null;
                int?rating = null;
                int rat;
                if (line.Length > 3 && int.TryParse(line[3], out rat))
                {
                    rating = rat;
                }

                bool isSuccess = Create(groupForUser, line, from, russian, image, rating);
                Console.WriteLine("{0}: {1}", isSuccess ? "Сохранено" : "Не сохранено",
                                  line.Aggregate((e1, e2) => e1 + " -> " + e2));
            } while (true);
        }
Пример #6
0
        private static void TranslationsToElement(XElement container, string name, List <string> translations)
        {
            if (EnumerableValidator.IsEmpty(translations))
            {
                return;
            }

            foreach (string translation in translations)
            {
                container.Add(new XElement(name, translation));
            }
        }
Пример #7
0
        /*public JsonResult GetExamples(UserLanguages userLanguages,
         *                            GroupForUser group) {
         *  if (userLanguages == null || group == null || UserLanguages.IsInvalid(userLanguages)) {
         *      return JsonResultHelper.Error();
         *  }
         *  GroupModel model = GetModel(userLanguages, group);
         *  if (model.IsInvalid()) {
         *      return JsonResultHelper.Error();
         *  }
         *
         *  var resultExamples = new List<Tuple<long, List<string>>>();
         *  var searchEngineFactory = new SentencesSearchEngineFactory();
         *  ISentencesSearchEngine fromSentencesSearchEngine = searchEngineFactory.Create(userLanguages.From.Id);
         *  ISentencesSearchEngine toSentencesSearchEngine = searchEngineFactory.Create(userLanguages.To.Id);
         *
         *  foreach (SourceWithTranslation elem in model.ElemsWithTranslations) {
         *      model.SetCurrent(elem);
         *
         *      AddExample(fromSentencesSearchEngine, elem.Source, resultExamples);
         *      AddExample(toSentencesSearchEngine, elem.Translation, resultExamples);
         *  }
         *  return JsonResultHelper.GetUnlimitedJsonResult(resultExamples);
         * }*/

        /*protected JsonResult GetKnowledgeInfo(long userId, UserLanguages userLanguages, GroupForUser group) {
         *  if (IdValidator.IsInvalid(userId) || group == null) {
         *      return JsonResultHelper.Error();
         *  }
         *  GroupModel model = GetModel(userLanguages, group, GetPatternsForAll(group));
         *  if (model.IsInvalid()) {
         *      return JsonResultHelper.Error();
         *  }
         *  var knowledgeQuery = IoCModule.Create<UserKnowledgeQuery>();
         *  var statuses = //knowledgeQuery.GetStatusesByDataIds(model.ElemsWithTranslations.Select(e => e.Id).ToList());
         *  return GetUnlimitedJsonResult(statuses);
         * }*/

        public void AddExample(ISentencesSearchEngine sentencesSearcher,
                               PronunciationForUser entity,
                               List <Tuple <long, List <string> > > result)
        {
            List <string> examples = sentencesSearcher.FindSentences(entity.Text, OrderWordsInSearch.ExactWordForWord);

            if (EnumerableValidator.IsEmpty(examples))
            {
                return;
            }

            result.Add(new Tuple <long, List <string> >(entity.Id, examples));
        }
Пример #8
0
        public static T Get <T>(XElement element, params string[] names)
        {
            if (EnumerableValidator.IsEmpty(names))
            {
                return(default(T));
            }

            XElement elem             = GetElementByNames(element, names);
            string   valueElementName = names[names.Length - 1];
            XElement valueElement     = elem != null?elem.Element(valueElementName) : null;

            return(valueElement != null?ParseValue <T>(GetElementValue(valueElement)) : default(T));
        }
Пример #9
0
        internal string GetAdditionalInfo()
        {
            if (EnumerableValidator.IsEmpty(_additionalInfo))
            {
                return(null);
            }

            var xElement = new XElement("Info");

            foreach (var additionalInfo in _additionalInfo)
            {
                xElement.Add(new XElement(additionalInfo.Key.ToString(), additionalInfo.Value));
            }
            return(xElement.ToString(SaveOptions.DisableFormatting));
        }
Пример #10
0
        public JsonResult GetExistenceIds(long userId, List <long> ids, KnowledgeDataType dataType)
        {
            /*             List<long> ids = new List<long>();
             * KnowledgeDataType dataType = KnowledgeDataType.SentenceTranslation;*/
            List <long> parsedIds = ids != null?ids.Where(IdValidator.IsValid).ToList() : new List <long>(0);

            if (IdValidator.IsInvalid(userId) || EnumerableValidator.IsEmpty(parsedIds) ||
                EnumValidator.IsInvalid(dataType))
            {
                return(JsonResultHelper.Error(INVALID_DATA));
            }

            IUserKnowledgeQuery userKnowledgeQuery = CreateUserKnowledgeQuery(userId);
            List <long>         existenceIds       = userKnowledgeQuery.GetExistenceIds(parsedIds, dataType);

            return(JsonResultHelper.GetUnlimitedJsonResult(existenceIds));
        }
Пример #11
0
        private void Translate(IEnumerable <ITranslator> translators,
                               LanguageShortName from,
                               LanguageShortName to,
                               string text)
        {
            foreach (ITranslator translator in translators)
            {
                List <string> translations = translator.Translate(from, to, text);
                if (translations == null)
                {
                    //TODO: логировать
                    continue;
                }

                //считаем что перевод не может совпадать с исходным текстом(т.к. переводчики возвращают исходный текст, когда не знают как его перевести)
                translations =
                    translations.Where(e => !string.Equals(e, text, StringComparison.InvariantCultureIgnoreCase)).Select(e => e).ToList();
                if (EnumerableValidator.IsEmpty(translations))
                {
                    //TODO: логировать
                    continue;
                }

                foreach (string translation in translations)
                {
                    string normalizedTranslation = translation.Trim().ToLowerInvariant();
                    if (_bestTranslations.ContainsKey(normalizedTranslation))
                    {
                        _bestTranslations[normalizedTranslation]++;
                        continue;
                    }

                    if (_otherTranslations.ContainsKey(normalizedTranslation))
                    {
                        _bestTranslations.Add(normalizedTranslation, 2);
                        _otherTranslations.Remove(normalizedTranslation);
                    }
                    else
                    {
                        _initialsByNormalized.Add(normalizedTranslation, translation);
                        _otherTranslations.Add(normalizedTranslation, 1);
                    }
                }
            }
        }
Пример #12
0
        /// <summary>
        /// Переводит на язык to, тексты которые указаны в textsByFromLanguages
        /// </summary>
        /// <param name="to">язык на который нужно перевести</param>
        /// <param name="textsWithLanguages">список текстов на разных, которые означают одно и то же и значение перевод у которых будет одно и тоже</param>
        /// <returns>наилучшии общие переводы для текстов на разных языках; пустой список если не удалось определить наилучшие переводы</returns>
        public List <string> Translate(LanguageShortName to,
                                       IEnumerable <Tuple <LanguageShortName, string> > textsWithLanguages)
        {
            _bestTranslations.Clear();
            _otherTranslations.Clear();
            _initialsByNormalized.Clear();

            Translate(_translators, to, textsWithLanguages);
            if (EnumerableValidator.IsEmpty(_bestTranslations) && EnumerableValidator.IsNotEmpty(_extraTranslators))
            {
                //наилучшие переводы не найдены - перевести с помощью дополнительных переводчиков
                Console.WriteLine("Воспользуемся дополнительными переводчиками!!!");
                CountExtraCalls++;
                Translate(_extraTranslators, to, textsWithLanguages);
            }

            return(GetBestTranslations());
        }
Пример #13
0
        private void SaveConvertedWords(string fileName,
                                        IEnumerable <SourceWithTranslation> words)
        {
            var translationSaver = new TranslationSaver(fileName);

            foreach (SourceWithTranslation sourceWithTranslation in words)
            {
                PronunciationForUser source      = sourceWithTranslation.Source;
                PronunciationForUser translation = sourceWithTranslation.Translation;

                var textsWithLanguages = new List <Tuple <LanguageShortName, string> > {
                    new Tuple <LanguageShortName, string>(_languageShortNames[source.LanguageId],
                                                          source.Text),
                    new Tuple <LanguageShortName, string>(_languageShortNames[translation.LanguageId],
                                                          translation.Text),
                };

                string sourceWords = string.Join(", ", textsWithLanguages.Select(e => e.Item2));

                List <string> bestTranslations  = _translator.Translate(_languageTo, textsWithLanguages);
                List <string> otherTranslations = _translator.GetOtherTranslations();
                translationSaver.Write(sourceWithTranslation, bestTranslations, otherTranslations);

                if (EnumerableValidator.IsNotEmpty(bestTranslations))
                {
                    Console.WriteLine("Лучшие переводы для {0} это {1}", sourceWords,
                                      string.Join(", ", bestTranslations));
                    //TODO: сохранять в БД, предварительно изменив регистр в соответствии с английским словом
                    continue;
                }

                if (EnumerableValidator.IsEmpty(otherTranslations))
                {
                    //не нашли вообще переводов - сообщить
                    Console.WriteLine("ERROR: Для {0} не нашли вообще переводов. Пропустить", sourceWords);
                }

                Console.WriteLine(
                    "WARNING: Для слова {0} нашли переводы {1}, но среди них нет лучшего. Пропустить", sourceWords,
                    string.Join(", ", otherTranslations));
            }

            translationSaver.Save();
        }
Пример #14
0
        public void FillFromXml(string fileName, Action <int, string, IEnumerable <string>, bool> callBack)
        {
            Load();

            XDocument doc = XDocument.Load(fileName);

            foreach (XElement cardElement in doc.Root.Elements("card"))
            {
                XElement wordElement = cardElement.XPathSelectElement("word");
                if (wordElement == null)
                {
                    return;
                }
                string word = wordElement.Value.Trim();
                if (string.IsNullOrEmpty(word))
                {
                    return;
                }
                IEnumerable <XElement> translations =
                    cardElement.XPathSelectElements("meanings/meaning/translations/word");
                List <string> dirtyTranslationsWords = translations.Where(e => !string.IsNullOrEmpty(e.Value))
                                                       .SelectMany(e => _xmlRegex.Split(e.Value)).Select(e => e.Trim())
                                                       .Where(e => !string.IsNullOrEmpty(e)).Distinct().ToList();

                if (EnumerableValidator.IsEmpty(dirtyTranslationsWords))
                {
                    return;
                }

                bool isSaved = CreateWordWithTranslation(word, dirtyTranslationsWords, WordType.Default);
                if (!isSaved)
                {
                    LoggerWrapper.LogTo(LoggerName.Errors).ErrorFormat(
                        "WordFiller.FillFromXml can't add word {0}, translations: {1}", word,
                        string.Join(",", dirtyTranslationsWords));
                }
                callBack(++_counter, word, dirtyTranslationsWords, isSaved);
            }
        }
Пример #15
0
        public static Dictionary <TKey, TValue> GetDictionary <TKey, TValue>(XElement element, params string[] names)
        {
            if (EnumerableValidator.IsEmpty(names))
            {
                return(null);
            }

            XElement elem             = GetElementByNames(element, names);
            string   valueElementName = names[names.Length - 1];

            var result = new Dictionary <TKey, TValue>();

            if (elem == null)
            {
                return(result);
            }
            foreach (XElement valueElement in elem.Elements(valueElementName))
            {
                var parsedKey   = ParseAttribute <TKey>(valueElement, "key");
                var parsedValue = ParseAttribute <TValue>(valueElement, "value");
                result.Add(parsedKey, parsedValue);
            }
            return(result);
        }
Пример #16
0
        public JsonResult Search(UserLanguages userLanguages, string query)
        {
            if (UserLanguages.IsInvalid(userLanguages))
            {
                return(JsonResultHelper.Error());
            }
            WordsByPattern result;

            if (!string.IsNullOrEmpty(query))
            {
                var wordsQuery = new WordsQuery();
                result = wordsQuery.GetLikeWords(userLanguages, query, WordType);
                if (EnumerableValidator.IsEmpty(result.Words))
                {
                    //попробовать перевести символы из латинских в русские, из русских в латинские
                    result = GetKeyboardLayoutResult(userLanguages, query, wordsQuery);
                }
            }
            else
            {
                result = new WordsByPattern();
            }
            return(Json(result, JsonRequestBehavior.AllowGet));
        }
Пример #17
0
        public ActionResult Detail(string baseUrlPart)
        {
            if (WebSettingsConfig.Instance.IsSectionForbidden(SectionId.TVSeries))
            {
                return(RedirectToAction("Index", RouteConfig.MAIN_CONTROLLER_NAME));
            }

            var tvSeriesQuery            = new TVSeriesQuery(WebSettingsConfig.Instance.DefaultUserLanguages.From.Id);
            List <TVSeriesWatch> watches = tvSeriesQuery.GetSeriesWatches(baseUrlPart);

            if (EnumerableValidator.IsEmpty(watches))
            {
                return(RedirectToAction("Index", RouteConfig.MAIN_CONTROLLER_NAME));
            }

            TVSeriesInfo seriesInfo = watches[0].GetSeriesInfo();
            var          model      = new TVSeriesModel {
                Title     = seriesInfo.Title,
                OrigTitle = seriesInfo.OrigTitle,
                Series    = ConvertWatchesToModels(watches)
            };

            return(View("../Video/TVSeriesIndex", model));
        }
Пример #18
0
        public static List <T> GetList <T>(XElement element, params string[] names)
        {
            if (EnumerableValidator.IsEmpty(names))
            {
                return(null);
            }

            XElement elem             = GetElementByNames(element, names);
            string   valueElementName = names[names.Length - 1];

            var result = new List <T>();

            if (elem == null)
            {
                return(result);
            }
            foreach (XElement valueElement in elem.Elements(valueElementName))
            {
                string dirtyValue  = GetElementValue(valueElement);
                var    parsedValue = ParseValue <T>(dirtyValue);
                result.Add(parsedValue);
            }
            return(result);
        }
Пример #19
0
 /// <summary>
 /// Корректные ли данные
 /// </summary>
 /// <returns>true - корректные, false - некорректные</returns>
 public bool IsInvalid()
 {
     return(ElemsWithTranslations == null || EnumerableValidator.IsEmpty(ElemsWithTranslations));
 }