public static void SaveOrUpdate(NoteAttachmentModel noteModel)
{
lock (NoteLocker)
{
bool addedNote = false;
DbEndPoint.SetTimestamps(noteModel);
using (var context = contextFactory.CreateContext <NoteAttachmentModel>())
{
var existingModel = context.Objects.FirstOrDefault(note => note.Id == noteModel.Id);
if (existingModel != null)
{
existingModel.AcceptModelProperties(noteModel);
}
else
{
addedNote = true;
context.Objects.Add(noteModel);
}
context.SaveChanges();
if (addedNote)
{
EventNoteAdded(noteModel);
}
}
}
}
public void DefaultQuery(Action <IQuery <VD_Sys_Menu> > action)
{
using (var db = DbContextFactory.CreateContext())
{
var query = db.Query <Sys_Menu>().LeftJoin <Sys_Menu>((q, p) => q.ParentId == p.Id).
Select((q, p) => new VD_Sys_Menu()
{
Id = q.Id,
//AutoID = 0,
ButtonMode = q.ButtonMode,
Enabled = q.Enabled,
IconClass = q.IconClass,
IconUrl = q.IconUrl,
MenuCode = q.MenuCode,
MenuName = q.MenuName,
MenuType = q.MenuType,
ParentId = q.ParentId,
ParentId_Code = p.MenuCode,
Sort = q.Sort,
Url = q.Url,
Remark = q.Remark
});
action?.Invoke(query);
//return query.FirstOrDefault();
}
}
public Form1()
{
InitializeComponent();
DbContextFactory newContextFactory = new DbContextFactory();
connect = newContextFactory.CreateContext();
}
public HangerdResult <WordDto> AddWord(string stem)
{
return(TryOperate(() =>
{
if (string.IsNullOrWhiteSpace(stem))
{
throw new HangerdException("词干不可为空");
}
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.GetWordByStem(stem, false);
if (word != null)
{
throw new HangerdException("该单词已存在");
}
word = new Word(stem);
wordRepository.Add(word);
unitOfWork.Commit();
return Mapper.Map <Word, WordDto>(word);
}
}));
}
public async Task <MapDTO> Find(int mapId)
{
using (var context = contextFactory.CreateContext())
{
var entity = await context.Maps.FindAsync(mapId);
if (entity == null)
{
return(default);
public async Task <MonsterDataDTO> GetMonsterData(int gameId)
{
using (var context = contextFactory.CreateContext())
{
var entity = await context.MonstersData.FindAsync(gameId);
if (entity == null)
{
return(default);
public async Task <MonsterDTO> GetMonster(long monsterId)
{
using (var context = contextFactory.CreateContext())
{
var entity = await context.Monsters.FindAsync(monsterId);
if (entity == null)
{
return(default);
/// <summary>
/// Factory method for creating handlers
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <returns></returns>
private static IHandler GetHandler <TRequest>()
{
if (typeof(TRequest) == typeof(BikeSearchCommand))
{
return(new BikeSearchCommandHandler((RegistarDbContext)DbContextFactory.CreateContext("RegistarDbContext")));
}
//
return(null);
}
public int GetTotalNumberOfWords()
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
return(wordRepository.GetTotalNumberOfWords());
}
}
public async Task <AccountDTO> GetAccountByName(string name)
{
using (var context = contextFactory.CreateContext())
{
var entity = await context.Accounts.FirstOrDefaultAsync(x => x.Username == name);
if (entity is null)
{
return(default);
private static IEvolutionLogic GetApplication(IDatabaseAuthenticationOptions dbAuthOptions)
{
PopulateMissingConfigValues(ref dbAuthOptions);
var context = DbContextFactory.CreateContext(dbAuthOptions);
var repo = new EvolutionRepo(context);
var fileSystem = new FileContext();
var fileSystemRepo = new FileRepo(fileSystem);
return(new EvolutionLogic(repo, fileSystemRepo));
}
public async Task <IEnumerable <CharacterDTO> > FindAll(long accountId)
{
using (var context = contextFactory.CreateContext())
{
IEnumerable <DbCharacter> entities =
await context.Characters.Where(x => x.AccountId == accountId).ToListAsync();
if (entities is null)
{
return(default);
public void CreateContext()
{
var factory = new DbContextFactory <TestDbContext>(Fixtures.SqlSessionFactory,
typeof(NotNullEntityRepository).Assembly);
var dbCtx = factory.CreateContext();
Assert.IsNotNull(dbCtx);
Assert.IsInstanceOf <NotNullEntityRepository>(dbCtx.NotNullEntityRepository);
Assert.IsInstanceOf <NullableEntityRepository>(dbCtx.NullableEntityRepository);
}
public MorphemeDto GetMorpheme(string id)
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var spec = MorphemeSpecifications.IdEquals(id);
return(Mapper.Map <Morpheme, MorphemeDto>(
morphemeRepository.Get(spec, false)));
}
}
public IEnumerable <MorphemeDto> GetAllMorphemes(int pageIndex, int pageSize, out int totalCount)
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var morphemes = morphemeRepository.GetAll(false)
.OrderBy(m => m.Standard)
.Paging(pageIndex, pageSize, out totalCount);
return(Mapper.Map <IEnumerable <Morpheme>, IEnumerable <MorphemeDto> >(morphemes));
}
}
public IEnumerable <WordDto> GetWordListByMorpheme(string morphemeId, int maxCount, out int totalCount)
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var wordList = wordRepository
.GetAll(WordSpecifications.ContainsMorphemeId(morphemeId), false, w => w.Interpretations)
.OrderBy(w => w.Stem)
.Paging(1, maxCount, out totalCount);
return(Mapper.Map <IEnumerable <Word>, IEnumerable <WordDto> >(wordList));
}
}
public WordDto GetWord(string wordStem)
{
if (string.IsNullOrWhiteSpace(wordStem))
{
return(null);
}
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.GetWordByStem(wordStem, false, w => w.Morphemes, w => w.Interpretations);
return(Mapper.Map <Word, WordDto>(word));
}
}
public IActionResult DBback()
{
IOHelper.CreateDirectory(Path.Combine(_hostingEnvironment.WebRootPath, "/DBBackUp/"));
SqlParameter[] para_sys = new SqlParameter[]
{
new SqlParameter("@BKPATH", Path.Combine(_hostingEnvironment.WebRootPath, "/DBBackUp/") + DateTime.Now.ToString("yyyyMMddHHmmss") + ".bak"),
};
int count = ("backup database " + "Mrc" + " to disk=@BKPATH").Count();
var dbcontext = DbContextFactory.CreateContext("");
// dbcontext.SqlQuery("backup database " + "Mrc" + " to disk=@BKPATH");
return(Json(new { ok = "" }));
}
public async Task GetContactById_Query_should_return_Contact_with_Id()
{
// Arrange
int id = 1;
var context = DbContextFactory.CreateContext();
var query = new GetContactModelByIdQuery(id);
var handler = new GetContactModelByIdQueryHandler(context, _mapper);
// Act
var result = await handler.Handle(query, new CancellationToken());
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(id, result.Id);
Assert.AreEqual(ContactFactory.Name, result.Name);
}
public HangerdResult <bool> RemoveMorphemeForWord(string wordId, string morphemeId)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.Get(wordId, true, w => w.Morphemes);
Requires.NotNull(word, "单词信息不存在");
word.RemoveMorpheme(morphemeId);
unitOfWork.Commit();
}
}));
}
public HangerdResult <bool> ModifyMorpheme(string morphemeId, MorphemeDto morphemeDto)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var morpheme = morphemeRepository.Get(morphemeId, true);
morpheme.ModifyVariant(morphemeDto.Variant);
morpheme.ModifyDescription(morphemeDto.Description);
morphemeRepository.Update(morpheme);
unitOfWork.Commit();
}
}));
}
public HangerdResult <bool> AddWordInterpretation(string wordId, WordInterpretationDto interpretationDto)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.Get(wordId, true, w => w.Interpretations);
Requires.NotNull(word, "单词信息不存在");
word.AddInterpretation((PartOfSpeech)interpretationDto.PartOfSpeech, interpretationDto.Interpretation);
wordRepository.Update(word);
unitOfWork.Commit();
}
}));
}
public IEnumerable <MorphemeDto> GetMorphemeList(string fuzzyMorpheme, int maxCount, out int totalCount)
{
if (string.IsNullOrWhiteSpace(fuzzyMorpheme))
{
totalCount = 0;
return(new MorphemeDto[0]);
}
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var morphemeList = morphemeRepository
.GetAll(MorphemeSpecifications.StandardLike(fuzzyMorpheme.Trim()), false)
.OrderBy(m => m.Standard)
.Paging(1, maxCount, out totalCount);
return(Mapper.Map <IEnumerable <Morpheme>, IEnumerable <MorphemeDto> >(morphemeList));
}
}
public HangerdResult <bool> RemoveWordInterpretation(string wordId, string interpretationId)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.Get(wordId, true, w => w.Interpretations);
Requires.NotNull(word, "单词信息不存在");
word.RemoveInterpretation(interpretationId);
wordRepository.Update(word);
unitOfWork.Commit();
}
}));
}
public async Task CreateContact_Command_should_return_new_Contact()
{
// Arrange
var context = DbContextFactory.CreateContext();
var validator = new ContactValidator();
var contactModel = ContactFactory.GetContactModel(0);
var command = new CreateContactCommand(contactModel);
var handler = new CreateContactCommandHandler(context, validator, _mapper);
// Act
var result = await handler.Handle(command, new CancellationToken());
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.IsSuccessful);
Assert.IsTrue(result.Id > 0);
}
public IEnumerable <WordDto> GetWordListWithInterpretation(string fuzzyWord, int maxCount, out int totalCount)
{
if (string.IsNullOrWhiteSpace(fuzzyWord))
{
totalCount = 0;
return(new WordDto[0]);
}
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var wordList = wordRepository
.GetAll(WordSpecifications.StemLike(fuzzyWord.Trim()), false, w => w.Interpretations)
.OrderBy(w => w.Stem)
.Paging(1, maxCount, out totalCount);
return(Mapper.Map <IEnumerable <Word>, IEnumerable <WordDto> >(wordList));
}
}
public async Task Hello()
{
using (var dbContext = _dbContextFactory.CreateContext())
{
var discordUserId = Context.User.Id;
#region Fetch Discord User
var discordUser = dbContext.DiscordUsers.Find(discordUserId);
if (discordUser == null)
{
_logger.LogInformation("User does not yet exist, creating it");
discordUser = new DiscordUser {
DiscordUserId = Context.User.Id
};
dbContext.DiscordUsers.Add(discordUser);
}
var accessToken = GetAccessToken(dbContext, discordUser);
if (accessToken != null)
{
if (await IsValidAccessToken(accessToken))
{
await HelloKnownUser(dbContext, discordUser);
}
else
{
await HelloForgottenUser(dbContext, discordUser);
}
}
else
{
await HelloUnknownUser(dbContext, discordUser);
}
#endregion
dbContext.SaveChanges();
}
}
public Task DoAsync(Action <IDbContext> action, bool?startTransaction = null)
{
return(Task.Run(() =>
{
using (var dbContext = DbContextFactory.CreateContext())
{
if (startTransaction.HasValue && startTransaction.Value)
{
dbContext.DoWithTransaction(() =>
{
action(dbContext);
});
}
else
{
action(dbContext);
}
}
}));
}
public HangerdResult <bool> ModifyWord(string wordId, WordDto wordDto)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var wordRepository = unitOfWork.GetRepository <IWordRepository>();
var word = wordRepository.Get(wordId, true, w => w.Interpretations);
Requires.NotNull(word, "单词信息不存在");
word.ModifyPhonetic(wordDto.Phonetic);
word.ModifyExampleSentence(wordDto.ExampleSentence);
wordRepository.Update(word);
unitOfWork.Commit();
}
}));
}
public HangerdResult <MorphemeDto> AddMorpheme(MorphemeDto morphemeDto)
{
return(TryOperate(() =>
{
using (var unitOfWork = DbContextFactory.CreateContext())
{
var morphemeRepository = unitOfWork.GetRepository <IMorphemeRepository>();
var morpheme = new Morpheme(
morphemeDto.Standard,
morphemeDto.Variant,
morphemeDto.Description,
(MorphemeType)morphemeDto.Type);
morphemeRepository.Add(morpheme);
unitOfWork.Commit();
return Mapper.Map <Morpheme, MorphemeDto>(morpheme);
}
}));
}
