public async Task <int> Count(PlaceCheckingFilter filter)
{
IQueryable <PlaceCheckingDAO> PlaceCheckings = DataContext.PlaceChecking.AsNoTracking();
PlaceCheckings = DynamicFilter(PlaceCheckings, filter);
return(await PlaceCheckings.CountAsync());
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter();
PlaceCheckingFilter = await PlaceCheckingService.ToFilter(PlaceCheckingFilter);
PlaceCheckingFilter.Id = new IdFilter {
In = Ids
};
PlaceCheckingFilter.Selects = PlaceCheckingSelect.Id;
PlaceCheckingFilter.Skip = 0;
PlaceCheckingFilter.Take = int.MaxValue;
List <PlaceChecking> PlaceCheckings = await PlaceCheckingService.List(PlaceCheckingFilter);
PlaceCheckings = await PlaceCheckingService.BulkDelete(PlaceCheckings);
if (PlaceCheckings.Any(x => !x.IsValidated))
{
return(BadRequest(PlaceCheckings.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <List <Tracking_PlaceCheckingDTO> > FilterListPlaceChecking([FromBody] Tracking_PlaceCheckingFilterDTO Tracking_PlaceCheckingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter();
PlaceCheckingFilter.Skip = 0;
PlaceCheckingFilter.Take = 20;
PlaceCheckingFilter.OrderBy = PlaceCheckingOrder.Id;
PlaceCheckingFilter.OrderType = OrderType.ASC;
PlaceCheckingFilter.Selects = PlaceCheckingSelect.ALL;
PlaceCheckingFilter.Id = Tracking_PlaceCheckingFilterDTO.Id;
PlaceCheckingFilter.AppUserId = Tracking_PlaceCheckingFilterDTO.AppUserId;
PlaceCheckingFilter.PlaceId = Tracking_PlaceCheckingFilterDTO.PlaceId;
PlaceCheckingFilter.PlaceCheckingStatusId = Tracking_PlaceCheckingFilterDTO.PlaceCheckingStatusId;
PlaceCheckingFilter.CheckInAt = Tracking_PlaceCheckingFilterDTO.CheckInAt;
PlaceCheckingFilter.CheckOutAt = Tracking_PlaceCheckingFilterDTO.CheckOutAt;
List <PlaceChecking> PlaceCheckings = await PlaceCheckingService.List(PlaceCheckingFilter);
List <Tracking_PlaceCheckingDTO> Tracking_PlaceCheckingDTOs = PlaceCheckings
.Select(x => new Tracking_PlaceCheckingDTO(x)).ToList();
return(Tracking_PlaceCheckingDTOs);
}
public async Task <PlaceCheckingFilter> ToFilter(PlaceCheckingFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <PlaceCheckingFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
PlaceCheckingFilter subFilter = new PlaceCheckingFilter();
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.AppUserId))
{
subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.PlaceId))
{
subFilter.PlaceId = FilterBuilder.Merge(subFilter.PlaceId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.PlaceCheckingStatusId))
{
subFilter.PlaceCheckingStatusId = FilterBuilder.Merge(subFilter.PlaceCheckingStatusId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.CheckInAt))
{
subFilter.CheckInAt = FilterBuilder.Merge(subFilter.CheckInAt, FilterPermissionDefinition.DateFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.CheckOutAt))
{
subFilter.CheckOutAt = FilterBuilder.Merge(subFilter.CheckOutAt, FilterPermissionDefinition.DateFilter);
}
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 <PlaceChecking> > List(PlaceCheckingFilter filter)
{
if (filter == null)
{
return(new List <PlaceChecking>());
}
IQueryable <PlaceCheckingDAO> PlaceCheckingDAOs = DataContext.PlaceChecking.AsNoTracking();
PlaceCheckingDAOs = DynamicFilter(PlaceCheckingDAOs, filter);
PlaceCheckingDAOs = DynamicOrder(PlaceCheckingDAOs, filter);
List <PlaceChecking> PlaceCheckings = await DynamicSelect(PlaceCheckingDAOs, filter);
return(PlaceCheckings);
}
public async Task <int> Count(PlaceCheckingFilter PlaceCheckingFilter)
{
try
{
int result = await UOW.PlaceCheckingRepository.Count(PlaceCheckingFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(PlaceCheckingService));
}
return(0);
}
public async Task <List <PlaceChecking> > List(PlaceCheckingFilter PlaceCheckingFilter)
{
try
{
List <PlaceChecking> PlaceCheckings = await UOW.PlaceCheckingRepository.List(PlaceCheckingFilter);
return(PlaceCheckings);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(PlaceCheckingService));
}
return(null);
}
public async Task <ActionResult <int> > Count([FromBody] PlaceChecking_PlaceCheckingFilterDTO PlaceChecking_PlaceCheckingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PlaceCheckingFilter PlaceCheckingFilter = ConvertFilterDTOToFilterEntity(PlaceChecking_PlaceCheckingFilterDTO);
PlaceCheckingFilter = await PlaceCheckingService.ToFilter(PlaceCheckingFilter);
int count = await PlaceCheckingService.Count(PlaceCheckingFilter);
return(count);
}
public async Task <ActionResult <List <PlaceChecking_PlaceCheckingDTO> > > List([FromBody] PlaceChecking_PlaceCheckingFilterDTO PlaceChecking_PlaceCheckingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PlaceCheckingFilter PlaceCheckingFilter = ConvertFilterDTOToFilterEntity(PlaceChecking_PlaceCheckingFilterDTO);
PlaceCheckingFilter = await PlaceCheckingService.ToFilter(PlaceCheckingFilter);
List <PlaceChecking> PlaceCheckings = await PlaceCheckingService.List(PlaceCheckingFilter);
List <PlaceChecking_PlaceCheckingDTO> PlaceChecking_PlaceCheckingDTOs = PlaceCheckings
.Select(c => new PlaceChecking_PlaceCheckingDTO(c)).ToList();
return(PlaceChecking_PlaceCheckingDTOs);
}
private PlaceCheckingFilter ConvertFilterDTOToFilterEntity(PlaceChecking_PlaceCheckingFilterDTO PlaceChecking_PlaceCheckingFilterDTO)
{
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter();
PlaceCheckingFilter.Selects = PlaceCheckingSelect.ALL;
PlaceCheckingFilter.Skip = PlaceChecking_PlaceCheckingFilterDTO.Skip;
PlaceCheckingFilter.Take = PlaceChecking_PlaceCheckingFilterDTO.Take;
PlaceCheckingFilter.OrderBy = PlaceChecking_PlaceCheckingFilterDTO.OrderBy;
PlaceCheckingFilter.OrderType = PlaceChecking_PlaceCheckingFilterDTO.OrderType;
PlaceCheckingFilter.Id = PlaceChecking_PlaceCheckingFilterDTO.Id;
PlaceCheckingFilter.AppUserId = PlaceChecking_PlaceCheckingFilterDTO.AppUserId;
PlaceCheckingFilter.PlaceId = PlaceChecking_PlaceCheckingFilterDTO.PlaceId;
PlaceCheckingFilter.PlaceCheckingStatusId = PlaceChecking_PlaceCheckingFilterDTO.PlaceCheckingStatusId;
PlaceCheckingFilter.CheckInAt = PlaceChecking_PlaceCheckingFilterDTO.CheckInAt;
PlaceCheckingFilter.CheckOutAt = PlaceChecking_PlaceCheckingFilterDTO.CheckOutAt;
return(PlaceCheckingFilter);
}
public async Task <bool> ValidateId(PlaceChecking PlaceChecking)
{
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = PlaceChecking.Id
},
Selects = PlaceCheckingSelect.Id
};
int count = await UOW.PlaceCheckingRepository.Count(PlaceCheckingFilter);
if (count == 0)
{
PlaceChecking.AddError(nameof(PlaceCheckingValidator), nameof(PlaceChecking.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
private async Task <bool> HasPermission(long Id)
{
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter();
PlaceCheckingFilter = await PlaceCheckingService.ToFilter(PlaceCheckingFilter);
if (Id == 0)
{
}
else
{
PlaceCheckingFilter.Id = new IdFilter {
Equal = Id
};
int count = await PlaceCheckingService.Count(PlaceCheckingFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <ActionResult> Import(IFormFile file)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
PlaceFilter PlaceFilter = new PlaceFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = PlaceSelect.ALL
};
List <Place> Places = await PlaceService.List(PlaceFilter);
PlaceCheckingFilter PlaceCheckingFilter = new PlaceCheckingFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = PlaceCheckingSelect.ALL
};
List <PlaceChecking> PlaceCheckings = await PlaceCheckingService.List(PlaceCheckingFilter);
AppUserFilter TargetFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.ALL
};
List <AppUser> Targets = await AppUserService.List(TargetFilter);
AppUserFilter TrackerFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.ALL
};
List <AppUser> Trackers = await AppUserService.List(TrackerFilter);
List <Tracking> Trackings = new List <Tracking>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(Trackings));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int TrackerIdColumn = 1 + StartColumn;
int TargetIdColumn = 2 + StartColumn;
int PlaceIdColumn = 3 + StartColumn;
int PlaceCheckingIdColumn = 4 + StartColumn;
int UsedColumn = 8 + StartColumn;
for (int i = StartRow; i <= worksheet.Dimension.End.Row; i++)
{
if (string.IsNullOrEmpty(worksheet.Cells[i + StartRow, StartColumn].Value?.ToString()))
{
break;
}
string IdValue = worksheet.Cells[i + StartRow, IdColumn].Value?.ToString();
string TrackerIdValue = worksheet.Cells[i + StartRow, TrackerIdColumn].Value?.ToString();
string TargetIdValue = worksheet.Cells[i + StartRow, TargetIdColumn].Value?.ToString();
string PlaceIdValue = worksheet.Cells[i + StartRow, PlaceIdColumn].Value?.ToString();
string PlaceCheckingIdValue = worksheet.Cells[i + StartRow, PlaceCheckingIdColumn].Value?.ToString();
string UsedValue = worksheet.Cells[i + StartRow, UsedColumn].Value?.ToString();
Tracking Tracking = new Tracking();
Place Place = Places.Where(x => x.Id.ToString() == PlaceIdValue).FirstOrDefault();
Tracking.PlaceId = Place == null ? 0 : Place.Id;
Tracking.Place = Place;
PlaceChecking PlaceChecking = PlaceCheckings.Where(x => x.Id.ToString() == PlaceCheckingIdValue).FirstOrDefault();
Tracking.PlaceCheckingId = PlaceChecking == null ? 0 : PlaceChecking.Id;
Tracking.PlaceChecking = PlaceChecking;
AppUser Target = Targets.Where(x => x.Id.ToString() == TargetIdValue).FirstOrDefault();
Tracking.TargetId = Target == null ? 0 : Target.Id;
Tracking.Target = Target;
AppUser Tracker = Trackers.Where(x => x.Id.ToString() == TrackerIdValue).FirstOrDefault();
Tracking.TrackerId = Tracker == null ? 0 : Tracker.Id;
Tracking.Tracker = Tracker;
Trackings.Add(Tracking);
}
}
Trackings = await TrackingService.Import(Trackings);
if (Trackings.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < Trackings.Count; i++)
{
Tracking Tracking = Trackings[i];
if (!Tracking.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (Tracking.Errors.ContainsKey(nameof(Tracking.Id)))
{
Error += Tracking.Errors[nameof(Tracking.Id)];
}
if (Tracking.Errors.ContainsKey(nameof(Tracking.TrackerId)))
{
Error += Tracking.Errors[nameof(Tracking.TrackerId)];
}
if (Tracking.Errors.ContainsKey(nameof(Tracking.TargetId)))
{
Error += Tracking.Errors[nameof(Tracking.TargetId)];
}
if (Tracking.Errors.ContainsKey(nameof(Tracking.PlaceId)))
{
Error += Tracking.Errors[nameof(Tracking.PlaceId)];
}
if (Tracking.Errors.ContainsKey(nameof(Tracking.PlaceCheckingId)))
{
Error += Tracking.Errors[nameof(Tracking.PlaceCheckingId)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
private IQueryable <PlaceCheckingDAO> DynamicOrder(IQueryable <PlaceCheckingDAO> query, PlaceCheckingFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case PlaceCheckingOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case PlaceCheckingOrder.AppUser:
query = query.OrderBy(q => q.AppUserId);
break;
case PlaceCheckingOrder.Place:
query = query.OrderBy(q => q.PlaceId);
break;
case PlaceCheckingOrder.PlaceCheckingStatus:
query = query.OrderBy(q => q.PlaceCheckingStatusId);
break;
case PlaceCheckingOrder.CheckInAt:
query = query.OrderBy(q => q.CheckInAt);
break;
case PlaceCheckingOrder.CheckOutAt:
query = query.OrderBy(q => q.CheckOutAt);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case PlaceCheckingOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case PlaceCheckingOrder.AppUser:
query = query.OrderByDescending(q => q.AppUserId);
break;
case PlaceCheckingOrder.Place:
query = query.OrderByDescending(q => q.PlaceId);
break;
case PlaceCheckingOrder.PlaceCheckingStatus:
query = query.OrderByDescending(q => q.PlaceCheckingStatusId);
break;
case PlaceCheckingOrder.CheckInAt:
query = query.OrderByDescending(q => q.CheckInAt);
break;
case PlaceCheckingOrder.CheckOutAt:
query = query.OrderByDescending(q => q.CheckOutAt);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private async Task <List <PlaceChecking> > DynamicSelect(IQueryable <PlaceCheckingDAO> query, PlaceCheckingFilter filter)
{
List <PlaceChecking> PlaceCheckings = await query.Select(q => new PlaceChecking()
{
Id = filter.Selects.Contains(PlaceCheckingSelect.Id) ? q.Id : default(long),
AppUserId = filter.Selects.Contains(PlaceCheckingSelect.AppUser) ? q.AppUserId : default(long),
PlaceId = filter.Selects.Contains(PlaceCheckingSelect.Place) ? q.PlaceId : default(long),
PlaceCheckingStatusId = filter.Selects.Contains(PlaceCheckingSelect.PlaceCheckingStatus) ? q.PlaceCheckingStatusId : default(long),
CheckInAt = filter.Selects.Contains(PlaceCheckingSelect.CheckInAt) ? q.CheckInAt : default(DateTime?),
CheckOutAt = filter.Selects.Contains(PlaceCheckingSelect.CheckOutAt) ? q.CheckOutAt : default(DateTime?),
AppUser = filter.Selects.Contains(PlaceCheckingSelect.AppUser) && q.AppUser != null ? new AppUser
{
Id = q.AppUser.Id,
Username = q.AppUser.Username,
Password = q.AppUser.Password,
DisplayName = q.AppUser.DisplayName,
Email = q.AppUser.Email,
Phone = q.AppUser.Phone,
} : null,
Place = filter.Selects.Contains(PlaceCheckingSelect.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,
PlaceCheckingStatus = filter.Selects.Contains(PlaceCheckingSelect.PlaceCheckingStatus) && q.PlaceCheckingStatus != null ? new CheckingStatus
{
Id = q.PlaceCheckingStatus.Id,
Code = q.PlaceCheckingStatus.Code,
Name = q.PlaceCheckingStatus.Name,
} : null,
}).ToListAsync();
return(PlaceCheckings);
}
private IQueryable <PlaceCheckingDAO> DynamicFilter(IQueryable <PlaceCheckingDAO> query, PlaceCheckingFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null && filter.Id.HasValue)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.AppUserId != null && filter.AppUserId.HasValue)
{
query = query.Where(q => q.AppUserId, filter.AppUserId);
}
if (filter.PlaceId != null && filter.PlaceId.HasValue)
{
query = query.Where(q => q.PlaceId, filter.PlaceId);
}
if (filter.PlaceCheckingStatusId != null && filter.PlaceCheckingStatusId.HasValue)
{
query = query.Where(q => q.PlaceCheckingStatusId, filter.PlaceCheckingStatusId);
}
if (filter.CheckInAt != null && filter.CheckInAt.HasValue)
{
query = query.Where(q => q.CheckInAt == null).Union(query.Where(q => q.CheckInAt.HasValue).Where(q => q.CheckInAt.Value, filter.CheckInAt));
}
if (filter.CheckOutAt != null && filter.CheckOutAt.HasValue)
{
query = query.Where(q => q.CheckOutAt == null).Union(query.Where(q => q.CheckOutAt.HasValue).Where(q => q.CheckOutAt.Value, filter.CheckOutAt));
}
query = OrFilter(query, filter);
return(query);
}
public async Task <ActionResult> Export([FromBody] Tracking_TrackingFilterDTO Tracking_TrackingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region Tracking
var TrackingFilter = ConvertFilterDTOToFilterEntity(Tracking_TrackingFilterDTO);
TrackingFilter.Skip = 0;
TrackingFilter.Take = int.MaxValue;
TrackingFilter = await TrackingService.ToFilter(TrackingFilter);
List <Tracking> Trackings = await TrackingService.List(TrackingFilter);
var TrackingHeaders = new List <string[]>()
{
new string[] {
"Id",
"TrackerId",
"TargetId",
"PlaceId",
"PlaceCheckingId",
}
};
List <object[]> TrackingData = new List <object[]>();
for (int i = 0; i < Trackings.Count; i++)
{
var Tracking = Trackings[i];
TrackingData.Add(new Object[]
{
Tracking.Id,
Tracking.TrackerId,
Tracking.TargetId,
Tracking.PlaceId,
Tracking.PlaceCheckingId,
});
}
excel.GenerateWorksheet("Tracking", TrackingHeaders, TrackingData);
#endregion
#region Place
var PlaceFilter = new PlaceFilter();
PlaceFilter.Selects = PlaceSelect.ALL;
PlaceFilter.OrderBy = PlaceOrder.Id;
PlaceFilter.OrderType = OrderType.ASC;
PlaceFilter.Skip = 0;
PlaceFilter.Take = int.MaxValue;
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 PlaceChecking
var PlaceCheckingFilter = new PlaceCheckingFilter();
PlaceCheckingFilter.Selects = PlaceCheckingSelect.ALL;
PlaceCheckingFilter.OrderBy = PlaceCheckingOrder.Id;
PlaceCheckingFilter.OrderType = OrderType.ASC;
PlaceCheckingFilter.Skip = 0;
PlaceCheckingFilter.Take = int.MaxValue;
List <PlaceChecking> PlaceCheckings = await PlaceCheckingService.List(PlaceCheckingFilter);
var PlaceCheckingHeaders = new List <string[]>()
{
new string[] {
"Id",
"AppUserId",
"PlaceId",
"PlaceCheckingStatusId",
"CheckInAt",
"CheckOutAt",
}
};
List <object[]> PlaceCheckingData = new List <object[]>();
for (int i = 0; i < PlaceCheckings.Count; i++)
{
var PlaceChecking = PlaceCheckings[i];
PlaceCheckingData.Add(new Object[]
{
PlaceChecking.Id,
PlaceChecking.AppUserId,
PlaceChecking.PlaceId,
PlaceChecking.PlaceCheckingStatusId,
PlaceChecking.CheckInAt,
PlaceChecking.CheckOutAt,
});
}
excel.GenerateWorksheet("PlaceChecking", PlaceCheckingHeaders, PlaceCheckingData);
#endregion
#region AppUser
var AppUserFilter = new AppUserFilter();
AppUserFilter.Selects = AppUserSelect.ALL;
AppUserFilter.OrderBy = AppUserOrder.Id;
AppUserFilter.OrderType = OrderType.ASC;
AppUserFilter.Skip = 0;
AppUserFilter.Take = int.MaxValue;
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
var AppUserHeaders = new List <string[]>()
{
new string[] {
"Id",
"Username",
"Password",
"DisplayName",
"Email",
"Phone",
}
};
List <object[]> AppUserData = new List <object[]>();
for (int i = 0; i < AppUsers.Count; i++)
{
var AppUser = AppUsers[i];
AppUserData.Add(new Object[]
{
AppUser.Id,
AppUser.Username,
AppUser.Password,
AppUser.DisplayName,
AppUser.Email,
AppUser.Phone,
});
}
excel.GenerateWorksheet("AppUser", AppUserHeaders, AppUserData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "Tracking.xlsx"));
}
private IQueryable <PlaceCheckingDAO> OrFilter(IQueryable <PlaceCheckingDAO> query, PlaceCheckingFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <PlaceCheckingDAO> initQuery = query.Where(q => false);
foreach (PlaceCheckingFilter PlaceCheckingFilter in filter.OrFilter)
{
IQueryable <PlaceCheckingDAO> queryable = query;
if (PlaceCheckingFilter.Id != null && PlaceCheckingFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (PlaceCheckingFilter.AppUserId != null && PlaceCheckingFilter.AppUserId.HasValue)
{
queryable = queryable.Where(q => q.AppUserId, filter.AppUserId);
}
if (PlaceCheckingFilter.PlaceId != null && PlaceCheckingFilter.PlaceId.HasValue)
{
queryable = queryable.Where(q => q.PlaceId, filter.PlaceId);
}
if (PlaceCheckingFilter.PlaceCheckingStatusId != null && PlaceCheckingFilter.PlaceCheckingStatusId.HasValue)
{
queryable = queryable.Where(q => q.PlaceCheckingStatusId, filter.PlaceCheckingStatusId);
}
if (PlaceCheckingFilter.CheckInAt != null && PlaceCheckingFilter.CheckInAt.HasValue)
{
queryable = queryable.Where(q => q.CheckInAt == null).Union(queryable.Where(q => q.CheckInAt.HasValue).Where(q => q.CheckInAt.Value, filter.CheckInAt));
}
if (PlaceCheckingFilter.CheckOutAt != null && PlaceCheckingFilter.CheckOutAt.HasValue)
{
queryable = queryable.Where(q => q.CheckOutAt == null).Union(queryable.Where(q => q.CheckOutAt.HasValue).Where(q => q.CheckOutAt.Value, filter.CheckOutAt));
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
