public void Setup()
{
var optionsBuilder = new DbContextOptionsBuilder <DictionaryContext>();
optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Lingva;Trusted_Connection=True;MultipleActiveResultSets=true;");
var _dbContext = new DictionaryContext(optionsBuilder.Options);
_dbContext.Database.EnsureDeleted();
_dbContext.Database.EnsureCreated();
_groupList = new List <Group>()
{
new Group
{
Name = "Harry Potter",
Date = DateTime.Now,
Description = "Description",
LanguageId = 1,
},
new Group
{
Name = "Harry Potter",
Date = DateTime.Now,
Description = "Description",
LanguageId = 1,
}
};
_dbContext.Set <Group>().AddRange(_groupList);
_dbContext.SaveChanges();
_groupRepository = new GroupRepository(_dbContext);
}
public override void Execute(Message message, TelegramBotClient client)
{
Console.WriteLine("Executing " + Name + "Command");
ChatId id = message.Chat.Id;
using (DictionaryContext db = new DictionaryContext())
{
//Checking if user already exists in database, creating new if not
var user = db.Users.FirstOrDefault(x => x.Chat == id.Identifier);
db.Words.Load();
if (user == null || user.Words.Count == 0)
{
Bot.Get().SendTextMessageAsync(id, "Вы ещё не добавили слов." +
"\nЧтобы добавить слово напишите команду \"/add слово перевод\"");
return;
}
string replyMessage = "Все добавленные вами слова:\n";
foreach (Word w in user.Words)
{
replyMessage += $" {w.EnglishVersion} - {w.RussianVersion}\n";
}
Bot.Get().SendTextMessageAsync(id, replyMessage);
}
}
public override object VisitDictionary(DictionaryContext context)
{
var key = Any;
var value = Any;
var result = (new Result());
foreach (var i in range(0, context.dictionaryElement().Length - 1, 1, true, true))
{
var r = (DicEle)(Visit(context.dictionaryElement(i)));
if (i == 0)
{
key = r.key;
value = r.value;
result.text += r.text;
}
else
{
if (key != r.key)
{
key = Any;
}
if (value != r.value)
{
value = Any;
}
result.text += "," + r.text;
}
}
var type = (new System.Text.StringBuilder().Append(key).Append(", ").Append(value)).to_str();
result.data = (new System.Text.StringBuilder().Append(Dic).Append("<").Append(type).Append(">")).to_str();
result.text = (new System.Text.StringBuilder().Append("(new ").Append(result.data).Append("(){ ").Append(result.text).Append(" })")).to_str();
return(result);
}
/// <summary>
/// Выборка наиболее часто встречающихся пяти слов из словаря, начало которых соответствует префиксу.
/// </summary>
/// <returns>Возвращает строку из подходящих слов, разделённых пробелом</returns>
public static string GetTopFive(string prefix)
{
try
{
using (DictionaryContext context = new DictionaryContext())
{
if (!context.Database.Exists())
{
return("Error: Словаря не существует");
}
List <Word> topFive = context.Words.Where(x => x.Text.StartsWith(prefix))
.OrderByDescending(x => x.Count)
.ThenBy(x => x.Text)
.Take(5)
.ToList();
var topFiveStr = new StringBuilder();
foreach (Word word in topFive)
{
topFiveStr.Append(word.Text + " ");
}
return(topFiveStr.ToString().TrimEnd());
}
}
catch (Exception e)
{
Console.WriteLine($"\nПри подключении к словарю возникла непредвиденная ошибка:\n{e.Message}");
return("");
}
}
public AccountController(UserManager <User> userManager, SignInManager <User> signInManager, IMailSender mailSender, DictionaryContext context)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.mailSender = mailSender;
this.context = context;
}
public static async Task InitializeAsync(IConfiguration config)
{
DbProviders dbProvider = (DbProviders)Enum.Parse(typeof(DbProviders), config.GetSection("Selectors:DbProvider").Value, true);
switch (dbProvider)
{
case DbProviders.Dapper:
DictionaryContextFactory factory = new DictionaryContextFactory();
DictionaryContext dbContext = factory.CreateDbContext(config);
await dbContext.InitializeAsync();
break;
case DbProviders.Mongo:
await new MongoContext(config).InitializeAsync();
break;
case DbProviders.CosmosSqlApi:
await new CosmosSqlApiContext(config).InitializeAsync();
break;
default:
factory = new DictionaryContextFactory();
dbContext = factory.CreateDbContext(config);
await dbContext.InitializeAsync();
break;
}
}
static void AddInitial()
{
var optionsBuilder = new DbContextOptionsBuilder <DictionaryContext>();
optionsBuilder.UseSqlite("Data source=dict.db");
var _context = new DictionaryContext(optionsBuilder.Options);
using (var inputStream = new FileStream(@"Seeder\dictionary.dsl", FileMode.Open))
{
Parser p = new Parser(inputStream);
var entries = p.ParseEntries();
int cnt = 0;
foreach (var entry in entries)
{
_context.Add(entry);
Console.WriteLine($"Add {entry.Lemma}");
if (cnt % 1000 == 0)
{
_context.SaveChanges();
}
cnt++;
}
_context.SaveChanges();
};
}
public UsageSeeder()
{
var optionsBuilder = new DbContextOptionsBuilder <DictionaryContext>();
optionsBuilder.UseSqlite("Data source=dict.db");
_ctx = new DictionaryContext(optionsBuilder.Options);
}
public void Query()
{
var map = GetTranslationMap();
var optionsBuilder = new DbContextOptionsBuilder <DictionaryContext>();
optionsBuilder.UseSqlite("Data source=dict.db");
var _context = new DictionaryContext(optionsBuilder.Options);
var lastId = _context.DictionaryEntries.OrderBy(e => e.Id).Last().Id;
var last = 0;
while (last < lastId)
{
var set = _context.DictionaryEntries
.Where(e => e.Id > last)
.OrderBy(e => e.Id)
.Take(1000);
foreach (var entry in set)
{
_context.Update(entry);
string translation;
if (map.TryGetValue(entry.Lemma, out translation))
{
entry.Translation = translation;
}
;
}
last = set.Last().Id;
_context.SaveChanges();
}
}
private static async Task ExecuteScriptsWithGlobalContextAsync()
{
Console.Out.WriteLine("Enter in your script - type \"STOP\" to quit:");
var session = new DictionaryContext();
while (true)
{
var code = Console.In.ReadLine();
if (code == "STOP")
{
break;
}
else
{
var result = await CSharpScript.RunAsync(code,
globals : session);
if (result.ReturnValue != null)
{
Console.Out.WriteLine(
$"\t{result.ReturnValue}");
}
}
}
}
public override object VisitDictionary([NotNull] DictionaryContext context)
{
var key = Any;
var value = Any;
var result = new Result();
for (int i = 0; i < context.dictionaryElement().Length; i++)
{
var r = (DicEle)Visit(context.dictionaryElement(i));
if (i == 0)
{
key = r.key;
value = r.value;
result.text += r.text;
}
else
{
if (key != r.key)
{
key = Any;
}
if (value != r.value)
{
value = Any;
}
result.text += "," + r.text;
}
}
var type = key + "," + value;
result.data = $"{dic}<{type}>";
result.text = $"(new {result.data}(){{ {result.text} }})";
return(result);
}
/// <summary>
/// Создание и заполнение словаря предоставленным списком слов
/// </summary>
private static void CreateDictionary(DictionaryContext context, List <Word> words)
{
Console.WriteLine("Процесс создания словаря...");
context.Words.AddRange(words);
context.SaveChanges();
Console.WriteLine("Словарь успешно создан!");
}
/// <summary>
/// Создание базы данных DictionaryDb и таблицы Word, с последующим заполнением элементами List<Word>, в случае,
/// если словарь существует, но данные в нем отсутствуют, заполняет уже имеющуюся таблицу.
/// </summary>
public static void CreateDictionary(string pathToFile)
{
try
{
using (DictionaryContext context = new DictionaryContext())
{
if (context.Database.Exists())
{
int hasRecord = context.Words.Take(1).ToList().Count;
if (hasRecord != 0)
{
Console.WriteLine("Словарь уже существует и содержит слова. " +
"Вы можете обновить словарь, либо очистить существующий.\n");
return;
}
}
List <Word> words = new TextProcessor().GetWordsFromFile(pathToFile);
if (words.Count == 0)
{
return;
}
CreateDictionary(context, words);
}
}
catch (Exception e)
{
Console.WriteLine($"\nПри создании словаря возникла непредвиденная ошибка:\n{e.Message} {e.StackTrace}");
}
}
public UnitOfWorkParser(DictionaryContext context, IRepositorySubtitle subtitles, IRepositorySubtitleRow subtitleRows,
IRepositoryParserWord words, IRepositoryFilm films)
{
_context = context;
_subtitles = subtitles;
_subtitleRows = subtitleRows;
_parserWords = words;
_films = films;
}
public DefinitionController(
UserManager <User> userManager,
DictionaryContext context,
IHashtagParser <Hashtag> hashtagParser
)
{
_hashtagParser = hashtagParser;
_userManager = userManager;
_context = context;
}
// TODO: issues 147: [DynamicData(nameof(GetOptionalParametersData), DynamicDataSourceType.Method)]
public void OptionalNoDefaultTest(IResolverFactory <ParameterInfo> factory)
{
var context = new DictionaryContext() as IResolveContext;
var resolver = factory.GetResolver <IResolveContext>(NoDefaultInfo);
// Validate
Assert.IsNotNull(resolver);
Assert.IsNull(resolver(ref context));
}
public void OptionalExceptionTest(IResolverFactory <Type> factory)
{
var context = new DictionaryContext() as IResolveContext;
var resolver = factory.GetResolver <IResolveContext>(typeof(string));
// Validate
Assert.IsNotNull(resolver);
Assert.IsNull(resolver(ref context));
}
public HomeController
(
//ILogger<HomeController> logger ,
DictionaryContext db,
AppUserRepository user)
{
//_logger = logger;
_db = db;
Log.log("HomeController starts...");
_user = user;
}
private static void ConfigureServices()
{
var context = new DictionaryContext();
context.Database.Migrate();
IUnitOfWork unitOfWork = new UnitOfWork(context);
_dictionaryService = new DictionaryService(unitOfWork);
_bot = BotService.GetBot();
_manager = new CommandManager(_bot, _dictionaryService);
}
// TODO: issues 147: [DynamicData(nameof(GetOptionalParametersData), DynamicDataSourceType.Method)]
public void OptionalDefaultTest(IResolverFactory <ParameterInfo> factory)
{
var context = new DictionaryContext() as IResolveContext;
var resolver = factory.GetResolver <IResolveContext>(DefaultInfo);
// Validate
Assert.IsNotNull(resolver);
var value = resolver(ref context);
Assert.AreEqual(DefaultValue, value);
}
public void Setup()
{
_connection = new SqliteConnection("Data source=:memory:");
_connection.Open();
var options = new DbContextOptionsBuilder <DictionaryContext>()
.UseSqlite(_connection)
.Options;
_context = new DictionaryContext(options);
_context.Database.EnsureCreated();
_cache = new MemoryCache(new MemoryCacheOptions());
controller = new DictionaryEntryController(_cache, _context);
}
static void Main(string[] args)
{
Console.CancelKeyPress += Console_CancelKeyPress;
AppDomain.CurrentDomain.ProcessExit += App_ProcessExit;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var defaultRepository = LoggerManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(defaultRepository, new FileInfo(AppDomain.CurrentDomain.BaseDirectory + "log4net.config"));
using var context = new DictionaryContext();
string url = args.Length > 0 ? args[0] : null;
new TratuParser(context).Parse(url, cancellationParserSource.Token);
}
public override async void Execute(Message message, TelegramBotClient client)
{
Console.WriteLine("Executing " + Name + "Command");
ChatId id = message.Chat.Id;
//Splitting message "/add word definition"
string[] messageArgs = message.Text.Split();
//If input is not correct
if (messageArgs.Length != 3)
{
string errorMessage = "Неправильный формат комманды" +
"\nПроверьте, или комманда соответствует шаблону \"/add слово перевод\"";
await client.SendTextMessageAsync(id, errorMessage);
return;
}
//TODO: move user creating and db operations to separate class
using (DictionaryContext db = new DictionaryContext())
{
//Checking if user already exists in database, creating new if not
var user = db.Users.FirstOrDefault(x => x.Chat == id.Identifier);
if (user == null)
{
user = new BotUser {
Chat = id.Identifier
};
db.Users.Add(user);
}
//Adding word to users dictionary
Word word = new Word(messageArgs[1], messageArgs[2]);
user.Words.Add(word);
//Updating data in database
db.SaveChanges();
}
await Bot.Get().SendTextMessageAsync(id, "Новое слово добавлено в ваш словарь" +
"\nEnglish: " + messageArgs[1] +
"\nПеревод: " + messageArgs[2]);
}
public UnitOfWork()
{
object oylesine = "";
if (db == null)
{
lock (oylesine)
{
if (db == null)
{
db = new DictionaryContext();
}
}
}
Languages = new BaseRepoSitory <Language>(db);
Words = new WordRepoSitory(db);
WordRequests = new BaseRepoSitory <WordRequest>(db);
TranslateManager = new TranslateManager(db);
}
public UnitOfWork()
{
object whatever = "";
if (db == null)
{
lock (whatever)
{
if (db == null)
{
db = new DictionaryContext();
}
}
}
Languages = new BaseRepository <Language>(db);
Words = new BaseRepository <Word>(db);
WordRequests = new BaseRepository <WordRequest>(db);
}
public static void SetStressIndex()
{
var optionsBuilder = new DbContextOptionsBuilder <DictionaryContext>();
optionsBuilder.UseSqlite("Data source=dict.db");
var _context = new DictionaryContext(optionsBuilder.Options);
using (var inputStream = new FileStream(@"C:\Users\Willem\Downloads\ru-ru_ozhegov_shvedova_cc_v2_0.dsl", FileMode.Open))
{
int cnt = 0;
StreamReader reader = new StreamReader(inputStream);
while (!reader.EndOfStream)
{
while (char.IsWhiteSpace((char)reader.Peek()))
{
reader.ReadLine();
}
string lemma = reader.ReadLine();
DictionaryEntry entry = _context.DictionaryEntries.Where(de => de.Lemma == lemma).FirstOrDefault();
if (entry != null)
{
string definition = reader.ReadLine();
if (definition.Contains("_"))
{
Match match = Regex.Match(definition, "[А-Я]+(?=_)");
if (match.Success)
{
_context.Update(entry);
entry.StressIndex = match.Value.Length;
cnt++;
if (cnt % 500 == 0)
{
_context.SaveChanges();
}
}
}
}
}
_context.SaveChanges();
}
}
/// <summary>
/// Добавление данных в Word, если база данных еще не создана, вызывается метод CreateDictionary и происходит её создание
/// </summary>
public static void UpdateDictionary(string pathToFile)
{
List <Word> words = new TextProcessor().GetWordsFromFile(pathToFile);
if (words.Count == 0)
{
return;
}
try
{
using (DictionaryContext context = new DictionaryContext())
{
if (!context.Database.Exists())
{
CreateDictionary(context, words);
return;
}
Console.WriteLine("Процесс обновления словаря...");
foreach (Word word in words)
{
Word dbElement = context.Words.Find(word.Text);
if (dbElement != null)
{
dbElement.Count += word.Count;
}
else
{
context.Words.Add(word);
}
}
context.SaveChanges();
Console.WriteLine("Словарь успешно обновлён!\n");
}
}
catch (Exception e)
{
Console.WriteLine($"\nПри обновлении словаря возникла непредвиденная ошибка:\n{e.Message} {e.StackTrace}");
}
}
public UnitOfWork()
{ //double lock pattern
//thread safe olarak db nin tek bir kez üretilmesini sağlamak
object oylesine = ""; //kilitlemek için nesne kullanıyoruz
if (db == null)
{
lock (oylesine)
{
if (db == null)
{
db = new DictionaryContext();
}
}
}
Languages = new BaseRepository <Language>(db);
Words = new WordRepository(db);
WordRequests = new BaseRepository <WordRequest>(db);
TranslateManager = new TranslateManager(db);
}
/// <summary>
/// Удаление всех данных из таблицы Words
/// </summary>
public static void ClearDictionary()
{
try
{
using (DictionaryContext context = new DictionaryContext())
{
if (!context.Database.Exists())
{
Console.WriteLine("Словарь не может быть очищен, так как его не существует!\n");
return;
}
Console.WriteLine("Процесс очистки словаря...");
context.Words.RemoveRange(context.Words);
context.SaveChanges();
Console.WriteLine("Словарь успешно очищен!");
}
}
catch (Exception e)
{
Console.WriteLine($"\nПри очистке словаря возникла непредвиденная ошибка:\n{e.Message} {e.StackTrace}");
}
}
public CharacterManager(DictionaryContext context)
{
Context = context;
}
public EFCFCacheRepository(DictionaryContext dbContext)
{
_dbContext = dbContext;
}
public IdiomManager(DictionaryContext context, ICharacterManager manager)
{
Context = context;
Manager = manager;
}
