public async Task <UserApplication[]> GetForUserAsync(int accountId) { if (accountId <= 0) { throw new ArgumentOutOfRangeException(nameof(accountId)); } using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = @"SELECT a.Id ApplicationId, a.Name ApplicationName, ApplicationMembers.Roles, a.NumberOfFtes NumberOfDevelopers FROM Applications a JOIN ApplicationMembers ON (ApplicationMembers.ApplicationId = a.Id) WHERE ApplicationMembers.AccountId = @userId ORDER BY Name"; cmd.AddParameter("userId", accountId); using (var reader = await cmd.ExecuteReaderAsync()) { var apps = new List <UserApplication>(); while (await reader.ReadAsync()) { var numberOfDevelopers = reader.GetValue(3); var a = new UserApplication { IsAdmin = reader.GetString(2).Contains("Admin"), ApplicationName = reader.GetString(1), ApplicationId = reader.GetInt32(0), NumberOfDevelopers = numberOfDevelopers is DBNull ? null : (decimal?)numberOfDevelopers }; apps.Add(a); } return(apps.ToArray()); } } }
public virtual async Task <int> GetAverageReportCountAsync(int applicationId) { using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT [Day] = DATENAME(WEEKDAY, createdatutc), Totals = COUNT(*) FROM errorreports WHERE applicationid=@appId GROUP BY DATENAME(WEEKDAY, createdatutc)"; cmd.AddParameter("appId", applicationId); var numbers = new List <int>(); using (var reader = await cmd.ExecuteReaderAsync()) { while (await reader.ReadAsync()) { numbers.Add((int)reader[0]); } } numbers.Sort(); RemovePeaks(numbers); return((int)numbers.Average()); } }
public async Task UpdateAsync(Incident incident) { using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = @"UPDATE Incidents SET ApplicationId = @ApplicationId, UpdatedAtUtc = @UpdatedAtUtc, Description = @Description, Solution = @Solution, IsSolutionShared = @IsSolutionShared, AssignedToId = @AssignedTo, AssignedAtUtc = @AssignedAtUtc, State = @state, IgnoringReportsSinceUtc = @IgnoringReportsSinceUtc, IgnoringRequestedBy = @IgnoringRequestedBy WHERE Id = @id"; cmd.AddParameter("Id", incident.Id); cmd.AddParameter("ApplicationId", incident.ApplicationId); cmd.AddParameter("UpdatedAtUtc", incident.UpdatedAtUtc); cmd.AddParameter("Description", incident.Description); cmd.AddParameter("State", (int)incident.State); cmd.AddParameter("AssignedTo", incident.AssignedToId); cmd.AddParameter("AssignedAtUtc", incident.AssignedAtUtc); cmd.AddParameter("IgnoringReportsSinceUtc", incident.IgnoringReportsSinceUtc.ToDbNullable()); cmd.AddParameter("IgnoringRequestedBy", incident.IgnoringRequestedBy); cmd.AddParameter("Solution", incident.Solution == null ? null : EntitySerializer.Serialize(incident.Solution)); cmd.AddParameter("IsSolutionShared", incident.IsSolutionShared); await cmd.ExecuteNonQueryAsync(); } }
public virtual async Task <int> GetAverageReportCountAsync(int applicationId) { using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT [Day] = DATENAME(WEEKDAY, ReceivedAtUtc), Totals = cast (COUNT(IncidentReports.Id) as int) FROM IncidentReports JOIN Incidents ON (Incidents.Id = IncidentReports.IncidentId) WHERE applicationid = @appid GROUP BY DATENAME(WEEKDAY, ReceivedAtUtc)"; cmd.AddParameter("appId", applicationId); var numbers = new List <int>(); using (var reader = await cmd.ExecuteReaderAsync()) { while (await reader.ReadAsync()) { numbers.Add((int)reader[1]); } } numbers.Sort(); RemovePeaks(numbers); return((int)numbers.Average()); } }
private async Task GetReportStatistics(GetIncidentResult result) { using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = @"select cast(createdatutc as date) as Date, count(*) as Count from errorreports where incidentid=@incidentId AND CreatedAtUtc > @date group by cast(createdatutc as date)"; var startDate = DateTime.Today.AddDays(-29); cmd.AddParameter("date", startDate); cmd.AddParameter("incidentId", result.Id); var specifiedDays = (await cmd.ToListAsync <ReportDay>()); var curDate = startDate; var values = new ReportDay[30]; var valuesIndexer = 0; var specifiedDaysIndexer = 0; while (curDate <= DateTime.Today) { if (specifiedDays.Count > specifiedDaysIndexer && specifiedDays[specifiedDaysIndexer].Date == curDate) { values[valuesIndexer++] = specifiedDays[specifiedDaysIndexer++]; } else { values[valuesIndexer++] = new ReportDay() { Date = curDate } }; curDate = curDate.AddDays(1); } result.DayStatistics = values; } }
public IEnumerable <Trigger> GetForApplication(int applicationId) { using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = "SELECT * FROM Triggers WHERE ApplicationId = @applicationId"; cmd.AddParameter("applicationId", applicationId); return(cmd.ToList(new TriggerMapper()).ToList()); } }
public async Task CreateAsync(ErrorOrigin entity, int applicationId, int incidentId, int reportId) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (applicationId <= 0) { throw new ArgumentOutOfRangeException(nameof(applicationId)); } if (incidentId <= 0) { throw new ArgumentOutOfRangeException(nameof(incidentId)); } if (reportId <= 0) { throw new ArgumentOutOfRangeException(nameof(reportId)); } using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = "SELECT Id FROM ErrorOrigins WHERE IpAddress = @ip"; cmd.AddParameter("ip", entity.IpAddress); var id = await cmd.ExecuteScalarAsync(); if (id is int) { await CreateReportInfoAsync((int)id, applicationId, incidentId, reportId); return; } } using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = "INSERT INTO ErrorOrigins (IpAddress, CountryCode, CountryName, RegionCode, RegionName, City, ZipCode, Latitude, Longitude, CreatedAtUtc) " + "VALUES (@IpAddress, @CountryCode, @CountryName, @RegionCode, @RegionName, @City, @ZipCode, @Latitude, @Longitude, @CreatedAtUtc);select cast(SCOPE_IDENTITY() as int);"; cmd.AddParameter("IpAddress", entity.IpAddress); cmd.AddParameter("CountryCode", entity.CountryCode); cmd.AddParameter("CountryName", entity.CountryName); cmd.AddParameter("RegionCode", entity.RegionCode); cmd.AddParameter("RegionName", entity.RegionName); cmd.AddParameter("City", entity.City); cmd.AddParameter("ZipCode", entity.ZipCode); //cmd.AddParameter("Point", SqlGeography.Point(command.Latitude, command.Longitude, 4326)); cmd.AddParameter("Latitude", entity.Latitude); cmd.AddParameter("Longitude", entity.Longitude); cmd.AddParameter("CreatedAtUtc", DateTime.UtcNow); var id = (int)await cmd.ExecuteScalarAsync(); await CreateReportInfoAsync(id, applicationId, incidentId, reportId); } }
public async Task CreateAsync(InvalidErrorReport entity) { using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = @"INSERT INTO InvalidErrorReports (Id, AddedAtUtc, ApplicationId, Body, Exception) VALUES(@Id, @AddedAtUtc, @OrganizationId, @ApplicationId, @Body, @Exception)"; cmd.AddParameter("Id", entity.Id); cmd.AddParameter("AddedAtUtc", entity.AddedAtUtc); cmd.AddParameter("ApplicationId", entity.ApplicationId); cmd.AddParameter("Body", entity.Report); cmd.AddParameter("Exception", entity.Exception); await cmd.ExecuteNonQueryAsync(); } }
public bool ExistsByClientId(string clientReportId) { if (clientReportId == null) { throw new ArgumentNullException("clientReportId"); } using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = "select id from ErrorReports WHERE ErrorId = @Id"; cmd.AddParameter("id", clientReportId); return(cmd.ExecuteScalar() != null); } }
/// <inheritdoc /> public void Execute() { // find incidents with too many reports. var incidentsToTruncate = new List <int>(); using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT TOP 10 Id FROM Incidents WHERE ReportCount > @max ORDER BY ReportCount DESC"; cmd.AddParameter("max", MaxReportsPerIncident); using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { incidentsToTruncate.Add((int)reader[0]); } } } foreach (var incidentId in incidentsToTruncate) { using (var cmd = _unitOfWork.CreateCommand()) { var sql = @"DELETE FROM ErrorReports WHERE IncidentId = @id AND Id <= (SELECT Id FROM ErrorReports WHERE IncidentId = @id ORDER BY Id DESC OFFSET {0} ROWS FETCH NEXT 1 ROW ONLY)"; cmd.CommandText = string.Format(sql, MaxReportsPerIncident); cmd.AddParameter("id", incidentId); cmd.CommandTimeout = 90; var rows = cmd.ExecuteNonQuery(); if (rows > 0) { _logger.Debug("Deleted the oldest " + rows + " reports for incident " + incidentId); } } using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = @"UPDATE Incidents SET ReportCount = (SELECT count(Id) FROM ErrorReports WHERE IncidentId = @id) WHERE Id = @id"; cmd.AddParameter("id", incidentId); cmd.ExecuteNonQuery(); } } }
/// <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); } } }
public SimilaritiesReport FindForIncident(int incidentId) { using (var cmd = _uow.CreateCommand()) { cmd.CommandText = @"select Id, Name, Properties from IncidentContextCollections where IncidentId = @incidentId"; cmd.AddParameter("incidentId", incidentId); var collections = new List <SimilarityCollection>(); using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { var json = (string)reader["Properties"]; var properties = CoderrDtoSerializer.Deserialize <ContextCollectionPropertyDbEntity[]>(json); var col = new SimilarityCollection(incidentId, reader.GetString(1)); col.GetType().GetProperty("Id").SetValue(col, reader.GetInt32(0)); foreach (var entity in properties) { var prop = new Similarity(entity.Name); prop.LoadValues( entity.Values.Select(x => new SimilarityValue(x.Value, x.Percentage, x.Count)).ToArray()); col.Properties.Add(prop); } collections.Add(col); } } return(collections.Count == 0 ? null : new SimilaritiesReport(incidentId, collections)); } }
/// <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()); } }
/// <summary> /// Method used to execute the query /// </summary> /// <param name="query">Query to execute.</param> /// <returns> /// Task which will contain the result once completed. /// </returns> public async Task <GetOriginsForIncidentResult> HandleAsync(IMessageContext context, GetOriginsForIncident query) { using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT Longitude, Latitude, count(*) FROM ErrorOrigins eo JOIN ErrorReportOrigins ON (eo.Id = ErrorReportOrigins.ErrorOriginId) WHERE IncidentId = @id AND eo.IsLookedUp = 1 GROUP BY IncidentId, Longitude, Latitude"; cmd.AddParameter("id", query.IncidentId); using (var reader = await cmd.ExecuteReaderAsync()) { var items = new List <GetOriginsForIncidentResultItem>(); while (await reader.ReadAsync()) { var item = new GetOriginsForIncidentResultItem { Longitude = (double)reader.GetDecimal(0), Latitude = (double)reader.GetDecimal(1), NumberOfErrorReports = reader.GetInt32(2) }; items.Add(item); } return(new GetOriginsForIncidentResult { Items = items.ToArray() }); ; } } }
public async Task <GetEnvironmentsResult> HandleAsync(IMessageContext context, GetEnvironments query) { var result = new GetEnvironmentsResult(); string sql; if (query.ApplicationId == null) { sql = @"select Id, Name from Environments ORDER BY Name"; } else { sql = @"WITH EnvironmentIds AS ( select distinct EnvironmentId FROM IncidentEnvironments JOIN Incidents ON (IncidentId = Incidents.Id) WHERE ApplicationId = @applicationId ) SELECT Id, Name FROM Environments JOIN EnvironmentIds ON (EnvironmentId=Environments.Id)"; } using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = sql; cmd.AddParameter("applicationId", query.ApplicationId); var items = await cmd.ToListAsync <GetEnvironmentsResultItem>(); result.Items = items.ToArray(); return(result); } }
/// <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 async Task <GetReportListResult> ExecuteAsync(GetReportList query) { using (var cmd = _unitOfWork.CreateCommand()) { int totalCount = 0; cmd.AddParameter("incidentId", query.IncidentId); if (query.PageNumber > 0) { cmd.CommandText = "SELECT cast(count(Id) as int) FROM ErrorReports WHERE IncidentId = @incidentId"; totalCount = (int)cmd.ExecuteScalar(); cmd.CommandText = "SELECT Id, Title, CreatedAtUtc, RemoteAddress, Exception FROM ErrorReports WHERE IncidentId = @incidentId ORDER BY Id DESC"; cmd.Paging(query.PageNumber, query.PageSize); } else { cmd.CommandText = "SELECT Id, Title, CreatedAtUtc, RemoteAddress, Exception FROM ErrorReports WHERE IncidentId = @incidentId ORDER BY Id DESC"; } var items = await cmd.ToListAsync <GetReportListResultItem>(); return(new GetReportListResult(items.ToArray()) { PageNumber = query.PageNumber, PageSize = query.PageSize, TotalCount = totalCount }); } }
/// <inheritdoc /> public void Execute() { // find incidents with too many reports. var incidentsToTruncate = new List <Tuple <int, int> >(); using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT TOP(5) IncidentId, count(Id) FROM ErrorReports GROUP BY IncidentId HAVING Count(IncidentId) > @max ORDER BY count(Id) DESC"; cmd.AddParameter("max", MaxReportsPerIncident); using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { incidentsToTruncate.Add(new Tuple <int, int>((int)reader[0], (int)reader[1])); } } } foreach (var incidentIdAndCount in incidentsToTruncate) { //do not delete more then 500 at a time. var rowsToDelete = Math.Min(500, incidentIdAndCount.Item2 - MaxReportsPerIncident); using (var cmd = _unitOfWork.CreateCommand()) { var sql = $@"With RowsToDelete AS ( SELECT TOP {rowsToDelete} Id FROM ErrorReports WHERE IncidentId = {incidentIdAndCount.Item1} ORDER BY ID ASC ) DELETE FROM RowsToDelete"; cmd.CommandText = sql; cmd.CommandTimeout = 90; var rows = cmd.ExecuteNonQuery(); if (rows > 0) { _logger.Debug("Deleted the oldest " + rows + " reports for incident " + incidentIdAndCount); } } } }
/// <inheritdoc /> public async Task <Account> FindByActivationKeyAsync(string activationKey) { using (var cmd = _uow.CreateCommand()) { cmd.CommandText = "SELECT * FROM Accounts WHERE ActivationKey=@key"; cmd.AddParameter("key", activationKey); return(await cmd.FirstOrDefaultAsync(new AccountMapper())); } }
private async Task <IList <InboundCollection> > GetInboundCollections() { using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = "SELECT TOP(50) Id, ReportId, Body FROM ErrorReportCollectionInbound"; return(await cmd.ToListAsync <InboundCollection>()); } }
private IReadOnlyList <ErrorReportEntity> GetReportsUsingSql() { using (var cmd = _unitOfWork.CreateCommand()) { cmd.CommandText = @"SELECT QueueReports.* FROM QueueReports ORDER BY QueueReports.Id"; cmd.Limit(10); try { var reports = new List <ErrorReportEntity>(); var idsToRemove = new List <int>(); using (var reader = cmd.ExecuteReader()) { while (reader.Read()) { var json = ""; try { json = (string)reader["body"]; var report = _reportDtoConverter.LoadReportFromJson(json); var newReport = _reportDtoConverter.ConvertReport(report, (int)reader["ApplicationId"]); newReport.RemoteAddress = (string)reader["RemoteAddress"]; reports.Add(newReport); idsToRemove.Add(reader.GetInt32(0)); } catch (Exception ex) { _logger.Error("Failed to deserialize " + json, ex); } } } if (idsToRemove.Any()) { _unitOfWork.ExecuteNonQuery("DELETE FROM QueueReports WHERE Id IN (" + string.Join(",", idsToRemove) + ")"); } return(reports); } catch (Exception ex) { throw cmd.CreateDataException(ex); } } }
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)); } }
public async Task ExecuteAsync(DeleteTrigger command) { using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = "DELETE FROM Triggers WHERE Id = @id"; cmd.AddParameter("id", command.Id); await cmd.ExecuteNonQueryAsync(); } }
public async Task <Application[]> GetForUserAsync(int accountId) { if (accountId <= 0) { throw new ArgumentOutOfRangeException(nameof(accountId)); } using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = @"SELECT * FROM Applications JOIN ApplicationMembers ON (ApplicationMembers.ApplicationId = Applications.Id) WHERE ApplicationMembers.AccountId = @userId"; cmd.AddParameter("userId", accountId); var result = await cmd.ToListAsync <Application>(); return(result.ToArray()); } }
public async Task <TriggerDTO[]> HandleAsync(IMessageContext context, GetTriggersForApplication query) { using (var cmd = (DbCommand)_unitOfWork.CreateCommand()) { cmd.CommandText = "SELECT * FROM Triggers WHERE [ApplicationId]=@appId"; cmd.AddParameter("appId", query.ApplicationId); return((await cmd.ToListAsync <TriggerDTO>()).ToArray()); } }
public IEnumerable <IncidentSummaryDTO> FindLatestForOrganization(int count) { using (var cmd = _uow.CreateCommand()) { cmd.CommandText = "SELECT TOP " + count + " * FROM Incidents WHERE IsSolved=0 ORDER BY UpdatedAtUtc DESC"; return(cmd.ToList <IncidentSummaryDTO>()); } }
/// <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(); } }
public async Task CreateAsync(User user) { using (var cmd = (DbCommand)_uow.CreateCommand()) { cmd.CommandText = "INSERT INTO Users (AccountId, UserName, EmailAddress) VALUES(@id, @userName, @email)"; cmd.AddParameter("id", user.AccountId); cmd.AddParameter("userName", user.UserName); cmd.AddParameter("email", user.EmailAddress); await cmd.ExecuteNonQueryAsync(); } }