public async Task <int> Count(TicketTypeFilter filter)
{
IQueryable <TicketTypeDAO> TicketTypes = DataContext.TicketType.AsNoTracking();
TicketTypes = DynamicFilter(TicketTypes, filter);
return(await TicketTypes.CountAsync());
}
public async Task <List <Dashboard_TicketTypeDTO> > SingleListTicketType([FromBody] Dashboard_TicketTypeFilterDTO Dashboard_TicketTypeFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter.Skip = 0;
TicketTypeFilter.Take = 20;
TicketTypeFilter.OrderBy = TicketTypeOrder.Id;
TicketTypeFilter.OrderType = OrderType.ASC;
TicketTypeFilter.Selects = TicketTypeSelect.ALL;
TicketTypeFilter.Id = Dashboard_TicketTypeFilterDTO.Id;
TicketTypeFilter.Name = Dashboard_TicketTypeFilterDTO.Name;
TicketTypeFilter.ColorCode = Dashboard_TicketTypeFilterDTO.ColorCode;
TicketTypeFilter.StatusId = Dashboard_TicketTypeFilterDTO.StatusId;
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
List <Dashboard_TicketTypeDTO> Dashboard_TicketTypeDTOs = TicketTypes
.Select(x => new Dashboard_TicketTypeDTO(x)).ToList();
return(Dashboard_TicketTypeDTOs);
}
public async Task <List <TicketIssueLevel_TicketTypeDTO> > FilterListTicketType([FromBody] TicketIssueLevel_TicketTypeFilterDTO TicketIssueLevel_TicketTypeFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter.Skip = 0;
TicketTypeFilter.Take = 20;
TicketTypeFilter.OrderBy = TicketTypeOrder.Id;
TicketTypeFilter.OrderType = OrderType.ASC;
TicketTypeFilter.Selects = TicketTypeSelect.ALL;
TicketTypeFilter.Id = TicketIssueLevel_TicketTypeFilterDTO.Id;
TicketTypeFilter.Name = TicketIssueLevel_TicketTypeFilterDTO.Name;
TicketTypeFilter.Code = TicketIssueLevel_TicketTypeFilterDTO.Code;
TicketTypeFilter.StatusId = TicketIssueLevel_TicketTypeFilterDTO.StatusId;
TicketTypeFilter.StatusId.Equal = StatusEnum.ACTIVE.Id;
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
List <TicketIssueLevel_TicketTypeDTO> TicketIssueLevel_TicketTypeDTOs = TicketTypes
.Select(x => new TicketIssueLevel_TicketTypeDTO(x)).ToList();
return(TicketIssueLevel_TicketTypeDTOs);
}
public async Task <ActionResult <int> > Count([FromBody] TicketType_TicketTypeFilterDTO TicketType_TicketTypeFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketTypeFilter TicketTypeFilter = ConvertFilterDTOToFilterEntity(TicketType_TicketTypeFilterDTO);
TicketTypeFilter = TicketTypeService.ToFilter(TicketTypeFilter);
int count = await TicketTypeService.Count(TicketTypeFilter);
return(count);
}
public async Task <List <TicketType> > List(TicketTypeFilter filter)
{
if (filter == null)
{
return(new List <TicketType>());
}
IQueryable <TicketTypeDAO> TicketTypeDAOs = DataContext.TicketType.AsNoTracking();
TicketTypeDAOs = DynamicFilter(TicketTypeDAOs, filter);
TicketTypeDAOs = DynamicOrder(TicketTypeDAOs, filter);
List <TicketType> TicketTypes = await DynamicSelect(TicketTypeDAOs, filter);
return(TicketTypes);
}
public async Task <ActionResult <List <TicketType_TicketTypeDTO> > > List([FromBody] TicketType_TicketTypeFilterDTO TicketType_TicketTypeFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketTypeFilter TicketTypeFilter = ConvertFilterDTOToFilterEntity(TicketType_TicketTypeFilterDTO);
TicketTypeFilter = TicketTypeService.ToFilter(TicketTypeFilter);
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
List <TicketType_TicketTypeDTO> TicketType_TicketTypeDTOs = TicketTypes
.Select(c => new TicketType_TicketTypeDTO(c)).ToList();
return(TicketType_TicketTypeDTOs);
}
private TicketTypeFilter ConvertFilterDTOToFilterEntity(TicketType_TicketTypeFilterDTO TicketType_TicketTypeFilterDTO)
{
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter.Selects = TicketTypeSelect.ALL;
TicketTypeFilter.Skip = TicketType_TicketTypeFilterDTO.Skip;
TicketTypeFilter.Take = TicketType_TicketTypeFilterDTO.Take;
TicketTypeFilter.OrderBy = TicketType_TicketTypeFilterDTO.OrderBy;
TicketTypeFilter.OrderType = TicketType_TicketTypeFilterDTO.OrderType;
TicketTypeFilter.Id = TicketType_TicketTypeFilterDTO.Id;
TicketTypeFilter.Code = TicketType_TicketTypeFilterDTO.Code;
TicketTypeFilter.Name = TicketType_TicketTypeFilterDTO.Name;
TicketTypeFilter.ColorCode = TicketType_TicketTypeFilterDTO.ColorCode;
TicketTypeFilter.StatusId = TicketType_TicketTypeFilterDTO.StatusId;
TicketTypeFilter.CreatedAt = TicketType_TicketTypeFilterDTO.CreatedAt;
TicketTypeFilter.UpdatedAt = TicketType_TicketTypeFilterDTO.UpdatedAt;
return(TicketTypeFilter);
}
public async Task <bool> ValidateId(TicketType TicketType)
{
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = TicketType.Id
},
Selects = TicketTypeSelect.Id
};
int count = await UOW.TicketTypeRepository.Count(TicketTypeFilter);
if (count == 0)
{
TicketType.AddError(nameof(TicketTypeValidator), nameof(TicketType.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public TicketTypeFilter ToFilter(TicketTypeFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <TicketTypeFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
TicketTypeFilter subFilter = new TicketTypeFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.Id))
{
subFilter.Id = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Code))
{
subFilter.Code = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Name))
{
subFilter.Name = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ColorCode))
{
subFilter.ColorCode = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.StatusId))
{
subFilter.StatusId = FilterPermissionDefinition.IdFilter;
}
}
}
return(filter);
}
public async Task <int> Count(TicketTypeFilter TicketTypeFilter)
{
try
{
int result = await UOW.TicketTypeRepository.Count(TicketTypeFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(TicketTypeService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <List <TicketType> > List(TicketTypeFilter TicketTypeFilter)
{
try
{
List <TicketType> TicketTypes = await UOW.TicketTypeRepository.List(TicketTypeFilter);
return(TicketTypes);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(TicketTypeService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
private async Task <bool> HasPermission(long Id)
{
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter = TicketTypeService.ToFilter(TicketTypeFilter);
if (Id == 0)
{
}
else
{
TicketTypeFilter.Id = new IdFilter {
Equal = Id
};
int count = await TicketTypeService.Count(TicketTypeFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter = TicketTypeService.ToFilter(TicketTypeFilter);
TicketTypeFilter.Id = new IdFilter {
In = Ids
};
TicketTypeFilter.Selects = TicketTypeSelect.Id;
TicketTypeFilter.Skip = 0;
TicketTypeFilter.Take = int.MaxValue;
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
TicketTypes = await TicketTypeService.BulkDelete(TicketTypes);
return(true);
}
public async Task <bool> ValidateCode(TicketType TicketType)
{
if (string.IsNullOrWhiteSpace(TicketType.Code))
{
TicketType.AddError(nameof(TicketTypeValidator), nameof(TicketType.Code), ErrorCode.CodeEmpty);
}
else
{
var Code = TicketType.Code;
if (TicketType.Code.Contains(" ") || !FilterExtension.ChangeToEnglishChar(Code).Equals(TicketType.Code))
{
TicketType.AddError(nameof(TicketTypeValidator), nameof(TicketType.Code), ErrorCode.CodeHasSpecialCharacter);
}
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = TicketType.Id
},
Code = new StringFilter {
Equal = TicketType.Code
},
Selects = TicketTypeSelect.Code
};
int count = await UOW.TicketTypeRepository.Count(TicketTypeFilter);
if (count != 0)
{
TicketType.AddError(nameof(TicketTypeValidator), nameof(TicketType.Code), ErrorCode.CodeExisted);
}
}
return(TicketType.IsValidated);
}
private IQueryable <TicketTypeDAO> DynamicOrder(IQueryable <TicketTypeDAO> query, TicketTypeFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case TicketTypeOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case TicketTypeOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case TicketTypeOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case TicketTypeOrder.ColorCode:
query = query.OrderBy(q => q.ColorCode);
break;
case TicketTypeOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
case TicketTypeOrder.Used:
query = query.OrderBy(q => q.Used);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case TicketTypeOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case TicketTypeOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case TicketTypeOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case TicketTypeOrder.ColorCode:
query = query.OrderByDescending(q => q.ColorCode);
break;
case TicketTypeOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
case TicketTypeOrder.Used:
query = query.OrderByDescending(q => q.Used);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <TicketTypeDAO> DynamicFilter(IQueryable <TicketTypeDAO> query, TicketTypeFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
if (filter.CreatedAt != null)
{
query = query.Where(q => q.CreatedAt, filter.CreatedAt);
}
if (filter.UpdatedAt != null)
{
query = query.Where(q => q.UpdatedAt, filter.UpdatedAt);
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.ColorCode != null)
{
query = query.Where(q => q.ColorCode, filter.ColorCode);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <TicketTypeDAO> OrFilter(IQueryable <TicketTypeDAO> query, TicketTypeFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <TicketTypeDAO> initQuery = query.Where(q => false);
foreach (TicketTypeFilter TicketTypeFilter in filter.OrFilter)
{
IQueryable <TicketTypeDAO> queryable = query;
if (filter.Id != null)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
queryable = queryable.Where(q => q.Code, filter.Code);
}
if (filter.Name != null)
{
queryable = queryable.Where(q => q.Name, filter.Name);
}
if (filter.ColorCode != null)
{
queryable = queryable.Where(q => q.ColorCode, filter.ColorCode);
}
if (filter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, filter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <ActionResult> Import(IFormFile file)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
StatusFilter StatusFilter = new StatusFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = StatusSelect.ALL
};
List <Status> Statuses = await StatusService.List(StatusFilter);
TicketTypeFilter TicketTypeFilter = new TicketTypeFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = TicketTypeSelect.ALL
};
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
List <TicketGroup> TicketGroups = new List <TicketGroup>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(TicketGroups));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int NameColumn = 1 + StartColumn;
int OrderNumberColumn = 2 + StartColumn;
int StatusIdColumn = 3 + StartColumn;
int TicketTypeIdColumn = 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 NameValue = worksheet.Cells[i + StartRow, NameColumn].Value?.ToString();
string OrderNumberValue = worksheet.Cells[i + StartRow, OrderNumberColumn].Value?.ToString();
string StatusIdValue = worksheet.Cells[i + StartRow, StatusIdColumn].Value?.ToString();
string TicketTypeIdValue = worksheet.Cells[i + StartRow, TicketTypeIdColumn].Value?.ToString();
string UsedValue = worksheet.Cells[i + StartRow, UsedColumn].Value?.ToString();
TicketGroup TicketGroup = new TicketGroup();
TicketGroup.Name = NameValue;
TicketGroup.OrderNumber = long.TryParse(OrderNumberValue, out long OrderNumber) ? OrderNumber : 0;
Status Status = Statuses.Where(x => x.Id.ToString() == StatusIdValue).FirstOrDefault();
TicketGroup.StatusId = Status == null ? 0 : Status.Id;
TicketGroup.Status = Status;
TicketType TicketType = TicketTypes.Where(x => x.Id.ToString() == TicketTypeIdValue).FirstOrDefault();
TicketGroup.TicketTypeId = TicketType == null ? 0 : TicketType.Id;
TicketGroup.TicketType = TicketType;
TicketGroups.Add(TicketGroup);
}
}
TicketGroups = await TicketGroupService.Import(TicketGroups);
if (TicketGroups.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < TicketGroups.Count; i++)
{
TicketGroup TicketGroup = TicketGroups[i];
if (!TicketGroup.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.Id)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.Id)];
}
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.Name)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.Name)];
}
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.OrderNumber)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.OrderNumber)];
}
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.StatusId)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.StatusId)];
}
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.TicketTypeId)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.TicketTypeId)];
}
if (TicketGroup.Errors.ContainsKey(nameof(TicketGroup.Used)))
{
Error += TicketGroup.Errors[nameof(TicketGroup.Used)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
public async Task <FileResult> ExportTemplate([FromBody] TicketGroup_TicketGroupFilterDTO TicketGroup_TicketGroupFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region TicketGroup
var TicketGroupHeaders = new List <string[]>()
{
new string[] {
"Id",
"Name",
"OrderNumber",
"StatusId",
"TicketTypeId",
"Used",
}
};
List <object[]> TicketGroupData = new List <object[]>();
excel.GenerateWorksheet("TicketGroup", TicketGroupHeaders, TicketGroupData);
#endregion
#region Status
var StatusFilter = new StatusFilter();
StatusFilter.Selects = StatusSelect.ALL;
StatusFilter.OrderBy = StatusOrder.Id;
StatusFilter.OrderType = OrderType.ASC;
StatusFilter.Skip = 0;
StatusFilter.Take = int.MaxValue;
List <Status> Statuses = await StatusService.List(StatusFilter);
var StatusHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> StatusData = new List <object[]>();
for (int i = 0; i < Statuses.Count; i++)
{
var Status = Statuses[i];
StatusData.Add(new Object[]
{
Status.Id,
Status.Code,
Status.Name,
});
}
excel.GenerateWorksheet("Status", StatusHeaders, StatusData);
#endregion
#region TicketType
var TicketTypeFilter = new TicketTypeFilter();
TicketTypeFilter.Selects = TicketTypeSelect.ALL;
TicketTypeFilter.OrderBy = TicketTypeOrder.Id;
TicketTypeFilter.OrderType = OrderType.ASC;
TicketTypeFilter.Skip = 0;
TicketTypeFilter.Take = int.MaxValue;
List <TicketType> TicketTypes = await TicketTypeService.List(TicketTypeFilter);
var TicketTypeHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
"ColorCode",
"StatusId",
"Used",
}
};
List <object[]> TicketTypeData = new List <object[]>();
for (int i = 0; i < TicketTypes.Count; i++)
{
var TicketType = TicketTypes[i];
TicketTypeData.Add(new Object[]
{
TicketType.Id,
TicketType.Code,
TicketType.Name,
TicketType.ColorCode,
TicketType.StatusId,
TicketType.Used,
});
}
excel.GenerateWorksheet("TicketType", TicketTypeHeaders, TicketTypeData);
#endregion
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "TicketGroup.xlsx"));
}
private async Task <List <TicketType> > DynamicSelect(IQueryable <TicketTypeDAO> query, TicketTypeFilter filter)
{
List <TicketType> TicketTypes = await query.Select(q => new TicketType()
{
Id = filter.Selects.Contains(TicketTypeSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(TicketTypeSelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(TicketTypeSelect.Name) ? q.Name : default(string),
ColorCode = filter.Selects.Contains(TicketTypeSelect.ColorCode) ? q.ColorCode : default(string),
StatusId = filter.Selects.Contains(TicketTypeSelect.Status) ? q.StatusId : default(long),
Used = filter.Selects.Contains(TicketTypeSelect.Used) ? q.Used : default(bool),
Status = filter.Selects.Contains(TicketTypeSelect.Status) && q.Status != null ? new Status
{
Id = q.Status.Id,
Code = q.Status.Code,
Name = q.Status.Name,
} : null,
CreatedAt = q.CreatedAt,
UpdatedAt = q.UpdatedAt,
}).ToListAsync();
return(TicketTypes);
}
