public async Task <int> Count(PlaceGroupFilter filter) { IQueryable <PlaceGroupDAO> PlaceGroups = DataContext.PlaceGroup.AsNoTracking(); PlaceGroups = DynamicFilter(PlaceGroups, filter); return(await PlaceGroups.CountAsync()); }
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids) { if (!ModelState.IsValid) { throw new BindException(ModelState); } PlaceGroupFilter PlaceGroupFilter = new PlaceGroupFilter(); PlaceGroupFilter = await PlaceGroupService.ToFilter(PlaceGroupFilter); PlaceGroupFilter.Id = new IdFilter { In = Ids }; PlaceGroupFilter.Selects = PlaceGroupSelect.Id; PlaceGroupFilter.Skip = 0; PlaceGroupFilter.Take = int.MaxValue; List <PlaceGroup> PlaceGroups = await PlaceGroupService.List(PlaceGroupFilter); PlaceGroups = await PlaceGroupService.BulkDelete(PlaceGroups); if (PlaceGroups.Any(x => !x.IsValidated)) { return(BadRequest(PlaceGroups.Where(x => !x.IsValidated))); } return(true); }
public async Task <List <Place_PlaceGroupDTO> > SingleListPlaceGroup([FromBody] Place_PlaceGroupFilterDTO Place_PlaceGroupFilterDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } PlaceGroupFilter PlaceGroupFilter = new PlaceGroupFilter(); PlaceGroupFilter.Skip = 0; PlaceGroupFilter.Take = int.MaxValue; PlaceGroupFilter.OrderBy = PlaceGroupOrder.Id; PlaceGroupFilter.OrderType = OrderType.ASC; PlaceGroupFilter.Selects = PlaceGroupSelect.ALL; PlaceGroupFilter.Id = Place_PlaceGroupFilterDTO.Id; PlaceGroupFilter.ParentId = Place_PlaceGroupFilterDTO.ParentId; PlaceGroupFilter.Name = Place_PlaceGroupFilterDTO.Name; PlaceGroupFilter.Code = Place_PlaceGroupFilterDTO.Code; List <PlaceGroup> PlaceGroups = await PlaceGroupService.List(PlaceGroupFilter); List <Place_PlaceGroupDTO> Place_PlaceGroupDTOs = PlaceGroups .Select(x => new Place_PlaceGroupDTO(x)).ToList(); return(Place_PlaceGroupDTOs); }
public async Task <List <PlaceGroup> > List(PlaceGroupFilter filter) { if (filter == null) { return(new List <PlaceGroup>()); } IQueryable <PlaceGroupDAO> PlaceGroupDAOs = DataContext.PlaceGroup.AsNoTracking(); PlaceGroupDAOs = DynamicFilter(PlaceGroupDAOs, filter); PlaceGroupDAOs = DynamicOrder(PlaceGroupDAOs, filter); List <PlaceGroup> PlaceGroups = await DynamicSelect(PlaceGroupDAOs, filter); return(PlaceGroups); }
public async Task <List <PlaceGroup> > List(PlaceGroupFilter PlaceGroupFilter) { try { List <PlaceGroup> PlaceGroups = await UOW.PlaceGroupRepository.List(PlaceGroupFilter); return(PlaceGroups); } catch (Exception ex) { await Logging.CreateSystemLog(ex, nameof(PlaceGroupService)); } return(null); }
public async Task <int> Count(PlaceGroupFilter PlaceGroupFilter) { try { int result = await UOW.PlaceGroupRepository.Count(PlaceGroupFilter); return(result); } catch (Exception ex) { await Logging.CreateSystemLog(ex, nameof(PlaceGroupService)); } return(0); }
public async Task <ActionResult <int> > Count([FromBody] PlaceGroup_PlaceGroupFilterDTO PlaceGroup_PlaceGroupFilterDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } PlaceGroupFilter PlaceGroupFilter = ConvertFilterDTOToFilterEntity(PlaceGroup_PlaceGroupFilterDTO); PlaceGroupFilter = await PlaceGroupService.ToFilter(PlaceGroupFilter); int count = await PlaceGroupService.Count(PlaceGroupFilter); return(count); }
public async Task <PlaceGroupFilter> ToFilter(PlaceGroupFilter filter) { if (filter.OrFilter == null) { filter.OrFilter = new List <PlaceGroupFilter>(); } if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0) { return(filter); } foreach (var currentFilter in CurrentContext.Filters) { PlaceGroupFilter subFilter = new PlaceGroupFilter(); filter.OrFilter.Add(subFilter); List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value; foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions) { if (FilterPermissionDefinition.Name == nameof(subFilter.Id)) { subFilter.Id = FilterBuilder.Merge(subFilter.Id, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.ParentId)) { subFilter.ParentId = FilterBuilder.Merge(subFilter.ParentId, FilterPermissionDefinition.IdFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Name)) { subFilter.Name = FilterBuilder.Merge(subFilter.Name, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(subFilter.Code)) { subFilter.Code = FilterBuilder.Merge(subFilter.Code, FilterPermissionDefinition.StringFilter); } if (FilterPermissionDefinition.Name == nameof(CurrentContext.UserId) && FilterPermissionDefinition.IdFilter != null) { if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.IS.Id) { } if (FilterPermissionDefinition.IdFilter.Equal.HasValue && FilterPermissionDefinition.IdFilter.Equal.Value == CurrentUserEnum.ISNT.Id) { } } } } return(filter); }
public async Task <ActionResult <List <PlaceGroup_PlaceGroupDTO> > > List([FromBody] PlaceGroup_PlaceGroupFilterDTO PlaceGroup_PlaceGroupFilterDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } PlaceGroupFilter PlaceGroupFilter = ConvertFilterDTOToFilterEntity(PlaceGroup_PlaceGroupFilterDTO); PlaceGroupFilter = await PlaceGroupService.ToFilter(PlaceGroupFilter); List <PlaceGroup> PlaceGroups = await PlaceGroupService.List(PlaceGroupFilter); List <PlaceGroup_PlaceGroupDTO> PlaceGroup_PlaceGroupDTOs = PlaceGroups .Select(c => new PlaceGroup_PlaceGroupDTO(c)).ToList(); return(PlaceGroup_PlaceGroupDTOs); }
private PlaceGroupFilter ConvertFilterDTOToFilterEntity(PlaceGroup_PlaceGroupFilterDTO PlaceGroup_PlaceGroupFilterDTO) { PlaceGroupFilter PlaceGroupFilter = new PlaceGroupFilter(); PlaceGroupFilter.Selects = PlaceGroupSelect.ALL; PlaceGroupFilter.Skip = 0; PlaceGroupFilter.Take = 99999; PlaceGroupFilter.OrderBy = PlaceGroup_PlaceGroupFilterDTO.OrderBy; PlaceGroupFilter.OrderType = PlaceGroup_PlaceGroupFilterDTO.OrderType; PlaceGroupFilter.Id = PlaceGroup_PlaceGroupFilterDTO.Id; PlaceGroupFilter.ParentId = PlaceGroup_PlaceGroupFilterDTO.ParentId; PlaceGroupFilter.Name = PlaceGroup_PlaceGroupFilterDTO.Name; PlaceGroupFilter.Code = PlaceGroup_PlaceGroupFilterDTO.Code; PlaceGroupFilter.CreatedAt = PlaceGroup_PlaceGroupFilterDTO.CreatedAt; PlaceGroupFilter.UpdatedAt = PlaceGroup_PlaceGroupFilterDTO.UpdatedAt; return(PlaceGroupFilter); }
public async Task <bool> ValidateId(PlaceGroup PlaceGroup) { PlaceGroupFilter PlaceGroupFilter = new PlaceGroupFilter { Skip = 0, Take = 10, Id = new IdFilter { Equal = PlaceGroup.Id }, Selects = PlaceGroupSelect.Id }; int count = await UOW.PlaceGroupRepository.Count(PlaceGroupFilter); if (count == 0) { PlaceGroup.AddError(nameof(PlaceGroupValidator), nameof(PlaceGroup.Id), ErrorCode.IdNotExisted); } return(count == 1); }
private async Task <bool> HasPermission(long Id) { PlaceGroupFilter PlaceGroupFilter = new PlaceGroupFilter(); PlaceGroupFilter = await PlaceGroupService.ToFilter(PlaceGroupFilter); if (Id == 0) { } else { PlaceGroupFilter.Id = new IdFilter { Equal = Id }; int count = await PlaceGroupService.Count(PlaceGroupFilter); if (count == 0) { return(false); } } return(true); }
private IQueryable <PlaceGroupDAO> DynamicOrder(IQueryable <PlaceGroupDAO> query, PlaceGroupFilter filter) { switch (filter.OrderType) { case OrderType.ASC: switch (filter.OrderBy) { case PlaceGroupOrder.Id: query = query.OrderBy(q => q.Id); break; case PlaceGroupOrder.Parent: query = query.OrderBy(q => q.ParentId); break; case PlaceGroupOrder.Name: query = query.OrderBy(q => q.Name); break; case PlaceGroupOrder.Code: query = query.OrderBy(q => q.Code); break; } break; case OrderType.DESC: switch (filter.OrderBy) { case PlaceGroupOrder.Id: query = query.OrderByDescending(q => q.Id); break; case PlaceGroupOrder.Parent: query = query.OrderByDescending(q => q.ParentId); break; case PlaceGroupOrder.Name: query = query.OrderByDescending(q => q.Name); break; case PlaceGroupOrder.Code: query = query.OrderByDescending(q => q.Code); break; } break; } query = query.Skip(filter.Skip).Take(filter.Take); return(query); }
private async Task <List <PlaceGroup> > DynamicSelect(IQueryable <PlaceGroupDAO> query, PlaceGroupFilter filter) { List <PlaceGroup> PlaceGroups = await query.Select(q => new PlaceGroup() { Id = filter.Selects.Contains(PlaceGroupSelect.Id) ? q.Id : default(long), ParentId = filter.Selects.Contains(PlaceGroupSelect.Parent) ? q.ParentId : default(long?), Name = filter.Selects.Contains(PlaceGroupSelect.Name) ? q.Name : default(string), Code = filter.Selects.Contains(PlaceGroupSelect.Code) ? q.Code : default(string), Parent = filter.Selects.Contains(PlaceGroupSelect.Parent) && q.Parent != null ? new PlaceGroup { Id = q.Parent.Id, ParentId = q.Parent.ParentId, Name = q.Parent.Name, Code = q.Parent.Code, } : null, }).ToListAsync(); return(PlaceGroups); }
private IQueryable <PlaceGroupDAO> DynamicFilter(IQueryable <PlaceGroupDAO> query, PlaceGroupFilter filter) { if (filter == null) { return(query.Where(q => false)); } query = query.Where(q => !q.DeletedAt.HasValue); if (filter.CreatedAt != null && filter.CreatedAt.HasValue) { query = query.Where(q => q.CreatedAt, filter.CreatedAt); } if (filter.UpdatedAt != null && filter.UpdatedAt.HasValue) { query = query.Where(q => q.UpdatedAt, filter.UpdatedAt); } if (filter.Id != null && filter.Id.HasValue) { query = query.Where(q => q.Id, filter.Id); } if (filter.ParentId != null && filter.ParentId.HasValue) { query = query.Where(q => q.ParentId.HasValue).Where(q => q.ParentId.Value, filter.ParentId); } if (filter.Name != null && filter.Name.HasValue) { query = query.Where(q => q.Name, filter.Name); } if (filter.Code != null && filter.Code.HasValue) { query = query.Where(q => q.Code, filter.Code); } query = OrFilter(query, filter); return(query); }
public async Task <ActionResult> Export([FromBody] Place_PlaceFilterDTO Place_PlaceFilterDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } MemoryStream memoryStream = new MemoryStream(); using (ExcelPackage excel = new ExcelPackage(memoryStream)) { #region Place var PlaceFilter = ConvertFilterDTOToFilterEntity(Place_PlaceFilterDTO); PlaceFilter.Skip = 0; PlaceFilter.Take = int.MaxValue; PlaceFilter = await PlaceService.ToFilter(PlaceFilter); List <Place> Places = await PlaceService.List(PlaceFilter); var PlaceHeaders = new List <string[]>() { new string[] { "Id", "Name", "PlaceGroupId", "Radius", "Latitude", "Longtitude", } }; List <object[]> PlaceData = new List <object[]>(); for (int i = 0; i < Places.Count; i++) { var Place = Places[i]; PlaceData.Add(new Object[] { Place.Id, Place.Name, Place.PlaceGroupId, Place.Radius, Place.Latitude, Place.Longtitude, }); } excel.GenerateWorksheet("Place", PlaceHeaders, PlaceData); #endregion #region PlaceGroup var PlaceGroupFilter = new PlaceGroupFilter(); PlaceGroupFilter.Selects = PlaceGroupSelect.ALL; PlaceGroupFilter.OrderBy = PlaceGroupOrder.Id; PlaceGroupFilter.OrderType = OrderType.ASC; PlaceGroupFilter.Skip = 0; PlaceGroupFilter.Take = int.MaxValue; List <PlaceGroup> PlaceGroups = await PlaceGroupService.List(PlaceGroupFilter); var PlaceGroupHeaders = new List <string[]>() { new string[] { "Id", "ParentId", "Name", "Code", } }; List <object[]> PlaceGroupData = new List <object[]>(); for (int i = 0; i < PlaceGroups.Count; i++) { var PlaceGroup = PlaceGroups[i]; PlaceGroupData.Add(new Object[] { PlaceGroup.Id, PlaceGroup.ParentId, PlaceGroup.Name, PlaceGroup.Code, }); } excel.GenerateWorksheet("PlaceGroup", PlaceGroupHeaders, PlaceGroupData); #endregion excel.Save(); } return(File(memoryStream.ToArray(), "application/octet-stream", "Place.xlsx")); }
private IQueryable <PlaceGroupDAO> OrFilter(IQueryable <PlaceGroupDAO> query, PlaceGroupFilter filter) { if (filter.OrFilter == null || filter.OrFilter.Count == 0) { return(query); } IQueryable <PlaceGroupDAO> initQuery = query.Where(q => false); foreach (PlaceGroupFilter PlaceGroupFilter in filter.OrFilter) { IQueryable <PlaceGroupDAO> queryable = query; if (PlaceGroupFilter.Id != null && PlaceGroupFilter.Id.HasValue) { queryable = queryable.Where(q => q.Id, filter.Id); } if (PlaceGroupFilter.ParentId != null && PlaceGroupFilter.ParentId.HasValue) { queryable = queryable.Where(q => q.ParentId.HasValue).Where(q => q.ParentId.Value, filter.ParentId); } if (PlaceGroupFilter.Name != null && PlaceGroupFilter.Name.HasValue) { queryable = queryable.Where(q => q.Name, filter.Name); } if (PlaceGroupFilter.Code != null && PlaceGroupFilter.Code.HasValue) { queryable = queryable.Where(q => q.Code, filter.Code); } initQuery = initQuery.Union(queryable); } return(initQuery); }