/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override ReturnType Delete <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query)
{
//sqlTool.Log.Error(query.Sql, LogLevel.Error | LogLevel.AutoCSer);
if (query.NotQuery)
{
ReturnValue <int> returnValue = executeNonQuery(ref connection, query.Sql);
if (returnValue.ReturnType == ReturnType.Success)
{
if (returnValue.Value > 0)
{
sqlTool.CallOnDeleted(value);
return(ReturnType.Success);
}
return(ReturnType.NotFoundData);
}
return(returnValue.ReturnType);
}
else
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = sqlTool.SelectMemberMap, Sql = query.Sql
};
ReturnType returnType = Get(sqlTool, ref connection, value, ref getQuery);
if (returnType == ReturnType.Success)
{
sqlTool.CallOnDeleted(value);
}
return(returnType);
}
}
public async Task HandleShouldReturnFailWhenDatabaseSpecificErrorOccurs()
{
// Arrange
var id = Guid.NewGuid();
var userFinderMock = new Mock <IUserFinder>();
userFinderMock.Setup(x => x.Get(id)).Throws <SomeDatabaseSpecificException>();
var userFinder = userFinderMock.Object;
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <object>())).Returns(new UserModel());
var mapper = mapperMock.Object;
var query = new GetQuery(id);
var handler = new GetQueryHandler(mapper, userFinder);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Message == CustomFailures.GetUserFailure);
}
public virtual IActionResult GetById([FromRoute] TIdentifier id)
{
var query = new GetQuery <TModel>(id);
var result = QueryDispatcher.Dispatch(query);
return(OkOrNotFound(result));
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override ReturnType Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query)
{
sqlTool.Log.Error(query.Sql, LogLevel.Error | LogLevel.AutoCSer);
if ((DataModel.Model <modelType> .Identity != null || DataModel.Model <modelType> .PrimaryKeys.Length != 0) && !query.NotQuery)
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = DataModel.Model <modelType> .MemberMap, Sql = query.Sql
};
ReturnType returnType = Get(sqlTool, ref connection, value, ref getQuery);
if (returnType != ReturnType.Success)
{
return(returnType);
}
}
else
{
ReturnValue <int> returnValue = executeNonQuery(ref connection, query.Sql);
if (returnValue.ReturnType != ReturnType.Success)
{
return(returnValue.ReturnType);
}
if (returnValue.Value <= 0)
{
return(ReturnType.ExecuteFailed);
}
}
sqlTool.CallOnInserted(value);
return(ReturnType.Success);
}
public async Task HandleShouldReturnFailWhenNotFound()
{
// Arrange
var id = Guid.NewGuid();
var userFinderMock = new Mock <IUserFinder>();
userFinderMock.Setup(x => x.Get(id)).Throws <EntityNotFoundDbException>();
var userFinder = userFinderMock.Object;
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <object>())).Returns(new UserModel());
var mapper = mapperMock.Object;
var query = new GetQuery(id);
var handler = new GetQueryHandler(mapper, userFinder);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.IsFailure.Should().BeTrue();
result.Failures.Should().OnlyContain(x => x.Code == HandlerFaultCode.NotFound.Name &&
x.Message == HandlerFailures.NotFound &&
x.Target == "id");
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (query.NotQuery)
{
if (executeNonQuery(ref connection, query.UpdateSql) > 0)
{
sqlTool.CallOnUpdated(value, null, memberMap);
return(true);
}
}
else
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = query.MemberMap, Sql = query.Sql
};
valueType oldValue = AutoCSer.Emit.Constructor <valueType> .New();
if (Get(sqlTool, ref connection, oldValue, ref getQuery) && executeNonQuery(connection, query.UpdateSql) > 0 && Get(sqlTool, ref connection, value, ref getQuery))
{
sqlTool.CallOnUpdated(value, oldValue, memberMap);
return(true);
}
}
return(false);
}
public override Task <Organization> Handle(GetQuery <Organization> request, CancellationToken cancellationToken)
{
return(Task.FromResult(new Organization
{
Name = $"hello {DateTime.Now.Ticks}"
}));
}
public async Task <IActionResult> Get([FromRoute] Guid id)
{
var query = new GetQuery(id);
var result = await mediator.Send(query);
return(Ok(result));
}
public async Task HandleShouldReturnOk()
{
// Arrange
var id = Guid.NewGuid();
var userFinderMock = new Mock <IUserFinder>();
userFinderMock.Setup(x => x.Get(id)).Returns(Task.FromResult(new User(id, new Login("login"), "password", new FullName(new FirstName("FirstName"), new LastName("LastName")))));
var userFinder = userFinderMock.Object;
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(x => x.Map <UserModel>(It.IsAny <object>())).Returns(new UserModel());
var mapper = mapperMock.Object;
var query = new GetQuery(id);
var handler = new GetQueryHandler(mapper, userFinder);
// Act
var result = await handler.Handle(query, CancellationToken.None);
// Assert
result.IsFailure.Should().BeFalse();
result.Should().BeOfType(typeof(Result <UserModel>));
}
public async Task <string> Post([FromBody] CalcModel query)
{
GetQuery process = new GetQuery();
var result = await process.GettingQuery(query.Query);
return(result);
}
public async Task <IActionResult> GetAsync(int id)
{
var query = new GetQuery <CarDto> {
Id = id
};
return(Ok(await Mediator.Send(query)));
}
public GetQuery Map(GetRequest request)
{
var id = new Guid(request.RouteId);
var result = new GetQuery(id);
return(result);
}
public async Task <UserDto> Handle(GetQuery <UserDto> request, CancellationToken cancellationToken)
{
var user = await _context.User.Where(x => x.UserId == request.Id && x.IsActive == true).FirstOrDefaultAsync();
if (user == null)
{
throw new NotFoundException(nameof(User), request.Id);
}
return(_mapper.Map <UserDto>(user));
}
public static IQueryable <T> InvokeGetQuery <T>(this IQueryable <T> query, GetQuery getQuery, Expression <Func <T, bool> > searchPredicate = null)
{
if (!string.IsNullOrWhiteSpace(getQuery.Search) && searchPredicate != null)
{
query = query.Where(searchPredicate);
}
return(query
.Skip(getQuery.PageSize * getQuery.Page)
.Take(getQuery.PageSize));
}
public async Task <CarDto> Handle(GetQuery <CarDto> request, CancellationToken cancellationToken)
{
var car = await _carRepository.GetACarAsync(request.Id);
if (car == null)
{
throw new NotFoundException(nameof(car), request.Id);
}
return(_mapper.Map <CarDto>(car));
}
public Task <IMongoQueryable <StateProvinceDto> > Handle(GetQuery <StateProvinceDto> request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Id))
{
return(Task.FromResult(_mongoDBContext.Database().GetCollection <StateProvinceDto>(typeof(Domain.Directory.StateProvince).Name).AsQueryable()));
}
else
{
return(Task.FromResult(_mongoDBContext.Database().GetCollection <StateProvinceDto>(typeof(Domain.Directory.StateProvince).Name).AsQueryable().Where(x => x.Id == request.Id)));
}
}
public async Task <IActionResult> GetNotifications([FromQuery] GetQuery getQuery)
{
var userId = this.GetUserId();
var notifications = await db.Notifications
.Where(x => x.UserId == userId)
.OrderByDescending(x => x.CreatedAt)
.InvokeGetQuery(getQuery, x => x.Subject.Contains(getQuery.Search) || x.Body.Contains(getQuery.Search))
.ToArrayAsync();
return(Ok(notifications));
}
public Task <IMongoQueryable <LanguageDto> > Handle(GetQuery <LanguageDto> request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Id))
{
return(Task.FromResult(_mongoDBContext.Database().GetCollection <LanguageDto>(typeof(Core.Domain.Localization.Language).Name).AsQueryable()));
}
else
{
return(Task.FromResult(_mongoDBContext.Database().GetCollection <LanguageDto>(typeof(Core.Domain.Localization.Language).Name).AsQueryable().Where(x => x.Id == request.Id)));
}
}
public void ShouldContainNoErrors()
{
// Arrange
var query = new GetQuery(id: Guid.NewGuid());
// Act
var validationResult = _validator.Validate(query);
var exists = validationResult.Errors.Count > 0;
// Assert
exists.Should().BeFalse();
}
public virtual ActionResult <TModel> GetById([FromRoute] TIdentifier id)
{
if (id == null)
{
return(BadRequest());
}
var query = new GetQuery <TModel>(id);
var result = QueryDispatcher.Dispatch(query);
return(OkOrNotFound(result));
}
private void CheckConnection()
{
if (database == null)
{
throw new Exception($"{nameof(database)} is disposed");
}
if (getQuery == null)
{
getQuery = new GetQuery(database);
}
getQuery = new GetQuery(database);
}
public Response <T> Get <T>(IdRequest request, IQueryInclude <T> includeQuery = null) where T : DeletableEntity
{
Logger.LogTrace($"Entering Get {typeof(T).Name} by id: {request.Id}. By user {Username}");
var query = new GetQuery <T, IdRequest>
{
IncludeQuery = includeQuery
};
query.QueryFilters.Add(new IsActiveAndByIdFilter <T>(request.Id, true));
return(Get(request, query));
}
public async Task <IQueryable <ShippingMethodDto> > Handle(GetQuery <ShippingMethodDto> request, CancellationToken cancellationToken)
{
var shippingMethod = _dbContext.Table <ShippingMethodDto>(typeof(Domain.Shipping.ShippingMethod).Name);
if (string.IsNullOrEmpty(request.Id))
{
return(shippingMethod);
}
else
{
return(await Task.FromResult(shippingMethod.Where(x => x.Id == request.Id)));
}
}
public async Task <IQueryable <CategoryDto> > Handle(GetQuery <CategoryDto> request, CancellationToken cancellationToken)
{
var query = _dbContext.Table <CategoryDto>(typeof(Domain.Catalog.Category).Name);
if (string.IsNullOrEmpty(request.Id))
{
return(query);
}
else
{
return(await Task.FromResult(query.Where(x => x.Id == request.Id)));
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override bool Delete <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query)
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = sqlTool.SelectMemberMap, Sql = query.Sql
};
if (Get(sqlTool, ref connection, value, ref getQuery) && executeNonQuery(connection, query.InsertSql) > 0)
{
sqlTool.CallOnDeleted(value);
return(true);
}
return(false);
}
public void ShouldHaveUserNotFoundCustomFailureWhenIdIsGuidEmpty()
{
// Arrange
var query = new GetQuery(id: Guid.Empty);
// Act
var validationResult = _validator.Validate(query);
var exists =
validationResult.Errors.Any(
a => a.PropertyName.Equals("Id") && a.ErrorMessage.Contains(CustomFailures.UserNotFound));
// Assert
exists.Should().BeTrue();
}
/// <summary>
/// Executes a get API call to get a typed JSON document from the index based on its id.
/// https://www.elastic.co/guide/en/elasticsearch/reference/5.4/docs-get.html
/// </summary>
/// <typeparam name="TPoco"></typeparam>
/// <param name="getQuery"></param>
/// <returns></returns>
public TPoco ExecuteGet <TPoco>(GetQuery <TPoco> getQuery)
where TPoco : IElasticPoco
{
IndexExists(getQuery.IndexName);
var response = LowLevelClient.Get <string>(getQuery.IndexName, getQuery.TypeName, getQuery.Id.ToString());
if (!response.Success)
{
throw response.OriginalException ?? new Exception($"Unsuccessful Elastic Request: {response.DebugInformation}");
}
var data = JObject.Parse(response.Body)?.First;
return(MapResponseToPoco <TPoco>(data));
}
public async Task <IActionResult> GetCompanies([FromQuery] GetQuery getQuery)
{
var userId = this.GetUserId();
var companies = await db.CompanyUsers
.Include(x => x.Company)
.ThenInclude(x => x.Subscription)
.Where(x => x.UserId == userId && x.Company.Status == CompanyStatus.Active)
.Select(x => x.Company)
.OrderBy(x => x.Name)
.InvokeGetQuery(getQuery, x => x.Name.Contains(getQuery.Search) || x.UniqueName.Contains(getQuery.Search))
.ToArrayAsync();
return(Ok(companies));
}
public Response <T> Get <T>(IdRequest request, GetQuery <T, IdRequest> query)
where T : class, IEntity
{
var response = new Response <T>();
if (request.IsRequestInvalid(response, ContextInfo))
{
return(response);
}
query.ContextRequest = WrapRequest(request);
var result = Repository.ExecuteQuery(query);
response.Merge(result);
return(response);
}
public Task <IMongoQueryable <ManufacturerDto> > Handle(GetQuery <ManufacturerDto> request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.Id))
{
return(Task.FromResult(
_mongoDBContext.Database()
.GetCollection <ManufacturerDto>
(typeof(Domain.Catalog.Manufacturer).Name)
.AsQueryable()));
}
else
{
return(Task.FromResult(_mongoDBContext.Database()
.GetCollection <ManufacturerDto>(typeof(Domain.Catalog.Manufacturer).Name)
.AsQueryable()
.Where(x => x.Id == request.Id)));
}
}
