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());
}
