/// <summary>
/// Initializes a new instance of the <see cref="DbExporter" /> class.
/// </summary>
/// <param name="dbReader">A database reader - an object which implements <see cref="IDbReader" /> interface
/// and provide some basic operation for reading the DB content.</param>
/// <param name="dataSetExporter">A dataset exporter - allows to save the content of some dataset in a file of a particular format.</param>
/// <param name="packer">A packer - packs the files created by dataset exporter to some storage (e.g. to a folder or a ZIP archive).</param>
/// <param name="loggerFactory">The logger factory.</param>
public DbExporter(IDbReader dbReader, IDatasetExporter dataSetExporter, IDataPacker packer, ILoggerFactory loggerFactory)
{
_dbReader = dbReader;
_datasetExporter = dataSetExporter;
_dataPacker = packer;
_logger = loggerFactory?.CreateLogger("Korzh.DbUtils");
}
public virtual TModel BuildFrom(IDbReader reader)
{
if (!reader.Read())
{
return(null);
}
var model = new TModel();
Properties.ForEach(property =>
{
if (!reader.IsDbNull(property.Name))
{
property.SetValue(model, reader[property.Name], null);
}
});
ManyToOneProperties.ForEach(property =>
{
var propertyName = property.Name + "Id";
if (!reader.IsDbNull(propertyName))
{
var manyToOneObject = Activator.CreateInstance(property.PropertyType);
var idProperty = property.PropertyType.GetRuntimeProperty("Id");
idProperty.SetValue(manyToOneObject, reader[propertyName], null);
property.SetValue(model, manyToOneObject, null);
}
});
return(model);
}
public NoteManager(UserManager <DailerUser> userManager, IHttpContextHendler httpContextHendler, IDbReader <Note> dbReader, IDbWriter <Note> dbWriter)
{
_userManager = userManager;
_httpContextHendler = httpContextHendler;
_dbReader = dbReader;
_dbWriter = dbWriter;
}
public MembershipController(IDbReader reader, UserManager <User> userManager, SignInManager <User> signInManager)
{
_reader = reader;
_userManager = userManager;
_signInManager = signInManager;
userId = _userManager.GetUserId(_signInManager.Context.User);
}
public void SetUp()
{
bus = MockRepository.GenerateStub <IBus> ();
dbReader = MockRepository.GenerateStub <IDbReader> ();
harvesterService = new HarvesterService(bus, dbReader, new Logger());
}
public MarkManager(IDbWriter <Mark> dbWriter, IDbReader <Mark> dbReader, UserManager <DailerUser> userManager, IHttpContextAccessor httpContextAccessor)
{
_dbReader = dbReader;
_dbWriter = dbWriter;
_userMananager = userManager;
_httpContextAccessor = httpContextAccessor;
}
public ConnectionEstablished(IDataWriter dataWriter, IDbReader dbReader)
{
Preconditions.CheckNotNull(dataWriter, "dataWriter");
Preconditions.CheckNotNull(dbReader, "dbReader");
this.dataWriter = dataWriter;
this.dbReader = dbReader;
}
public QueueCreated(IDataWriter dataWriter, IDbReader dbReader)
{
Preconditions.CheckNotNull(dataWriter, "dataWriter");
Preconditions.CheckNotNull(dbReader, "dbReader");
this.dataWriter = dataWriter;
this.dbReader = dbReader;
}
public LookupService(String databaseFile, LookupOptions options)
{
_dbReader = options == LookupOptions.GEOIP_MEMORY_CACHE
? new StreamDbReader(databaseFile)
: new CachedDbReader(databaseFile);
Init();
}
/// <summary>
/// 初始化数据
/// </summary>
/// <param name="reader"></param>
public virtual void Initialize(IDbReader reader)
{
foreach (var ni in reader.NameIndex)
{
//this.Set(ni.Key, reader.Get(ni.Key));
this.propertys.Add(ni.Key, reader.Get(ni.Key));
}
}
public QueueModule(IDbReader dbReader) : base("/queue")
{
Preconditions.CheckNotNull(dbReader, "dbReader");
Get ["/{id}"] = parameters => GetQueueDetails(dbReader, parameters.id);
Get ["/{id}/levels"] = parameters => GetQueueLevels(dbReader, parameters.id);
}
public NewConsumer(IDataWriter dataWriter, IDbReader dbReader)
{
Preconditions.CheckNotNull(dataWriter, "dataWriter");
Preconditions.CheckNotNull(dbReader, "dbReader");
this.dataWriter = dataWriter;
this.dbReader = dbReader;
}
public void Init()
{
_readerStub = Substitute.For <IDbReader>();
_serviceCommand = Substitute.For <IDoesResultExistCommand>();
_serviceManager = Substitute.For <IDbManager>();
_serviceManager.ExecuteReader(Arg.Any <IDbCommand>()).Returns(_readerStub);
}
public void Init()
{
_fakeReader = Substitute.For <IDbReader>();
_serviceManager = Substitute.For <IDbManager>();
_serviceCommand = Substitute.For <IManyResultsCommand <string> >();
_serviceManager.ExecuteReader(Arg.Any <IDbCommand>()).Returns(_fakeReader);
}
public LookupService(Stream stream, LookupOptions options)
{
_dbReader = options == LookupOptions.GEOIP_MEMORY_CACHE
? new StreamDbReader(stream)
: new CachedDbReader(stream);
Init();
}
public UserService(IPasswordService passwordService, IDbReader dbReader)
{
Preconditions.CheckNotNull(passwordService, "passwordService");
Preconditions.CheckNotNull(dbReader, "dbReader");
this.passwordService = passwordService;
this.dbReader = dbReader;
}
public void Close()
{
lock (_ioLock)
{
_dbReader.Close();
}
_dbReader = null;
}
public void Init()
{
_readerStub = Substitute.For <IDbReader>();
_serviceManager = Substitute.For <IDbManager>();
_serviceCommand = Substitute.For <ISingleResultOrDefaultCommand <string> >();
_serviceManager.ExecuteReader(Arg.Any <IDbCommand>()).Returns(_readerStub);
}
public DatabaseProvider(IThronesDBProvider thronesDbProvider,
IDbReader localDbReader,
IDbWriter localDbWriter)
{
this.thronesDbProvider = thronesDbProvider;
this.localDbReader = localDbReader;
this.localDbWriter = localDbWriter;
}
//protected override async Task<TResult> ExecuteAsync(IDbManager dbManager, IDbCommand command, CancellationToken cancellationToken)
//{
// using (var reader = await dbManager.ExecuteReaderAsync(command, cancellationToken))
// return GetFirstResult(reader);
//}
private TResult GetFirstResult(IDbReader reader)
{
if (!reader.Read())
{
throw new InvalidOperationException("No results found");
}
return(Command.MapResult(reader));
}
public Person MapResult(IDbReader reader)
{
return(new Person()
{
Id = reader.GetInt("columnName1"),
FirstName = reader.GetString("columnName1"),
LastName = reader.GetString("columnName1"),
DateOfBirth = reader.GetDateTimeNullableOrDefault("columnName1")
});
}
public HarvesterService(IBus bus, IDbReader dbReader, ILogger logger)
{
Preconditions.CheckNotNull(bus, "bus");
Preconditions.CheckNotNull(dbReader, "dbReader");
Preconditions.CheckNotNull(logger, "logger");
this.bus = bus;
this.dbReader = dbReader;
this.logger = logger;
this.timer = new Timer(OnTimer);
}
//protected override async Task<IEnumerable<TResult>> ExecuteAsync(IDbManager dbManager, IDbCommand command, CancellationToken cancellationToken)
//{
// using (var reader = await dbManager.ExecuteReaderAsync(command, cancellationToken))
// return GetManyResults(reader);
//}
private IEnumerable <TResult> GetManyResults(IDbReader reader)
{
var results = new List <TResult>();
while (reader.Read())
{
results.Add(Command.MapResult(reader));
}
return(results);
}
public AlerterService(IBus bus, ILogger logger, IDbReader dbReader, TinyIoC.TinyIoCContainer container)
{
Preconditions.CheckNotNull(bus, "bus");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(dbReader, "dbReader");
this.bus = bus;
this.logger = logger;
this.dbReader = dbReader;
LoadAlertSinks(container);
}
public ResultRepository(
IDbReader dbConnection,
IHttpStatusResultStatisticsFactory statisticsFactory,
IHttpStatusResultService service,
IRequestResultRepository requestResultRepository,
ITestResultRepository testResultRepository)
{
_dbConnection = dbConnection.Connection;
_statisticsFactory = statisticsFactory;
_service = service;
_requestResultRepository = requestResultRepository;
_testResultRepository = testResultRepository;
}
public virtual IEnumerable <TModel> BuildListFrom(IDbReader reader)
{
var list = new List <TModel>();
var model = BuildFrom(reader);
while (model != null)
{
list.Add(model);
model = BuildFrom(reader);
}
return(list);
}
public WebhookModule(IBus bus, IDbReader dbReader) : base("/webhook")
{
if (dbReader == null)
{
throw new ArgumentNullException("dbReader");
}
Get ["/"] = parameters => GetWebhooks(dbReader, this.UserId());
Post ["/"] = _ => CreateNewWebhook(bus, this.Bind <NewWebhookPost>());
Delete ["/{id}"] = parameters => DeleteWebhook(bus, parameters.id);
}
public virtual IEnumerable <TModel> BuildQueueFrom(IDbReader reader)
{
var queue = new Queue <TModel>();
var model = BuildFrom(reader);
while (model != null)
{
queue.Enqueue(model);
model = BuildFrom(reader);
}
return(queue);
}
public dynamic GetQueueDetails(IDbReader dbReader, int queueId)
{
try {
var queue = dbReader.GetById <Queue> (queueId);
var vhost = dbReader.GetById <VHost> (queue.VHostId);
var broker = dbReader.GetById <Broker> (vhost.BrokerId);
if (broker.UserId != this.UserId())
{
return(HttpStatusCode.NotFound);
}
return(queue);
} catch (RowNotFoundInTableException) {
return(HttpStatusCode.NotFound);
}
}
//protected override async Task<TResult> ExecuteAsync(IDbManager dbManager, IDbCommand command, CancellationToken cancellationToken)
//{
// using (var reader = await dbManager.ExecuteReaderAsync(command, cancellationToken))
// return GetSingleResultOrDefault(reader);
//}
private TResult GetSingleResultOrDefault(IDbReader reader)
{
if (!reader.Read())
{
return(default(TResult));
}
var result = Command.MapResult(reader);
if (reader.Read())
{
throw new InvalidOperationException("Too many results");
}
return(result);
}
public override IRow this[IPrimaryKey key] {
get {
StringBuilder where = new StringBuilder();
foreach (ICell cell in (IEnumerable <ICell>)key)
{
where.Append(cell.Column.Name).Append(" = ")
.Append(helper.DbValueToString(cell.Value))
.Append(", ");
}
if (where.Length > 0)
{
where.Remove(where.Length - 2, 2);
}
IDbReader result = SelectAll(where.ToString());
return(result.MoveNext() ? result.Current : null);
}
}
public dynamic ExecuteSingleRow(string sql, DataParameter[] ps, CommandType type)
{
if (sql == null)
{
throw new ArgumentNullException("sql");
}
try
{
using (DbCommand cmd = CreateCommand())
{
cmd.CommandText = sql;
cmd.CommandType = type;
SetParameters(cmd, ps);
IDbReader row = null;
DbDataReader reader = ExecuteReader(cmd, CommandBehavior.SingleRow);
if (reader != null)
{
try
{
if (reader.HasRows)
{
row = new DbRow();
if (reader.Read())
{
row.ReadRow(reader);
}
}
}
finally
{
reader.Dispose();
}
}
return(row);
}
}
catch (Exception ex)
{
throw new DataException(string.Concat(ex.Message, sql));
}
}
public static IDbReader Configure(string ProviderType)
{
var builder = new ContainerBuilder();
switch (ProviderType)
{
case "AdoNet":
{
builder.RegisterType <AdoNetDbReader>().As <IDbReader>().SingleInstance();
break;
}
case "Dapper":
{
builder.RegisterType <DapperDbReader>().As <IDbReader>().SingleInstance();
break;
}
case "EF":
{
builder.RegisterType <EFDbReader>().As <IDbReader>().SingleInstance();
break;
}
default:
{
builder.RegisterType <IDbReader>().As <IDbReader>().SingleInstance();
break;
}
}
var container = builder.Build();
IDbReader reader = container.Resolve <IDbReader>();
return(reader);
}
public Lcd(ILcdView lcdView, IDbReader dbReader)
{
_lcdView = lcdView;
_dbReader = dbReader;
}
public void SetUp()
{
_view = Substitute.For<ILcdView>();
_dbReader = Substitute.For<IDbReader>();
_lcd = new Lcd(_view, _dbReader);
}
