public async Task <int> Count(TrackingFilter filter)
{
IQueryable <TrackingDAO> Trackings = DataContext.Tracking.AsNoTracking();
Trackings = DynamicFilter(Trackings, filter);
return(await Trackings.CountAsync());
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TrackingFilter TrackingFilter = new TrackingFilter();
TrackingFilter = await TrackingService.ToFilter(TrackingFilter);
TrackingFilter.Id = new IdFilter {
In = Ids
};
TrackingFilter.Selects = TrackingSelect.Id;
TrackingFilter.Skip = 0;
TrackingFilter.Take = int.MaxValue;
List <Tracking> Trackings = await TrackingService.List(TrackingFilter);
Trackings = await TrackingService.BulkDelete(Trackings);
if (Trackings.Any(x => !x.IsValidated))
{
return(BadRequest(Trackings.Where(x => !x.IsValidated)));
}
return(true);
}
/**
* Creats a PdfImage object using an explicitly provided dictionary and image bytes
* @param dictionary the dictionary for the image
* @param samples the samples
* @since 5.0.3
*/
protected internal PdfImageObject(PdfDictionary dictionary, byte[] samples, PdfDictionary colorSpaceDic)
{
this.dictionary = dictionary;
this.colorSpaceDic = colorSpaceDic;
TrackingFilter trackingFilter = new TrackingFilter();
IDictionary <PdfName, FilterHandlers.IFilterHandler> handlers = new Dictionary <PdfName, FilterHandlers.IFilterHandler>(FilterHandlers.GetDefaultFilterHandlers());
handlers[PdfName.JBIG2DECODE] = trackingFilter;
handlers[PdfName.DCTDECODE] = trackingFilter;
handlers[PdfName.JPXDECODE] = trackingFilter;
imageBytes = PdfReader.DecodeBytes(samples, dictionary, handlers);
if (trackingFilter.lastFilterName != null)
{
if (PdfName.JBIG2DECODE.Equals(trackingFilter.lastFilterName))
{
streamContentType = ImageBytesType.JBIG2;
}
else if (PdfName.DCTDECODE.Equals(trackingFilter.lastFilterName))
{
streamContentType = ImageBytesType.JPG;
}
else if (PdfName.JPXDECODE.Equals(trackingFilter.lastFilterName))
{
streamContentType = ImageBytesType.JP2;
}
}
else
{
DecodeImageBytes();
}
}
private IQueryable <TrackingDAO> OrFilter(IQueryable <TrackingDAO> query, TrackingFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <TrackingDAO> initQuery = query.Where(q => false);
foreach (TrackingFilter TrackingFilter in filter.OrFilter)
{
IQueryable <TrackingDAO> queryable = query;
if (TrackingFilter.Id != null && TrackingFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (TrackingFilter.TrackerId != null && TrackingFilter.TrackerId.HasValue)
{
queryable = queryable.Where(q => q.TrackerId, filter.TrackerId);
}
if (TrackingFilter.TargetId != null && TrackingFilter.TargetId.HasValue)
{
queryable = queryable.Where(q => q.TargetId, filter.TargetId);
}
if (TrackingFilter.PlaceId != null && TrackingFilter.PlaceId.HasValue)
{
queryable = queryable.Where(q => q.PlaceId, filter.PlaceId);
}
if (TrackingFilter.PlaceCheckingId != null && TrackingFilter.PlaceCheckingId.HasValue)
{
queryable = queryable.Where(q => q.PlaceCheckingId, filter.PlaceCheckingId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <List <Tracking> > List(TrackingFilter TrackingFilter)
{
try
{
List <Tracking> Trackings = await UOW.TrackingRepository.List(TrackingFilter);
return(Trackings);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(TrackingService));
}
return(null);
}
public async Task <int> Count(TrackingFilter TrackingFilter)
{
try
{
int result = await UOW.TrackingRepository.Count(TrackingFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(TrackingService));
}
return(0);
}
public async Task <TrackingFilter> ToFilter(TrackingFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <TrackingFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
TrackingFilter subFilter = new TrackingFilter();
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.TrackerId))
{
subFilter.TrackerId = FilterBuilder.Merge(subFilter.TrackerId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.TargetId))
{
subFilter.TargetId = FilterBuilder.Merge(subFilter.TargetId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.PlaceId))
{
subFilter.PlaceId = FilterBuilder.Merge(subFilter.PlaceId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.PlaceCheckingId))
{
subFilter.PlaceCheckingId = FilterBuilder.Merge(subFilter.PlaceCheckingId, FilterPermissionDefinition.IdFilter);
}
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 <List <Tracking> > List(TrackingFilter filter)
{
if (filter == null)
{
return(new List <Tracking>());
}
IQueryable <TrackingDAO> TrackingDAOs = DataContext.Tracking.AsNoTracking();
TrackingDAOs = DynamicFilter(TrackingDAOs, filter);
TrackingDAOs = DynamicOrder(TrackingDAOs, filter);
List <Tracking> Trackings = await DynamicSelect(TrackingDAOs, filter);
return(Trackings);
}
public async Task <ActionResult <int> > Count([FromBody] Tracking_TrackingFilterDTO Tracking_TrackingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TrackingFilter TrackingFilter = ConvertFilterDTOToFilterEntity(Tracking_TrackingFilterDTO);
TrackingFilter = await TrackingService.ToFilter(TrackingFilter);
int count = await TrackingService.Count(TrackingFilter);
return(count);
}
public TrackingRequest(
ControllerContext controller,
TrackingFilter model,
ICacheProvider cache,
IMessageRequest <TrackingFilterModel, IEnumerable <DomainModels.Business.TrackingDomain.Tracking> > messageQuery,
MiddlewareConfiguration middlewareConfiguration,
Guid correlationId,
IOperationalUnit operationalUnit)
{
_cache = cache;
_controller = controller;
_correlationId = correlationId;
_model = model;
_messageQuery = messageQuery;
_opertationalUnit = operationalUnit;
_middlewareConfiguration = middlewareConfiguration;
}
public async Task <ActionResult <List <Tracking_TrackingDTO> > > List([FromBody] Tracking_TrackingFilterDTO Tracking_TrackingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TrackingFilter TrackingFilter = ConvertFilterDTOToFilterEntity(Tracking_TrackingFilterDTO);
TrackingFilter = await TrackingService.ToFilter(TrackingFilter);
List <Tracking> Trackings = await TrackingService.List(TrackingFilter);
List <Tracking_TrackingDTO> Tracking_TrackingDTOs = Trackings
.Select(c => new Tracking_TrackingDTO(c)).ToList();
return(Tracking_TrackingDTOs);
}
private TrackingFilter ConvertFilterDTOToFilterEntity(Tracking_TrackingFilterDTO Tracking_TrackingFilterDTO)
{
TrackingFilter TrackingFilter = new TrackingFilter();
TrackingFilter.Selects = TrackingSelect.ALL;
TrackingFilter.Skip = Tracking_TrackingFilterDTO.Skip;
TrackingFilter.Take = Tracking_TrackingFilterDTO.Take;
TrackingFilter.OrderBy = Tracking_TrackingFilterDTO.OrderBy;
TrackingFilter.OrderType = Tracking_TrackingFilterDTO.OrderType;
TrackingFilter.Id = Tracking_TrackingFilterDTO.Id;
TrackingFilter.TrackerId = Tracking_TrackingFilterDTO.TrackerId;
TrackingFilter.TargetId = Tracking_TrackingFilterDTO.TargetId;
TrackingFilter.PlaceId = Tracking_TrackingFilterDTO.PlaceId;
TrackingFilter.PlaceCheckingId = Tracking_TrackingFilterDTO.PlaceCheckingId;
TrackingFilter.CreatedAt = Tracking_TrackingFilterDTO.CreatedAt;
TrackingFilter.UpdatedAt = Tracking_TrackingFilterDTO.UpdatedAt;
return(TrackingFilter);
}
public async Task <bool> ValidateId(Tracking Tracking)
{
TrackingFilter TrackingFilter = new TrackingFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Tracking.Id
},
Selects = TrackingSelect.Id
};
int count = await UOW.TrackingRepository.Count(TrackingFilter);
if (count == 0)
{
Tracking.AddError(nameof(TrackingValidator), nameof(Tracking.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
private async Task <bool> HasPermission(long Id)
{
TrackingFilter TrackingFilter = new TrackingFilter();
TrackingFilter = await TrackingService.ToFilter(TrackingFilter);
if (Id == 0)
{
}
else
{
TrackingFilter.Id = new IdFilter {
Equal = Id
};
int count = await TrackingService.Count(TrackingFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
/**
* Creats a PdfImage object using an explicitly provided dictionary and image bytes
* @param dictionary the dictionary for the image
* @param samples the samples
* @since 5.0.3
*/
protected internal PdfImageObject(PdfDictionary dictionary, byte[] samples, PdfDictionary colorSpaceDic) {
this.dictionary = dictionary;
this.colorSpaceDic = colorSpaceDic;
TrackingFilter trackingFilter = new TrackingFilter();
IDictionary<PdfName, FilterHandlers.IFilterHandler> handlers = new Dictionary<PdfName, FilterHandlers.IFilterHandler>(FilterHandlers.GetDefaultFilterHandlers());
handlers[PdfName.JBIG2DECODE] = trackingFilter;
handlers[PdfName.DCTDECODE] = trackingFilter;
handlers[PdfName.JPXDECODE] = trackingFilter;
imageBytes = PdfReader.DecodeBytes(samples, dictionary, handlers);
if (trackingFilter.lastFilterName != null){
if (PdfName.JBIG2DECODE.Equals(trackingFilter.lastFilterName))
streamContentType = ImageBytesType.JBIG2;
else if (PdfName.DCTDECODE.Equals(trackingFilter.lastFilterName))
streamContentType = ImageBytesType.JPG;
else if (PdfName.JPXDECODE.Equals(trackingFilter.lastFilterName))
streamContentType = ImageBytesType.JP2;
} else {
DecodeImageBytes();
}
}
private IQueryable <TrackingDAO> DynamicFilter(IQueryable <TrackingDAO> query, TrackingFilter 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.TrackerId != null && filter.TrackerId.HasValue)
{
query = query.Where(q => q.TrackerId, filter.TrackerId);
}
if (filter.TargetId != null && filter.TargetId.HasValue)
{
query = query.Where(q => q.TargetId, filter.TargetId);
}
if (filter.PlaceId != null && filter.PlaceId.HasValue)
{
query = query.Where(q => q.PlaceId, filter.PlaceId);
}
if (filter.PlaceCheckingId != null && filter.PlaceCheckingId.HasValue)
{
query = query.Where(q => q.PlaceCheckingId, filter.PlaceCheckingId);
}
query = OrFilter(query, filter);
return(query);
}
private async Task <List <Tracking> > DynamicSelect(IQueryable <TrackingDAO> query, TrackingFilter filter)
{
List <Tracking> Trackings = await query.Select(q => new Tracking()
{
Id = filter.Selects.Contains(TrackingSelect.Id) ? q.Id : default(long),
TrackerId = filter.Selects.Contains(TrackingSelect.Tracker) ? q.TrackerId : default(long),
TargetId = filter.Selects.Contains(TrackingSelect.Target) ? q.TargetId : default(long),
PlaceId = filter.Selects.Contains(TrackingSelect.Place) ? q.PlaceId : default(long),
PlaceCheckingId = filter.Selects.Contains(TrackingSelect.PlaceChecking) ? q.PlaceCheckingId : default(long),
Place = filter.Selects.Contains(TrackingSelect.Place) && q.Place != null ? new Place
{
Id = q.Place.Id,
Name = q.Place.Name,
PlaceGroupId = q.Place.PlaceGroupId,
Radius = q.Place.Radius,
Latitude = q.Place.Latitude,
Longtitude = q.Place.Longtitude,
} : null,
PlaceChecking = filter.Selects.Contains(TrackingSelect.PlaceChecking) && q.PlaceChecking != null ? new PlaceChecking
{
Id = q.PlaceChecking.Id,
AppUserId = q.PlaceChecking.AppUserId,
PlaceId = q.PlaceChecking.PlaceId,
PlaceCheckingStatusId = q.PlaceChecking.PlaceCheckingStatusId,
CheckInAt = q.PlaceChecking.CheckInAt,
CheckOutAt = q.PlaceChecking.CheckOutAt,
} : null,
Target = filter.Selects.Contains(TrackingSelect.Target) && q.Target != null ? new AppUser
{
Id = q.Target.Id,
Username = q.Target.Username,
Password = q.Target.Password,
DisplayName = q.Target.DisplayName,
Email = q.Target.Email,
Phone = q.Target.Phone,
} : null,
Tracker = filter.Selects.Contains(TrackingSelect.Tracker) && q.Tracker != null ? new AppUser
{
Id = q.Tracker.Id,
Username = q.Tracker.Username,
Password = q.Tracker.Password,
DisplayName = q.Tracker.DisplayName,
Email = q.Tracker.Email,
Phone = q.Tracker.Phone,
} : null,
}).ToListAsync();
return(Trackings);
}
private IQueryable <TrackingDAO> DynamicOrder(IQueryable <TrackingDAO> query, TrackingFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case TrackingOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case TrackingOrder.Tracker:
query = query.OrderBy(q => q.TrackerId);
break;
case TrackingOrder.Target:
query = query.OrderBy(q => q.TargetId);
break;
case TrackingOrder.Place:
query = query.OrderBy(q => q.PlaceId);
break;
case TrackingOrder.PlaceChecking:
query = query.OrderBy(q => q.PlaceCheckingId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case TrackingOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case TrackingOrder.Tracker:
query = query.OrderByDescending(q => q.TrackerId);
break;
case TrackingOrder.Target:
query = query.OrderByDescending(q => q.TargetId);
break;
case TrackingOrder.Place:
query = query.OrderByDescending(q => q.PlaceId);
break;
case TrackingOrder.PlaceChecking:
query = query.OrderByDescending(q => q.PlaceCheckingId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
