/// <summary>
/// Generate a complete list before returning.
/// </summary>
/// <typeparam name="TEntity">Type of entity to map</typeparam>
/// <param name="unitOfWork">Connection to invoke <c>ExecuteReader()</c> on (through a created <c>DbCommand</c>).</param>
/// <param name="mapping">Mapping used to translate from db table rows to .NET object</param>
/// <param name="query">Query</param>
/// <param name="parameters">Anonymous object (<c>new { id = dto.ProjectId, @minDate = dto.MinDate }</c>), a dictionary or a value array</param>
/// <returns>A list.</returns>
/// <remarks>
/// <para>
/// For more information about the "query" and "parameters" arguments, see <see cref="CommandExtensions.ApplyQuerySql{TEntity}"/>.
/// </para>
/// <para>
/// The returned enumerator will not map each row until it's requested. To be able to do that the
/// connection/command/datareader is
/// kept open until the enumerator is disposed. Hence it's important that you make sure that the enumerator is
/// disposed when you are
/// done with it.
/// </para>
/// <para>Uses <see cref="EntityMappingProvider" /> to find the correct <c><![CDATA[IEntityMapper<TEntity>]]></c>.</para>
/// </remarks>
/// <example>
/// <code>
/// // All these examples are valid:
/// <![CDATA[
/// var users = unitOfWork.ToList<User>("SELECT * FROM Users WHERE Age = 37");
/// var users = unitOfWork.ToList<User>("SELECT * FROM Users WHERE FirstName = @name", new { name = user.FirstName });
/// var users = unitOfWork.ToList<User>("SELECT * FROM Users WHERE FirstName = @1 AND Age < @2", 'A%', 35);
/// ]]>
/// </code>
/// </example>
public static IList <TEntity> ToList <TEntity>(this IAdoNetUnitOfWork unitOfWork, IEntityMapper <TEntity> mapping, string query, params object[] parameters)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
var cmd = unitOfWork.CreateDbCommand();
try
{
cmd.ApplyQuerySql <TEntity>(mapping, query, parameters);
var items = new List <TEntity>();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var entity = mapping.Create(reader);
mapping.Map(reader, entity);
items.Add((TEntity)entity);
}
}
return(items);
}
catch (Exception e)
{
throw cmd.CreateDataException(e);
}
}
public ReportController(IMessageQueueProvider queueProvider, IAdoNetUnitOfWork unitOfWork,
ConfigurationStore configStore)
{
_unitOfWork = unitOfWork;
_configStore = configStore;
_messageQueue = queueProvider.Open("Reports");
}
/// <summary>
/// Insert a new item.
/// </summary>
/// <typeparam name="TEntity">Type of entity (must have a mapping registered in the <see cref="EntityMappingProvider"/>)</typeparam>
/// <param name="unitOfWork">Uow to extend</param>
/// <param name="entity">The entity to create.</param>
public static object Insert <TEntity>(this IAdoNetUnitOfWork unitOfWork, TEntity entity)
{
var mapper = EntityMappingProvider.GetMapper <TEntity>();
using (var cmd = unitOfWork.CreateCommand())
{
try
{
mapper.CommandBuilder.InsertCommand(cmd, entity);
var keys = mapper.GetKeys(entity);
if (keys.Length == 1)
{
var id = cmd.ExecuteScalar();
if (id != null && id != DBNull.Value)
{
mapper.Properties[keys[0].Key].SetColumnValue(entity, id);
}
return(id);
}
return(cmd.ExecuteScalar());
}
catch (Exception ex)
{
throw cmd.CreateDataException(ex);
}
}
}
/// <summary>
/// Insert a new row into the database.
/// </summary>
/// <typeparam name="TEntity">
/// Type of entity to use, must have an mapper registered in <see cref="EntityMappingProvider" />
/// .
/// </typeparam>
/// <param name="unitOfWork">Unit of work to execute command in.</param>
/// <param name="entity">entity to insert into the database.</param>
/// <returns>Task to wait on for completion</returns>
/// <remarks>
/// <para>
/// Will assign the PK value to the
/// </para>
/// </remarks>
/// <example>
/// <code>
/// var user = new User(10, "Jonas");
/// using (var uow = UnitOfWorkFactory.Create())
/// {
/// await uow.InsertAsync(user);
/// }
/// </code>
/// </example>
public static async Task <object> InsertAsync <TEntity>(this IAdoNetUnitOfWork unitOfWork, TEntity entity)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (EqualityComparer <TEntity> .Default.Equals(default(TEntity), entity))
{
throw new ArgumentNullException("entity");
}
var mapper = EntityMappingProvider.GetMapper <TEntity>();
using (var cmd = (DbCommand)unitOfWork.CreateCommand())
{
mapper.CommandBuilder.InsertCommand(cmd, entity);
//var keys = mapper.GetKeys(entity);
//if (keys.Length == 1 && true)
//{
// var id = await cmd.ExecuteScalarAsync();
// mapper.Properties[keys[0].Key].SetColumnValue(entity, id);
//}
return(await cmd.ExecuteScalarAsync());
}
}
public SubmitFeedbackHandler(IAdoNetUnitOfWork unitOfWork, IReportsRepository reportsRepository,
IEventBus eventBus)
{
_unitOfWork = unitOfWork;
_reportsRepository = reportsRepository;
_eventBus = eventBus;
}
public CollectStatsJob(IAdoNetUnitOfWork unitOfWork, IConfiguration <UsageStatsSettings> config,
IConfiguration <CoderrConfigSection> reportConfiguration)
{
_unitOfWork = unitOfWork;
_config = config;
_reportConfiguration = reportConfiguration;
}
/// <summary>
/// Insert a new row into the database.
/// </summary>
/// <typeparam name="TEntity">
/// Type of entity to use, must have an mapper registered in <see cref="EntityMappingProvider" />
/// .
/// </typeparam>
/// <param name="unitOfWork">Unit of work to execute command in.</param>
/// <param name="entity">entity to insert into the database.</param>
/// <returns>Task to wait on for completion</returns>
/// <remarks>
/// <para>
/// Will assign the PK value to the
/// </para>
/// </remarks>
/// <example>
/// <code>
/// var user = new User(10, "Jonas");
/// using (var uow = UnitOfWorkFactory.Create())
/// {
/// await uow.InsertAsync(user);
/// }
/// </code>
/// </example>
public static async Task <object> InsertAsync <TEntity>(this IAdoNetUnitOfWork unitOfWork, TEntity entity)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
if (EqualityComparer <TEntity> .Default.Equals(default(TEntity), entity))
{
throw new ArgumentNullException("entity");
}
var mapper = EntityMappingProvider.GetCrudMapper <TEntity>();
using (var cmd = (DbCommand)unitOfWork.CreateCommand())
{
try
{
mapper.CommandBuilder.InsertCommand(cmd, entity);
var value = await cmd.AssignAutoIncrementIfConfigured(entity, mapper);
return(value ?? await cmd.ExecuteScalarAsync());
}
catch (Exception e)
{
throw cmd.CreateDataException(e);
}
}
}
public SubmitFeedbackHandler(IAdoNetUnitOfWork unitOfWork, IReportsRepository reportsRepository,
IApplicationRepository applicationRepository)
{
_unitOfWork = unitOfWork;
_reportsRepository = reportsRepository;
_applicationRepository = applicationRepository;
}
public RemoveOldCollectionDataJob(IAdoNetUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
var db = (UnitOfWorkWithTransaction)unitOfWork;
_importer = new Importer(db.Transaction);
}
protected void CreateUserAndApplication(IAdoNetUnitOfWork uow, out int accountId, out int applicationId)
{
var accountRepos = new AccountRepository(uow);
var account = new Account(TestUser.Username, TestUser.Password)
{
Email = TestUser.Email
};
account.Activate();
accountRepos.Create(account);
var userRepos = new UserRepository(uow);
var user = new User(account.Id, TestUser.Username)
{
EmailAddress = TestUser.Email
};
userRepos.CreateAsync(user).GetAwaiter().GetResult();
var appRepos = new ApplicationRepository(uow);
var app = new Application(account.Id, "MyTestApp")
{
ApplicationType = TypeOfApplication.DesktopApplication
};
appRepos.CreateAsync(app).GetAwaiter().GetResult();
var member = new ApplicationTeamMember(app.Id, account.Id, "Admin");
appRepos.CreateAsync(member).GetAwaiter().GetResult();
accountId = user.AccountId;
applicationId = app.Id;
}
public ProcessInboundContextCollectionsHandler(IAdoNetUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
var db = (AnalysisUnitOfWork)unitOfWork;
_importer = new Importer((SqlTransaction)db.Transaction);
}
/// <summary>
/// Creates a new instance of <see cref="SaveReportHandler" />.
/// </summary>
/// <param name="queue">Queue to store inbound reports in</param>
/// <exception cref="ArgumentNullException">queueProvider;connectionFactory</exception>
public SaveReportHandler(IMessageQueue queue, IAdoNetUnitOfWork unitOfWork, ConfigurationStore configStore)
{
_unitOfWork = unitOfWork;
_queue = queue ?? throw new ArgumentNullException(nameof(queue));
var config = configStore.Load <ReportConfig>();
_maxSizeForJsonErrorReport = config.MaxReportJsonSize;
}
public ReportReceiverController(IMessageQueueProvider queueProvider, IAdoNetUnitOfWork unitOfWork,
ConfigurationStore configStore, IWhitelistService whitelistService)
{
_unitOfWork = unitOfWork;
_configStore = configStore;
_whitelistService = whitelistService;
_messageQueue = queueProvider.Open("ErrorReports");
}
public AccountController(IAccountService accountService, IMessageBus messageBus, IAdoNetUnitOfWork uow, IQueryBus queryBus, ConfigurationStore configStore)
{
_accountService = accountService;
_messageBus = messageBus;
_uow = uow;
_queryBus = queryBus;
_configStore = configStore;
}
public ReportReceiverController(IMessageQueueProvider queueProvider, IAdoNetUnitOfWork unitOfWork,
IConfiguration <ReportConfig> reportConfig, IWhitelistService whitelistService)
{
_unitOfWork = unitOfWork;
_reportConfig = reportConfig.Value;
_whitelistService = whitelistService;
_messageQueue = queueProvider.Open("ErrorReports");
}
public DeleteApiKeyHandler(IAdoNetUnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException(nameof(unitOfWork));
}
_unitOfWork = unitOfWork;
}
public ApplicationRepository(IAdoNetUnitOfWork uow)
{
if (uow == null)
{
throw new ArgumentNullException("uow");
}
_uow = uow;
}
/// <summary>
/// Creates a new instance of <see cref="ApplicationDeletedHandler"/>.
/// </summary>
public ApplicationDeletedHandler(IAdoNetUnitOfWork uow)
{
if (uow == null)
{
throw new ArgumentNullException("uow");
}
_uow = uow;
}
public GetIncidentStatisticsHandler(IAdoNetUnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
_unitOfWork = unitOfWork;
}
/// <summary>
/// Creates a new instance of <see cref="DeleteOldReports" />.
/// </summary>
/// <param name="unitOfWork">Used for SQL queries</param>
public DeleteOldReports(IAdoNetUnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
_unitOfWork = unitOfWork;
}
/// <summary>
/// Creates a new instance of <see cref="DeleteEmptyIncidents" />.
/// </summary>
/// <param name="unitOfWork">Used for SQL queries</param>
public DeleteEmptyIncidents(IAdoNetUnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
_unitOfWork = unitOfWork;
}
public static bool TableExists(this IAdoNetUnitOfWork uow, string tableName)
{
using (var cmd = uow.CreateCommand())
{
cmd.CommandText = @"SELECT name FROM sqlite_master WHERE type='table' AND name=@tableName";
cmd.AddParameter("tableName", tableName);
return(tableName.Equals(cmd.ExecuteScalar() as string, StringComparison.OrdinalIgnoreCase));
}
}
/// <summary>
/// Creates a new instance of <see cref="ApiKeyRepository" />.
/// </summary>
/// <param name="uow">Active unit of work</param>
public ApiKeyRepository(IAdoNetUnitOfWork uow)
{
if (uow == null)
{
throw new ArgumentNullException(nameof(uow));
}
_uow = uow;
}
/// <summary>
/// Creates a new instance of <see cref="DeleteEmptyIncidents" />.
/// </summary>
/// <param name="unitOfWork">Used for SQL queries</param>
public DeleteEmptyIncidents(IAdoNetUnitOfWork unitOfWork, IConfiguration <ReportConfig> reportConfiguration)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
_unitOfWork = unitOfWork;
this._reportConfiguration = reportConfiguration;
}
/// <summary>
/// Creates a new instance of <see cref="GetApiKeyHandler"/>.
/// </summary>
/// <param name="uow">valid uow</param>
public GetApiKeyHandler(IAdoNetUnitOfWork uow)
{
if (uow == null)
{
throw new ArgumentNullException(nameof(uow));
}
_uow = uow;
}
/// <summary>
/// Creates a new instance of <see cref="DeleteReportsBelowReportLimit" />.
/// </summary>
/// <param name="unitOfWork">Used for SQL queries</param>
public DeleteReportsBelowReportLimit(IAdoNetUnitOfWork unitOfWork, ConfigurationStore configStore)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
_unitOfWork = unitOfWork;
_configStore = configStore;
}
/// <summary>
/// Return an enumerable which uses lazy loading of each row (you must close the connection once done).
/// </summary>
/// <typeparam name="TEntity">Type of entity to map</typeparam>
/// <param name="unitOfWork">Connection to invoke <c>ExecuteReader()</c> on (through a created <c>DbCommand</c>).</param>
/// <param name="query">Query or short query (<c><![CDATA["projectId = @id AND dateCreated < @minDate"]]></c>)</param>
/// <param name="parameters">Anonymous object (<c>new { id = dto.ProjectId, @minDate = dto.MinDate }</c>), a dictionary or a value array</param>
/// <returns>Lazy loaded enumerator</returns>
/// <remarks>
/// <para>
/// For more information about the "query" and "parameters" arguments, see <see cref="CommandExtensions.ApplyQuerySql{TEntity}"/>.
/// </para>
/// <para>
/// The returned enumerator will not map each row until it's requested. To be able to do that the
/// connection/command/datareader is
/// kept open until the enumerator is disposed. Hence it's important that you make sure that the enumerator is
/// disposed when you are
/// done with it.
/// </para>
/// <para>Uses <see cref="EntityMappingProvider" /> to find the correct <c><![CDATA[IEntityMapper<TEntity>]]></c>.</para>
/// </remarks>
/// <example>
/// <code>
/// // All these examples are valid:
/// <![CDATA[
/// var users = unitOfWork.ToEnumerable<User>("Age < 10");
/// var users = unitOfWork.ToEnumerable<User>("SELECT * FROM Users WHERE Age = 37");
/// var users = unitOfWork.ToEnumerable<User>("FirstName = @name", new { name = user.FirstName });
/// var users = unitOfWork.ToEnumerable<User>("FirstName = @1 AND Age < @2", 'A%', 35);
/// var users = unitOfWork.ToEnumerable<User>("SELECT * FROM Users WHERE Age = @age LIMIT 1, 10", new { age = submittedAge });
/// var users = unitOfWork.ToEnumerable<User>("SELECT * FROM Users WHERE Age = @1 LIMIT 1, 10", user.FirstName);
/// ]]>
/// </code>
/// </example>
public static IEnumerable <TEntity> ToEnumerable <TEntity>(this IAdoNetUnitOfWork unitOfWork, string query, params object[] parameters)
{
if (unitOfWork == null)
{
throw new ArgumentNullException("unitOfWork");
}
return(ToEnumerable <TEntity>(unitOfWork, false, query, parameters));
}
/// <summary>
/// Insert a new item.
/// </summary>
/// <typeparam name="TEntity">Type of entity (must have a mapping registred in the <see cref="EntityMappingProvider"/>)</typeparam>
/// <param name="unitOfWork">Uow to extend</param>
/// <param name="entity">The entity to create.</param>
public static void Insert <TEntity>(this IAdoNetUnitOfWork unitOfWork, TEntity entity)
{
var mapper = EntityMappingProvider.GetMapper <TEntity>();
using (var cmd = unitOfWork.CreateCommand())
{
mapper.CommandBuilder.InsertCommand(cmd, entity);
cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Truncate table (remove all rows without filling the transaction log)
/// </summary>
/// <typeparam name="TEntity">Type of entity (must have a mapping registred in the <see cref="EntityMappingProvider"/>)</typeparam>
/// <param name="unitOfWork">Uow to extend</param>
public static void Truncate <TEntity>(this IAdoNetUnitOfWork unitOfWork)
{
var mapper = EntityMappingProvider.GetMapper <TEntity>();
using (var cmd = unitOfWork.CreateCommand())
{
mapper.CommandBuilder.TruncateCommand(cmd);
cmd.ExecuteNonQuery();
}
}
/// <summary>
/// DELETE a row from the table.
/// </summary>
/// <typeparam name="TEntity">Type of entity to use, must have an mapper registered in <see cref="EntityMappingProvider"/>.</typeparam>
/// <param name="unitOfWork">Unit of work to execute command in.</param>
/// <param name="entity">Uses the primary key column(s), as defined in the mapping, to remove the entry.</param>
/// <returns>Task to wait on for completion.</returns>
/// <example>
/// <code>
/// <![CDATA[
/// public async Task DeleteUser(int userId)
/// {
/// return await _unitOfWork.DeleteAsync(new User { Id = userId });
/// }
/// ]]>
/// </code>
/// </example>
public static async Task DeleteAsync <TEntity>(this IAdoNetUnitOfWork unitOfWork, TEntity entity)
{
var mapper = EntityMappingProvider.GetMapper <TEntity>();
using (var cmd = (DbCommand)unitOfWork.CreateCommand())
{
mapper.CommandBuilder.DeleteCommand(cmd, entity);
await cmd.ExecuteNonQueryAsync();
}
}
