public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CheckingStatusFilter CheckingStatusFilter = new CheckingStatusFilter();
CheckingStatusFilter = await CheckingStatusService.ToFilter(CheckingStatusFilter);
CheckingStatusFilter.Id = new IdFilter {
In = Ids
};
CheckingStatusFilter.Selects = CheckingStatusSelect.Id;
CheckingStatusFilter.Skip = 0;
CheckingStatusFilter.Take = int.MaxValue;
List <CheckingStatus> CheckingStatuses = await CheckingStatusService.List(CheckingStatusFilter);
CheckingStatuses = await CheckingStatusService.BulkDelete(CheckingStatuses);
if (CheckingStatuses.Any(x => !x.IsValidated))
{
return(BadRequest(CheckingStatuses.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <int> Count(CheckingStatusFilter filter)
{
IQueryable <CheckingStatusDAO> CheckingStatuses = DataContext.CheckingStatus.AsNoTracking();
CheckingStatuses = DynamicFilter(CheckingStatuses, filter);
return(await CheckingStatuses.CountAsync());
}
public async Task <List <PlaceChecking_CheckingStatusDTO> > FilterListCheckingStatus([FromBody] PlaceChecking_CheckingStatusFilterDTO PlaceChecking_CheckingStatusFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CheckingStatusFilter CheckingStatusFilter = new CheckingStatusFilter();
CheckingStatusFilter.Skip = 0;
CheckingStatusFilter.Take = 20;
CheckingStatusFilter.OrderBy = CheckingStatusOrder.Id;
CheckingStatusFilter.OrderType = OrderType.ASC;
CheckingStatusFilter.Selects = CheckingStatusSelect.ALL;
CheckingStatusFilter.Id = PlaceChecking_CheckingStatusFilterDTO.Id;
CheckingStatusFilter.Code = PlaceChecking_CheckingStatusFilterDTO.Code;
CheckingStatusFilter.Name = PlaceChecking_CheckingStatusFilterDTO.Name;
List <CheckingStatus> CheckingStatuses = await CheckingStatusService.List(CheckingStatusFilter);
List <PlaceChecking_CheckingStatusDTO> PlaceChecking_CheckingStatusDTOs = CheckingStatuses
.Select(x => new PlaceChecking_CheckingStatusDTO(x)).ToList();
return(PlaceChecking_CheckingStatusDTOs);
}
public async Task <List <CheckingStatus> > List(CheckingStatusFilter CheckingStatusFilter)
{
try
{
List <CheckingStatus> CheckingStatuses = await UOW.CheckingStatusRepository.List(CheckingStatusFilter);
return(CheckingStatuses);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CheckingStatusService));
}
return(null);
}
public async Task <List <CheckingStatus> > List(CheckingStatusFilter filter)
{
if (filter == null)
{
return(new List <CheckingStatus>());
}
IQueryable <CheckingStatusDAO> CheckingStatusDAOs = DataContext.CheckingStatus.AsNoTracking();
CheckingStatusDAOs = DynamicFilter(CheckingStatusDAOs, filter);
CheckingStatusDAOs = DynamicOrder(CheckingStatusDAOs, filter);
List <CheckingStatus> CheckingStatuses = await DynamicSelect(CheckingStatusDAOs, filter);
return(CheckingStatuses);
}
public async Task <int> Count(CheckingStatusFilter CheckingStatusFilter)
{
try
{
int result = await UOW.CheckingStatusRepository.Count(CheckingStatusFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CheckingStatusService));
}
return(0);
}
private CheckingStatusFilter ConvertFilterDTOToFilterEntity(CheckingStatus_CheckingStatusFilterDTO CheckingStatus_CheckingStatusFilterDTO)
{
CheckingStatusFilter CheckingStatusFilter = new CheckingStatusFilter();
CheckingStatusFilter.Selects = CheckingStatusSelect.ALL;
CheckingStatusFilter.Skip = CheckingStatus_CheckingStatusFilterDTO.Skip;
CheckingStatusFilter.Take = CheckingStatus_CheckingStatusFilterDTO.Take;
CheckingStatusFilter.OrderBy = CheckingStatus_CheckingStatusFilterDTO.OrderBy;
CheckingStatusFilter.OrderType = CheckingStatus_CheckingStatusFilterDTO.OrderType;
CheckingStatusFilter.Id = CheckingStatus_CheckingStatusFilterDTO.Id;
CheckingStatusFilter.Code = CheckingStatus_CheckingStatusFilterDTO.Code;
CheckingStatusFilter.Name = CheckingStatus_CheckingStatusFilterDTO.Name;
return(CheckingStatusFilter);
}
public async Task <ActionResult <int> > Count([FromBody] CheckingStatus_CheckingStatusFilterDTO CheckingStatus_CheckingStatusFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CheckingStatusFilter CheckingStatusFilter = ConvertFilterDTOToFilterEntity(CheckingStatus_CheckingStatusFilterDTO);
CheckingStatusFilter = await CheckingStatusService.ToFilter(CheckingStatusFilter);
int count = await CheckingStatusService.Count(CheckingStatusFilter);
return(count);
}
public async Task <ActionResult <List <CheckingStatus_CheckingStatusDTO> > > List([FromBody] CheckingStatus_CheckingStatusFilterDTO CheckingStatus_CheckingStatusFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CheckingStatusFilter CheckingStatusFilter = ConvertFilterDTOToFilterEntity(CheckingStatus_CheckingStatusFilterDTO);
CheckingStatusFilter = await CheckingStatusService.ToFilter(CheckingStatusFilter);
List <CheckingStatus> CheckingStatuses = await CheckingStatusService.List(CheckingStatusFilter);
List <CheckingStatus_CheckingStatusDTO> CheckingStatus_CheckingStatusDTOs = CheckingStatuses
.Select(c => new CheckingStatus_CheckingStatusDTO(c)).ToList();
return(CheckingStatus_CheckingStatusDTOs);
}
public async Task <CheckingStatusFilter> ToFilter(CheckingStatusFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <CheckingStatusFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
CheckingStatusFilter subFilter = new CheckingStatusFilter();
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.Code))
{
subFilter.Code = FilterBuilder.Merge(subFilter.Code, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
{
subFilter.Name = FilterBuilder.Merge(subFilter.Name, 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 <bool> ValidateId(CheckingStatus CheckingStatus)
{
CheckingStatusFilter CheckingStatusFilter = new CheckingStatusFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = CheckingStatus.Id
},
Selects = CheckingStatusSelect.Id
};
int count = await UOW.CheckingStatusRepository.Count(CheckingStatusFilter);
if (count == 0)
{
CheckingStatus.AddError(nameof(CheckingStatusValidator), nameof(CheckingStatus.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
private async Task <bool> HasPermission(long Id)
{
CheckingStatusFilter CheckingStatusFilter = new CheckingStatusFilter();
CheckingStatusFilter = await CheckingStatusService.ToFilter(CheckingStatusFilter);
if (Id == 0)
{
}
else
{
CheckingStatusFilter.Id = new IdFilter {
Equal = Id
};
int count = await CheckingStatusService.Count(CheckingStatusFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
private IQueryable <CheckingStatusDAO> DynamicOrder(IQueryable <CheckingStatusDAO> query, CheckingStatusFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case CheckingStatusOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case CheckingStatusOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case CheckingStatusOrder.Name:
query = query.OrderBy(q => q.Name);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case CheckingStatusOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case CheckingStatusOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case CheckingStatusOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <CheckingStatusDAO> OrFilter(IQueryable <CheckingStatusDAO> query, CheckingStatusFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <CheckingStatusDAO> initQuery = query.Where(q => false);
foreach (CheckingStatusFilter CheckingStatusFilter in filter.OrFilter)
{
IQueryable <CheckingStatusDAO> queryable = query;
if (CheckingStatusFilter.Id != null && CheckingStatusFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (CheckingStatusFilter.Code != null && CheckingStatusFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, filter.Code);
}
if (CheckingStatusFilter.Name != null && CheckingStatusFilter.Name.HasValue)
{
queryable = queryable.Where(q => q.Name, filter.Name);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <CheckingStatusDAO> DynamicFilter(IQueryable <CheckingStatusDAO> query, CheckingStatusFilter 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.Code != null && filter.Code.HasValue)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null && filter.Name.HasValue)
{
query = query.Where(q => q.Name, filter.Name);
}
query = OrFilter(query, filter);
return(query);
}
public async Task <ActionResult> Export([FromBody] PlaceChecking_PlaceCheckingFilterDTO PlaceChecking_PlaceCheckingFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region PlaceChecking
var PlaceCheckingFilter = ConvertFilterDTOToFilterEntity(PlaceChecking_PlaceCheckingFilterDTO);
PlaceCheckingFilter.Skip = 0;
PlaceCheckingFilter.Take = int.MaxValue;
PlaceCheckingFilter = await PlaceCheckingService.ToFilter(PlaceCheckingFilter);
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",
"Used",
}
};
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
#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 CheckingStatus
var CheckingStatusFilter = new CheckingStatusFilter();
CheckingStatusFilter.Selects = CheckingStatusSelect.ALL;
CheckingStatusFilter.OrderBy = CheckingStatusOrder.Id;
CheckingStatusFilter.OrderType = OrderType.ASC;
CheckingStatusFilter.Skip = 0;
CheckingStatusFilter.Take = int.MaxValue;
List <CheckingStatus> CheckingStatuses = await CheckingStatusService.List(CheckingStatusFilter);
var CheckingStatusHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> CheckingStatusData = new List <object[]>();
for (int i = 0; i < CheckingStatuses.Count; i++)
{
var CheckingStatus = CheckingStatuses[i];
CheckingStatusData.Add(new Object[]
{
CheckingStatus.Id,
CheckingStatus.Code,
CheckingStatus.Name,
});
}
excel.GenerateWorksheet("CheckingStatus", CheckingStatusHeaders, CheckingStatusData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "PlaceChecking.xlsx"));
}
private async Task <List <CheckingStatus> > DynamicSelect(IQueryable <CheckingStatusDAO> query, CheckingStatusFilter filter)
{
List <CheckingStatus> CheckingStatuses = await query.Select(q => new CheckingStatus()
{
Id = filter.Selects.Contains(CheckingStatusSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(CheckingStatusSelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(CheckingStatusSelect.Name) ? q.Name : default(string),
}).ToListAsync();
return(CheckingStatuses);
}
public async Task <ActionResult> Import(IFormFile file)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
AppUserFilter AppUserFilter = new AppUserFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = AppUserSelect.ALL
};
List <AppUser> AppUsers = await AppUserService.List(AppUserFilter);
PlaceFilter PlaceFilter = new PlaceFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = PlaceSelect.ALL
};
List <Place> Places = await PlaceService.List(PlaceFilter);
CheckingStatusFilter PlaceCheckingStatusFilter = new CheckingStatusFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CheckingStatusSelect.ALL
};
List <CheckingStatus> PlaceCheckingStatuses = await CheckingStatusService.List(PlaceCheckingStatusFilter);
List <PlaceChecking> PlaceCheckings = new List <PlaceChecking>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(PlaceCheckings));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int AppUserIdColumn = 1 + StartColumn;
int PlaceIdColumn = 2 + StartColumn;
int PlaceCheckingStatusIdColumn = 3 + StartColumn;
int CheckInAtColumn = 4 + StartColumn;
int CheckOutAtColumn = 5 + 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 AppUserIdValue = worksheet.Cells[i + StartRow, AppUserIdColumn].Value?.ToString();
string PlaceIdValue = worksheet.Cells[i + StartRow, PlaceIdColumn].Value?.ToString();
string PlaceCheckingStatusIdValue = worksheet.Cells[i + StartRow, PlaceCheckingStatusIdColumn].Value?.ToString();
string CheckInAtValue = worksheet.Cells[i + StartRow, CheckInAtColumn].Value?.ToString();
string CheckOutAtValue = worksheet.Cells[i + StartRow, CheckOutAtColumn].Value?.ToString();
PlaceChecking PlaceChecking = new PlaceChecking();
PlaceChecking.CheckInAt = DateTime.TryParse(CheckInAtValue, out DateTime CheckInAt) ? CheckInAt : DateTime.Now;
PlaceChecking.CheckOutAt = DateTime.TryParse(CheckOutAtValue, out DateTime CheckOutAt) ? CheckOutAt : DateTime.Now;
AppUser AppUser = AppUsers.Where(x => x.Id.ToString() == AppUserIdValue).FirstOrDefault();
PlaceChecking.AppUserId = AppUser == null ? 0 : AppUser.Id;
PlaceChecking.AppUser = AppUser;
Place Place = Places.Where(x => x.Id.ToString() == PlaceIdValue).FirstOrDefault();
PlaceChecking.PlaceId = Place == null ? 0 : Place.Id;
PlaceChecking.Place = Place;
CheckingStatus PlaceCheckingStatus = PlaceCheckingStatuses.Where(x => x.Id.ToString() == PlaceCheckingStatusIdValue).FirstOrDefault();
PlaceChecking.PlaceCheckingStatusId = PlaceCheckingStatus == null ? 0 : PlaceCheckingStatus.Id;
PlaceChecking.PlaceCheckingStatus = PlaceCheckingStatus;
PlaceCheckings.Add(PlaceChecking);
}
}
PlaceCheckings = await PlaceCheckingService.Import(PlaceCheckings);
if (PlaceCheckings.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < PlaceCheckings.Count; i++)
{
PlaceChecking PlaceChecking = PlaceCheckings[i];
if (!PlaceChecking.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.Id)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.Id)];
}
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.AppUserId)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.AppUserId)];
}
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.PlaceId)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.PlaceId)];
}
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.PlaceCheckingStatusId)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.PlaceCheckingStatusId)];
}
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.CheckInAt)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.CheckInAt)];
}
if (PlaceChecking.Errors.ContainsKey(nameof(PlaceChecking.CheckOutAt)))
{
Error += PlaceChecking.Errors[nameof(PlaceChecking.CheckOutAt)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
