public void DeleteUserQueryGeneratesCorrectQuery()
        {
            var          generatedQuery = _queryFactory.GetDeleteQuery <DeleteUserQuery>();
            const string expected       = "DELETE FROM \"dbo\".\"IdentityUser\" WHERE \"Id\" = @Id";

            Assert.Equal(expected, generatedQuery);
        }
        public void DeleteUserQueryGeneratesCorrectQuery()
        {
            var          generatedQuery = _queryFactory.GetDeleteQuery <DeleteUserQuery>();
            const string expected       = "DELETE FROM `identity`.`identityuser` WHERE `Id` = @Id";

            Assert.Equal(expected, generatedQuery);
        }
        public void DeleteUserQueryGeneratesCorrectQuery()
        {
            var          generatedQuery = _queryFactory.GetDeleteQuery <DeleteUserQuery>();
            const string expected       = "DELETE FROM [dbo].[IdentityUser] WHERE [Id] = @Id";

            Assert.Equal(expected, generatedQuery);
        }
示例#4
0
        public async Task <bool> RemoveAsync(string id, CancellationToken cancellationToken)
        {
            try
            {
                var removeFunction = new Func <DbConnection, Task <bool> >(async x =>
                {
                    try
                    {
                        var dynamicParameters = new DynamicParameters();
                        dynamicParameters.Add("Id", id);

                        var query = _queryFactory.GetDeleteQuery <DeleteUserQuery>();

                        var result = await x.ExecuteAsync(query, dynamicParameters, _unitOfWork.Transaction);

                        return(result > 0);
                    }
                    catch (Exception ex)
                    {
                        Logging.LogException(ex);

                        throw;
                    }
                });

                DbConnection conn = null;
                if (_unitOfWork?.Connection == null)
                {
                    using (conn = _connectionProvider.Create())
                    {
                        await conn.OpenAsync(cancellationToken);

                        return(await removeFunction(conn));
                    }
                }
                else
                {
                    conn = _unitOfWork.CreateOrGetConnection();

                    return(await removeFunction(conn));
                }
            }
            catch (Exception ex)
            {
                Logging.LogException(ex);

                throw;
            }
        }
        public void DeleteRoleQueryGeneratesCorrectQuery()
        {
            var generatedQuery = _queryFactory.GetDeleteQuery <DeleteRoleQuery>();
            var expected       = "DELETE FROM `identity`.`identityrole` WHERE `Id` = @Id";

            Assert.Equal(expected, generatedQuery);
        }
示例#6
0
        public void DeleteRoleQueryGeneratesCorrectQuery()
        {
            var generatedQuery = _queryFactory.GetDeleteQuery <DeleteRoleQuery>();
            var expected       = "DELETE FROM [dbo].[IdentityRole] WHERE [Id] = @Id";

            Assert.Equal(expected, generatedQuery);
        }
示例#7
0
        public virtual async Task <bool> DeleteAsync(T entity, CancellationToken cancellationToken)
        {
            if (entity != null)
            {
                try
                {
                    var removeFunction = new Func <DbConnection, Task <bool> >(async x =>
                    {
                        var dynamicParameters = new DynamicParameters();
                        dynamicParameters.Add("Id", ((IEntity)entity).IdValue);

                        var query = _queryFactory.GetDeleteQuery <DeleteQuery, T>(entity);

                        var result = await x.ExecuteAsync(query, dynamicParameters, _unitOfWork.Transaction);

                        return(result > 0);
                    });

                    DbConnection conn = null;
                    if (_unitOfWork?.Connection == null)
                    {
                        using (conn = _connectionProvider.Create())
                        {
                            await conn.OpenAsync(cancellationToken);

                            return(await removeFunction(conn));
                        }
                    }
                    else
                    {
                        conn = _unitOfWork.CreateOrGetConnection();
                        return(await removeFunction(conn));
                    }
                }
                catch (Exception ex)
                {
                    Logging.LogException(ex);

                    throw;
                }
            }

            return(false);
        }