/// <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);
}
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);
}
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());
}
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
}));
}
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);
}
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));
}
}
/*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));
}
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));
}
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));
}
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));
}
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);
}
}
}
}
/// <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());
}
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();
}
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);
}
}
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);
}
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));
}
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));
}
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);
}
/// <summary>
/// Корректные ли данные
/// </summary>
/// <returns>true - корректные, false - некорректные</returns>
public bool IsInvalid()
{
return(ElemsWithTranslations == null || EnumerableValidator.IsEmpty(ElemsWithTranslations));
}