public long Create(User user) { using (var connection = dbFactory.Create()) { return(Convert.ToInt64(connection.Insert(user).GetInsertedId <object>())); } }
public long Create(TodoItem todoItem) { using (var connection = dbFactory.Create()) { return(Convert.ToInt64(connection.Insert(todoItem).GetInsertedId <object>())); } }
public IUnitOfWork UnitOfWork() { var uow = _factory.Create <IUnitOfWork>(_factory, this); uow.SqlDialect = SqlDialect; return(uow); }
public async Task <IEnumerable <Brave> > QueryAsync() { using (var session = _dbFactory.Create <IFooSession>()) { return(await _braveRepository.GetAllAsync(session).ConfigureAwait(false)); } }
public static void TestSetup() { if (Connection != null) { return; } Factory = A.Fake <IDbFactory>(x => x.Strict()); _settings = A.Fake <IMyDatabaseSettings>(); var path = $@"{TestContext.CurrentContext.TestDirectory}\RepoTests.db"; if (File.Exists(path)) { File.Delete(path); } A.CallTo(() => _settings.ConnectionString).Returns($@"Data Source={path};Version=3;New=True;BinaryGUID=False;"); Connection = CreateSession(null); A.CallTo(() => Factory.Create <ITestSession>()).ReturnsLazily(CreateSession); A.CallTo(() => Factory.Create <ISession>()).ReturnsLazily(CreateSession); A.CallTo(() => Factory.Create <IUnitOfWork>(A <IDbFactory> ._, A <ISession> ._, IsolationLevel.Serializable)) .ReturnsLazily(CreateUnitOrWork); A.CallTo(() => Factory.Create <IUnitOfWork, ITestSession>(A <IsolationLevel> ._)) .ReturnsLazily(CreateUnitOrWork); A.CallTo(() => Factory.Create <IUnitOfWork, ISession>(A <IsolationLevel> ._)) .ReturnsLazily(CreateUnitOrWork); A.CallTo(() => Factory.Release(A <IDisposable> ._)).DoesNothing(); new MigrateDb(Connection); }
public async Task CreateQuiz(string name) { using var factory = await _dbFactory.Create(IsolationLevel.ReadCommitted); var context = factory.For <QuizDbContext>(); var q = new Quiz { Title = name }; context.Quiz.Add(q); await context.SaveChangesAsync(); factory.CommitTransaction(); }
public int AddUser(UserModel user) { try { using (var db = _dbFactory.Create()) { return(db.Execute("Insert Into user(`Name`,`Email`)Values(@Name, @Email)", user)); } } catch (Exception ex) { _logger.Error("adduser", ex); return(0); } }
public void ArrangeAndAct() { _folder = "vgn6to834nchgiyoewrngcyfueiwrgcnytr4"; _filePaths = new[] { "vngtyicnhyucikw", "ny6ft5874386ngdtyrugw22dfr", "bhj765ghyegft43" }; _filePathsProvider = A.Fake <IFilePathsProvider>(); A.CallTo(() => _filePathsProvider.GetFilePathsFromFolder(_folder)).Returns(_filePaths); _fileContentProvider = A.Fake <IFileContentProvider>(); _content1 = "n7g9865yn3879gchyruicgchu542"; A.CallTo(() => _fileContentProvider.GetDataFrom(_filePaths[0])).Returns(_content1); A.CallTo(() => _fileContentProvider.GetDataFrom(_filePaths[1])).Throws <Exception>(); _content3 = "vhy67538ongt87rw2nfgrycngfyr42"; A.CallTo(() => _fileContentProvider.GetDataFrom(_filePaths[2])).Returns(_content3); _dbFactory = A.Fake <IDbFactory>(); _db = A.Fake <IDb>(); A.CallTo(() => _dbFactory.Create()).Returns(_db); _out = new FilesProcessor(_filePathsProvider, _fileContentProvider, _dbFactory); //act _out.ProcessFilesFromFolder(_folder); }
public void ShouldCallDatabaseTwice() { A.CallTo(() => _dbFactory.Create()).MustHaveHappened(2, Times.Exactly); A.CallTo(() => _db.SetParameter(null, null)).WithAnyArguments().MustHaveHappened(4, Times.Exactly); A.CallTo(() => _db.ExecuteStoredProcedure("files_pkg.save_file_with_content")).MustHaveHappened(2, Times.Exactly); A.CallTo(() => _db.Dispose()).MustHaveHappened(2, Times.Exactly); }
public static T Do <T>(this IDbFactory fac, Func <DbConnection, T> act) { using (var db = fac.Create()) { return(act(db)); } }
public async Task <IHttpActionResult> Post([FromBody] RequestModel[] models) { if (models == null || models.Length == 0) { return(StatusCode(System.Net.HttpStatusCode.BadRequest)); } try { using (var db = dbFactory.Create()) { foreach (var model in models) { db.Requests.Add(new Request { Index = model.Index, Visits = model.Visits, Name = model.Name, Date = model.Date }); } await db.SaveChangesAsync(); } return(StatusCode(System.Net.HttpStatusCode.Created)); } catch (Exception e) { return(InternalServerError(e)); } }
public async Task <int> ExecuteAsync(Brave request) { using (var uow = _dbFactory.Create <IUnitOfWork, IFooSession>(IsolationLevel.Serializable)) { return(await _braveRepository.SaveOrUpdateAsync(request, uow)); } }
public async Task CreateBook(int authorId, string title) { using var factory = await _dbFactory.Create(IsolationLevel.Snapshot); var context = factory.For <BooksDbContext>(); var book = new Book { Title = "New book", AuthorId = authorId }; context.Book.Add(book); await context.SaveChangesAsync(); factory.CommitTransaction(); }
public static Func <DbConnection> ToConnectionFactory(this IDbFactory factory) { return(() => { var db = factory.Create((string)null); db.Open(); return db; }); }
public List <oil_filltype> List() { using (var conn = _dbFactory.Create()) { var sql = "select * from oil_filltype"; var list = conn.Query <oil_filltype>(sql).ToList(); return(list); } }
public void Start() { using (var uow = _dbFactory.Create <IUnitOfWork, IFooSession>(IsolationLevel.Serializable)) { var databaseProvider = new SqliteDatabaseProvider(uow.Connection as System.Data.Common.DbConnection); var migrator = new SimpleMigrator(Assembly.GetExecutingAssembly(), databaseProvider); migrator.Load(); migrator.MigrateToLatest(); } }
public async Task <string> PingDb() { try { return((await _dbFactory.Create()).FactoryFor <ApnaBawarchiKhanaDbContext>().Categories.Count().ToString()); } catch { return("No Connection to Database"); } }
public ProcessedCommitsCount StartOrContinue(string name) { using (var db = _db.Create()) { var skip = db.QueryValue(q => q.From <BatchProgress>().Where(d => d.Name == name).Select(d => d.Skip).MapTo <long?>()); if (skip == null) { skip = 0; db.Insert(new BatchProgress() { Name = name }); } return(new ProcessedCommitsCount((int)skip.Value)); } }
public virtual ActionResult Subscribe(SubscriptionViewModel model) { if (ModelState.IsValid) { var item = GetEntities <Subscriber>().FirstOrDefault(x => x.Email == model.Email); if (item != null) { if (!item.IsApprowed) { /* send email? */ } } else { item = new Subscriber { Date = DateTime.Now, Email = model.Email, Url = HttpContext.Request.UrlReferrer.ToString(), IsApprowed = false, Key = Guid.NewGuid().ToString().Replace("-", "") }; using (var db = _factory.Create()) { db.Set <Subscriber>().Add(item); db.SaveChanges(); } EmailService.SendMail(new SendMailViewModel { From = AppConfig.GetValue("Emails.Subscribers.From"), SenderName = AppConfig.GetValue("Emails.Subscribers.SenderName"), Subject = AppConfig.GetValue("Emails.Subscribers.Subject"), TemplateName = MVC.Mails.Views.SubscriptionConfirm, To = model.Email, ViewModel = item }, ControllerContext); } return(Json(new { success = true })); } return(Json(new { success = false })); }
public virtual IEnumerable <TEntity> Get( Expression <Func <TEntity, bool> > filter = null, Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderBy = null, params Expression <Func <TEntity, object> >[] includeProperties) { using (var db = _dbFactory.Create()) { IQueryable <TEntity> query = db.Set <TEntity>(); if (filter != null) { query = query.Where(filter); } foreach (var includeProperty in includeProperties) { query = query.Include(includeProperty); } if (orderBy != null) { return(orderBy(query).ToList()); } return(query.ToList()); } }
public IUserIdentity GetUserFromIdentifier(Guid identifier, NancyContext context) { using (var db = _dbFactory.Create()) { var token = db.SingleOrDefault <AuthenticationToken>("SELECT * FROM AuthenticationTokens WHERE Id=@0", identifier.ToByteArray()); if (token == null) { return(null); } return(new UserIdentity(db.SingleOrDefault <User>("SELECT * FROM Users WHERE Id=@0", token.UserId))); } }
public async Task <IEnumerable <User> > GetAllUsers() { try { using var factory = await _dbFactory.Create(); return(await factory.FactoryFor <ApnaBawarchiKhanaDbContext>().Users.ToListAsync()); } catch { return(null); } }
public static void Init(IDbFactory fac,string dbSchema="") { using (var db = fac.Create()) { db.CreateTableFrom<ServerStateItem>(c => { c.TableName("dbus_server_state", dbSchema); c.IgnoreIfExists(); c.ColumnSize(d => d.Data, "max"); }); db.Insert(new ServerStateItem() {Data = new DispatcherState().Serialize()}); } }
public RegistrationModule(IDbFactory dbFactory) : base("Users") { var viewModel = new RegisterViewModel(); Get["/register"] = parameters => View["Register.cshtml", viewModel]; Post["/register"] = parameters => { viewModel = this.Bind <RegisterViewModel>(); var user = viewModel.BuildUser(); var token = new AuthenticationToken { Id = Guid.NewGuid().ToByteArray(), CreatedOn = DateTime.UtcNow }; var validationError = ""; var failedValidation = false; if (viewModel.Password != viewModel.Password2) { ViewBag.ValidationError = "Passwords did not match."; return(View["Register.cshtml", viewModel]); } try { using (var db = dbFactory.Create()) { var id = db.Insert(user); token.UserId = int.Parse(id.ToString()); db.Insert(token); } } catch (Exception e) { failedValidation = true; validationError += e.Message; } if (failedValidation) { ViewBag.ValidationError = validationError; return(View["Register.cshtml", viewModel]); } return(this.LoginAndRedirect(new Guid(token.Id))); }; }
public static void RetryOnTransientError(this IDbFactory factory, Action <IWithSql> action) { ModelTools.RetryOnException <DbException>(() => { using (var db = factory.Create()) { var op = new ResilientWithSql(db, CancellationToken.None); action(op); } }, x => { if (factory.Provider.IsDbBusy(x)) { return(OnExceptionAction.IgnoreAndContinue); } return(OnExceptionAction.Throw); }, SqlFuManager.Config.TransientErrors.Tries, SqlFuManager.Config.TransientErrors.Wait); }
public static void Init(IDbFactory fac, string dbSchema = "") { using (var db = fac.Create()) { db.CreateTableFrom <ServerStateItem>(c => { c.TableName("dbus_server_state", dbSchema); c.IgnoreIfExists(); if (db.Provider().IsSqlserver()) { c.ColumnSize(d => d.Data, "max"); } }); db.Insert(new ServerStateItem() { Data = new DispatcherState().Serialize() }); } }
public async Task <Recipe> GetRecipeById(int recipeId) { try { _logger.Information("Fetching Recipe By Id {RecipeId}", recipeId); var key = CacheKeys.Recipe + "_" + recipeId; if (_memoryCache.TryGetValue(key, out Recipe data)) { return(data); } else { using var factory = await _dbFactory.Create(); using var _dbContext = factory.FactoryFor <ApnaBawarchiKhanaDbContext>(); var result = await _dbContext.Recipes.Include(i => i.RecipeCategories).Include(i => i.Ingredients).Include(d => d.Directions).Include(r => r.RecipeRatings) .Include(i => i.RecipeImages) .ThenInclude(i => i.UploadedImage) .AsNoTracking().Where(w => w.Id == recipeId).FirstOrDefaultAsync(); if (result == null) { throw new InvalidOperationException("No recipe was found with provided Id"); } _memoryCache.Set(key, result, DateTimeOffset.UtcNow.AddHours(2)); return(result); } } catch (Exception e) { _logger.Error(e, "Failed to get recipe by id {RecipeId} ", recipeId); throw; } }
public Task SerializeDataAsync(string destFolder) { return(Task.Run(() => { using (var db = dbFactory.Create()) { foreach (var request in db.Requests) { var fileName = request.Date.ToString("yyyy-MM-dd") + ".xml"; if (!directory.Exists(destFolder)) { directory.CreateDirectory(destFolder); } var fullPath = Path.Combine(destFolder, fileName); if (file.Exists(fullPath)) { file.Delete(fullPath); } using (var stream = file.Create(fullPath)) { var xmlModel = new XmlRequestModel { Index = request.Index, Content = new XmlRequestContentModel { Date = request.Date, Name = request.Name, Visits = request.Visits } }; var serializer = new XmlSerializer(typeof(XmlRequestModel)); serializer.Serialize(stream, xmlModel); } } } })); }
public IUnitOfWork UnitOfWork() { var uow = _factory.Create <IUnitOfWork>(_factory, this); return(uow); }
public BaseService(IDbFactory dbFactory) { _dbFactory = dbFactory; _dbConnection = _dbFactory.Create(); }
protected override DbConnection GetConnection() { _factory = Setup.DbFactory(new SqlServer2012Provider(SqlClientFactory.Instance.CreateConnection), Setup.SqlServerConnectionString); return(_factory.Create()); }