public async Task <IActionResult> GetAllAddressByAgent(CancellationToken cancellationToken, int productId)
{
var returnResponse = new EntityResponseListModel <ProductImageReadDto>();
try
{
var filter = new EntityFilter()
{
Filters = new List <EntityFilter>()
{
new EntityFilter()
{
Name = "ProductId",
Operator = EntityFilterOperators.Equal,
Value = productId
},
}
};
var query = new EntityListQuery <EntityResponseListModel <ProductImageReadDto> >(filter);
var result = await Mediator.Send(query, cancellationToken).ConfigureAwait(false);
if (result.ReturnStatus == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
protected virtual async Task <EntityListResult <TReadModel> > ListQuery(EntityQuery <TEntity> entityQuery, CancellationToken cancellationToken = default(CancellationToken))
{
var command = new EntityListQuery <TEntity, TReadModel>(entityQuery, User);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
return(result);
}
public async Task <IActionResult> Get(CancellationToken cancellationToken)
{
//_emailService.Connect("*****@*****.**", "D6y_k_%=ZTh:!qfs");
//var webRoot = _env.ContentRootPath + @"\Attachment";
//_emailService.DownloadAttachment(webRoot);
EntityResponseListModel <StudentReadModel> returnResponse = new EntityResponseListModel <StudentReadModel>();
try
{
var query = new EntityListQuery <EntityResponseListModel <StudentReadModel> >(null);
var result = await _mediator.Send(query, cancellationToken).ConfigureAwait(false);
if (result.ReturnStatus == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
protected virtual IQueryable <DOMAIN.Entities.ProductImage> BuildQuery(EntityListQuery <EntityResponseListModel <ProductImageReadDto> > request, IQueryable <DOMAIN.Entities.ProductImage> query)
{
if (request?.Filter != null)
{
query = query.Filter(request.Filter);
}
return(query);
}
public void EntityDebugger_SetAllSelections()
{
var entityListQuery = new EntityListQuery(m_ComponentGroup);
EntityDebugger.SetAllSelections(World.Active, m_System, entityListQuery, m_Entity);
Assert.AreEqual(World.Active, m_Window.WorldSelection);
Assert.AreEqual(m_System, m_Window.SystemSelection);
Assert.AreEqual(m_ComponentGroup, m_Window.EntityListQuerySelection.Group);
Assert.AreEqual(m_Entity, m_Window.EntitySelection);
}
public void EntityDebugger_SetAllSelections()
{
var entityListQuery = new EntityListQuery(entityQuery);
EntityDebugger.SetAllSelections(World, m_System.Managed, entityListQuery, m_Entity);
Assert.AreEqual(World, m_Window.WorldSelection);
Assert.AreEqual(m_System, m_Window.SystemSelection);
Assert.AreEqual(entityQuery, m_Window.EntityListQuerySelection.Group);
Assert.AreEqual(m_Entity, m_Window.EntitySelection);
}
public void EntityDebugger_RememberSelections()
{
var entityListQuery = new EntityListQuery(entityQuery);
EntityDebugger.SetAllSelections(World.Active, m_System, entityListQuery, m_Entity);
m_Window.SetWorldSelection(null, true);
m_Window.SetWorldSelection(World.Active, true);
Assert.AreEqual(World.Active, m_Window.WorldSelection);
Assert.AreEqual(m_System, m_Window.SystemSelection);
Assert.AreEqual(entityQuery, m_Window.EntityListQuerySelection.Group);
Assert.AreEqual(m_Entity, m_Window.EntitySelection);
}
protected override async Task <EntityListResult <TReadModel> > ProcessAsync(EntityListQuery <TEntity, TReadModel> message, CancellationToken cancellationToken)
{
var entityQuery = message.Query;
var query = entityQuery.Query != null?entityQuery.Query.Filter(_context.Set <TEntity>().AsNoTracking())
: _context.Set <TEntity>().AsNoTracking();
if (entityQuery.Query != null)
{
if (!string.IsNullOrEmpty(entityQuery.Query.IncludeProperties))
{
foreach (var includeProperty in entityQuery.Query.IncludeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
}
}
var total = await query
.CountAsync(cancellationToken)
.ConfigureAwait(false);
if (total == 0)
{
return new EntityListResult <TReadModel> {
Data = _emptyList.Value
}
}
;
// page the query and convert to read model
var result = await query
.Sort(entityQuery.Sort)
.Page(entityQuery.Page, entityQuery.PageSize)
.ProjectTo <TReadModel>(_configurationProvider)
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
return(new EntityListResult <TReadModel>
{
Total = total,
Data = result.AsReadOnly()
});
}
}
public async Task <IActionResult> GetAllCourseByNotAttend(CancellationToken cancellationToken, Guid traineeId)
{
var search = Query <TrainingBuildCourseAttendee> .Create(x => x.AttendeeId == traineeId);
search = search.And(Query <TrainingBuildCourseAttendee> .Create(x => x.IsActive == true));
var query = new EntityQuery <TrainingBuildCourseAttendee>(search, 1, int.MaxValue, string.Empty);
var readModel = await ListQuery(query, cancellationToken).ConfigureAwait(false);
var course = readModel.Data.Select(x => x.CourseId).ToArray();
var searchCourse = Query <TrainingCourse> .Create(x => !course.Contains(x.Id));
var queryCourse = new EntityQuery <TrainingCourse>(searchCourse, 1, int.MaxValue, string.Empty);
var command = new EntityListQuery <TrainingCourse, CourseReadModel>(queryCourse, User);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
return(new OkObjectResult(new
{
Data = result,
Status = StatusCodes.Status200OK
}));
}
public void EntityDebugger_SetAllEntitiesFilter()
{
var query = new EntityArchetypeQuery()
{
All = new ComponentType[] { ComponentType.Create <EcsTestData>() },
Any = new ComponentType[0],
None = new ComponentType[0]
};
var listQuery = new EntityListQuery(query);
m_Window.SetWorldSelection(World.Active, true);
m_Window.SetSystemSelection(null, null, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreEqual(query, m_Window.EntityListQuerySelection.Query);
m_Window.SetEntityListSelection(null, true, true);
m_Window.SetSystemSelection(World.Active.GetExistingManager <EntityManager>(), World.Active, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreEqual(query, m_Window.EntityListQuerySelection.Query);
m_Window.SetSystemSelection(m_System, World.Active, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreNotEqual(listQuery, m_Window.EntityListQuerySelection);
}
public void EntityDebugger_SetAllEntitiesFilter()
{
var query = new EntityQueryDesc()
{
All = new ComponentType[] { ComponentType.ReadWrite <EcsTestData>() },
Any = new ComponentType[0],
None = new ComponentType[0]
};
var listQuery = new EntityListQuery(query);
m_Window.SetWorldSelection(World.Active, true);
m_Window.SetSystemSelection(null, null, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreEqual(query, m_Window.EntityListQuerySelection.QueryDesc);
m_Window.SetEntityListSelection(null, true, true);
m_Window.SetSystemSelection(null, World.Active, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreEqual(query, m_Window.EntityListQuerySelection.QueryDesc);
m_Window.SetSystemSelection(m_System, World.Active, true, true);
m_Window.SetAllEntitiesFilter(listQuery);
Assert.AreNotEqual(listQuery, m_Window.EntityListQuerySelection);
}
public void SetFilterDummy(EntityListQuery query)
{
}
private static void SetComponentGroupSelection(EntityListQuery query)
{
}
protected virtual async Task <EntityResponseListModel <ProductImageReadDto> > EfQueryList(EntityListQuery <EntityResponseListModel <ProductImageReadDto> > request, IQueryable <DOMAIN.Entities.ProductImage> query, CancellationToken cancellationToken)
{
var result = new EntityResponseListModel <ProductImageReadDto>();
try
{
var data = await query
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
result.Data = Mapper.Map <List <ProductImageReadDto> >(data);
result.ReturnStatus = true;
}
catch (Exception ex)
{
result.Errors.Add("GetAll", ex.Message);
result.ReturnMessage.Add("Record not found");
result.ReturnStatus = false;
}
return(result);
}
protected override async Task <EntityResponseListModel <ProductImageReadDto> > ProcessAsync(EntityListQuery <EntityResponseListModel <ProductImageReadDto> > request, CancellationToken cancellationToken)
{
var entityResponse = new EntityResponseListModel <ProductImageReadDto>();
try
{
var query = DataContext.Set <DOMAIN.Entities.ProductImage>().AsNoTracking();
query = BuildQuery(request, query);
var result = await EfQueryList(request, query, cancellationToken)
.ConfigureAwait(false);
return(result);
}
catch (Exception ex)
{
entityResponse.ReturnMessage.Add("Record not found");
entityResponse.ReturnStatus = false;
}
return(entityResponse);
}
protected override async Task <EntityResponseListModel <TReadModel> > ProcessAsync(EntityListQuery <EntityResponseListModel <TReadModel> > request, CancellationToken cancellationToken)
{
var entityResponse = new EntityResponseListModel <TReadModel>();
try
{
var query = DataContext.Set <Students>().AsNoTracking();
entityResponse.Data = query.Any() ? await query
.ProjectTo <TReadModel>(Mapper.ConfigurationProvider)
.ToListAsync(cancellationToken)
.ConfigureAwait(false) : new List <TReadModel>();
entityResponse.ReturnStatus = true;
return(entityResponse);
}
catch (Exception ex)
{
entityResponse.ReturnMessage.Add("Record not found");
entityResponse.ReturnStatus = false;
}
return(entityResponse);
}
