public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketOfUserFilter TicketOfUserFilter = new TicketOfUserFilter();
TicketOfUserFilter = TicketOfUserService.ToFilter(TicketOfUserFilter);
TicketOfUserFilter.Id = new IdFilter {
In = Ids
};
TicketOfUserFilter.Selects = TicketOfUserSelect.Id;
TicketOfUserFilter.Skip = 0;
TicketOfUserFilter.Take = int.MaxValue;
List <TicketOfUser> TicketOfUsers = await TicketOfUserService.List(TicketOfUserFilter);
TicketOfUsers = await TicketOfUserService.BulkDelete(TicketOfUsers);
if (TicketOfUsers.Any(x => !x.IsValidated))
{
return(BadRequest(TicketOfUsers.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <int> Count(TicketOfUserFilter filter)
{
IQueryable <TicketOfUserDAO> TicketOfUsers = DataContext.TicketOfUser.AsNoTracking();
TicketOfUsers = DynamicFilter(TicketOfUsers, filter);
return(await TicketOfUsers.CountAsync());
}
public async Task <List <TicketOfUser> > List(TicketOfUserFilter filter)
{
if (filter == null)
{
return(new List <TicketOfUser>());
}
IQueryable <TicketOfUserDAO> TicketOfUserDAOs = DataContext.TicketOfUser.AsNoTracking();
TicketOfUserDAOs = DynamicFilter(TicketOfUserDAOs, filter);
TicketOfUserDAOs = DynamicOrder(TicketOfUserDAOs, filter);
List <TicketOfUser> TicketOfUsers = await DynamicSelect(TicketOfUserDAOs, filter);
return(TicketOfUsers);
}
public async Task <ActionResult <int> > Count([FromBody] TicketOfUser_TicketOfUserFilterDTO TicketOfUser_TicketOfUserFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketOfUserFilter TicketOfUserFilter = ConvertFilterDTOToFilterEntity(TicketOfUser_TicketOfUserFilterDTO);
TicketOfUserFilter = TicketOfUserService.ToFilter(TicketOfUserFilter);
int count = await TicketOfUserService.Count(TicketOfUserFilter);
return(count);
}
public async Task <ActionResult <List <TicketOfUser_TicketOfUserDTO> > > List([FromBody] TicketOfUser_TicketOfUserFilterDTO TicketOfUser_TicketOfUserFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
TicketOfUserFilter TicketOfUserFilter = ConvertFilterDTOToFilterEntity(TicketOfUser_TicketOfUserFilterDTO);
TicketOfUserFilter = TicketOfUserService.ToFilter(TicketOfUserFilter);
List <TicketOfUser> TicketOfUsers = await TicketOfUserService.List(TicketOfUserFilter);
List <TicketOfUser_TicketOfUserDTO> TicketOfUser_TicketOfUserDTOs = TicketOfUsers
.Select(c => new TicketOfUser_TicketOfUserDTO(c)).ToList();
return(TicketOfUser_TicketOfUserDTOs);
}
private TicketOfUserFilter ConvertFilterDTOToFilterEntity(TicketOfUser_TicketOfUserFilterDTO TicketOfUser_TicketOfUserFilterDTO)
{
TicketOfUserFilter TicketOfUserFilter = new TicketOfUserFilter();
TicketOfUserFilter.Selects = TicketOfUserSelect.ALL;
TicketOfUserFilter.Skip = TicketOfUser_TicketOfUserFilterDTO.Skip;
TicketOfUserFilter.Take = TicketOfUser_TicketOfUserFilterDTO.Take;
TicketOfUserFilter.OrderBy = TicketOfUser_TicketOfUserFilterDTO.OrderBy;
TicketOfUserFilter.OrderType = TicketOfUser_TicketOfUserFilterDTO.OrderType;
TicketOfUserFilter.Id = TicketOfUser_TicketOfUserFilterDTO.Id;
TicketOfUserFilter.Notes = TicketOfUser_TicketOfUserFilterDTO.Notes;
TicketOfUserFilter.UserId = TicketOfUser_TicketOfUserFilterDTO.UserId;
TicketOfUserFilter.TicketId = TicketOfUser_TicketOfUserFilterDTO.TicketId;
TicketOfUserFilter.TicketStatusId = TicketOfUser_TicketOfUserFilterDTO.TicketStatusId;
TicketOfUserFilter.CreatedAt = TicketOfUser_TicketOfUserFilterDTO.CreatedAt;
TicketOfUserFilter.UpdatedAt = TicketOfUser_TicketOfUserFilterDTO.UpdatedAt;
return(TicketOfUserFilter);
}
public TicketOfUserFilter ToFilter(TicketOfUserFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <TicketOfUserFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
TicketOfUserFilter subFilter = new TicketOfUserFilter();
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.Notes))
{
subFilter.Notes = FilterPermissionDefinition.StringFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.UserId))
{
subFilter.UserId = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.TicketId))
{
subFilter.TicketId = FilterPermissionDefinition.IdFilter;
}
if (FilterPermissionDefinition.Name == nameof(subFilter.TicketStatusId))
{
subFilter.TicketStatusId = FilterPermissionDefinition.IdFilter;
}
}
}
return(filter);
}
public async Task <bool> ValidateId(TicketOfUser TicketOfUser)
{
TicketOfUserFilter TicketOfUserFilter = new TicketOfUserFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = TicketOfUser.Id
},
Selects = TicketOfUserSelect.Id
};
int count = await UOW.TicketOfUserRepository.Count(TicketOfUserFilter);
if (count == 0)
{
TicketOfUser.AddError(nameof(TicketOfUserValidator), nameof(TicketOfUser.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
private async Task <bool> HasPermission(long Id)
{
TicketOfUserFilter TicketOfUserFilter = new TicketOfUserFilter();
TicketOfUserFilter = TicketOfUserService.ToFilter(TicketOfUserFilter);
if (Id == 0)
{
}
else
{
TicketOfUserFilter.Id = new IdFilter {
Equal = Id
};
int count = await TicketOfUserService.Count(TicketOfUserFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
public async Task <List <TicketOfUser> > List(TicketOfUserFilter TicketOfUserFilter)
{
try
{
List <TicketOfUser> TicketOfUsers = await UOW.TicketOfUserRepository.List(TicketOfUserFilter);
return(TicketOfUsers);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(TicketOfUserService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(TicketOfUserService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(TicketOfUserFilter TicketOfUserFilter)
{
try
{
int result = await UOW.TicketOfUserRepository.Count(TicketOfUserFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(TicketOfUserService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(TicketOfUserService));
throw new MessageException(ex.InnerException);
}
}
}
private IQueryable <TicketOfUserDAO> OrFilter(IQueryable <TicketOfUserDAO> query, TicketOfUserFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <TicketOfUserDAO> initQuery = query.Where(q => false);
foreach (TicketOfUserFilter TicketOfUserFilter in filter.OrFilter)
{
IQueryable <TicketOfUserDAO> queryable = query;
if (TicketOfUserFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, TicketOfUserFilter.Id);
}
if (TicketOfUserFilter.Notes != null)
{
queryable = queryable.Where(q => q.Notes, TicketOfUserFilter.Notes);
}
if (TicketOfUserFilter.UserId != null)
{
queryable = queryable.Where(q => q.UserId, TicketOfUserFilter.UserId);
}
if (TicketOfUserFilter.TicketId != null)
{
queryable = queryable.Where(q => q.TicketId, TicketOfUserFilter.TicketId);
}
if (TicketOfUserFilter.TicketStatusId != null)
{
queryable = queryable.Where(q => q.TicketStatusId, TicketOfUserFilter.TicketStatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <TicketOfUserDAO> DynamicFilter(IQueryable <TicketOfUserDAO> query, TicketOfUserFilter 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.Notes != null)
{
query = query.Where(q => q.Notes, filter.Notes);
}
if (filter.UserId != null)
{
query = query.Where(q => q.UserId, filter.UserId);
}
if (filter.TicketId != null)
{
query = query.Where(q => q.TicketId, filter.TicketId);
}
if (filter.TicketStatusId != null)
{
query = query.Where(q => q.TicketStatusId, filter.TicketStatusId);
}
query = OrFilter(query, filter);
return(query);
}
private async Task <List <TicketOfUser> > DynamicSelect(IQueryable <TicketOfUserDAO> query, TicketOfUserFilter filter)
{
List <TicketOfUser> TicketOfUsers = await query.Select(q => new TicketOfUser()
{
Id = filter.Selects.Contains(TicketOfUserSelect.Id) ? q.Id : default(long),
Notes = filter.Selects.Contains(TicketOfUserSelect.Notes) ? q.Notes : default(string),
UserId = filter.Selects.Contains(TicketOfUserSelect.User) ? q.UserId : default(long),
TicketId = filter.Selects.Contains(TicketOfUserSelect.Ticket) ? q.TicketId : default(long),
TicketStatusId = filter.Selects.Contains(TicketOfUserSelect.TicketStatus) ? q.TicketStatusId : default(long),
Ticket = filter.Selects.Contains(TicketOfUserSelect.Ticket) && q.Ticket != null ? new Ticket
{
Id = q.Ticket.Id,
Name = q.Ticket.Name,
Phone = q.Ticket.Phone,
CustomerId = q.Ticket.CustomerId,
UserId = q.Ticket.UserId,
ProductId = q.Ticket.ProductId,
ReceiveDate = q.Ticket.ReceiveDate,
ProcessDate = q.Ticket.ProcessDate,
FinishDate = q.Ticket.FinishDate,
Subject = q.Ticket.Subject,
Content = q.Ticket.Content,
TicketIssueLevelId = q.Ticket.TicketIssueLevelId,
TicketPriorityId = q.Ticket.TicketPriorityId,
TicketStatusId = q.Ticket.TicketStatusId,
TicketSourceId = q.Ticket.TicketSourceId,
TicketNumber = q.Ticket.TicketNumber,
DepartmentId = q.Ticket.DepartmentId,
RelatedTicketId = q.Ticket.RelatedTicketId,
SLA = q.Ticket.SLA,
RelatedCallLogId = q.Ticket.RelatedCallLogId,
ResponseMethodId = q.Ticket.ResponseMethodId,
StatusId = q.Ticket.StatusId,
Used = q.Ticket.Used,
} : null,
TicketStatus = filter.Selects.Contains(TicketOfUserSelect.TicketStatus) && q.TicketStatus != null ? new TicketStatus
{
Id = q.TicketStatus.Id,
Name = q.TicketStatus.Name,
OrderNumber = q.TicketStatus.OrderNumber,
ColorCode = q.TicketStatus.ColorCode,
StatusId = q.TicketStatus.StatusId,
Used = q.TicketStatus.Used,
} : null,
User = filter.Selects.Contains(TicketOfUserSelect.User) && q.User != null ? new AppUser
{
Id = q.User.Id,
Username = q.User.Username,
DisplayName = q.User.DisplayName,
Address = q.User.Address,
Email = q.User.Email,
Phone = q.User.Phone,
SexId = q.User.SexId,
Birthday = q.User.Birthday,
Avatar = q.User.Avatar,
Department = q.User.Department,
OrganizationId = q.User.OrganizationId,
Longitude = q.User.Longitude,
Latitude = q.User.Latitude,
StatusId = q.User.StatusId,
} : null,
CreatedAt = q.CreatedAt,
UpdatedAt = q.UpdatedAt,
}).ToListAsync();
return(TicketOfUsers);
}
private IQueryable <TicketOfUserDAO> DynamicOrder(IQueryable <TicketOfUserDAO> query, TicketOfUserFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case TicketOfUserOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case TicketOfUserOrder.Notes:
query = query.OrderBy(q => q.Notes);
break;
case TicketOfUserOrder.User:
query = query.OrderBy(q => q.UserId);
break;
case TicketOfUserOrder.Ticket:
query = query.OrderBy(q => q.TicketId);
break;
case TicketOfUserOrder.TicketStatus:
query = query.OrderBy(q => q.TicketStatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case TicketOfUserOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case TicketOfUserOrder.Notes:
query = query.OrderByDescending(q => q.Notes);
break;
case TicketOfUserOrder.User:
query = query.OrderByDescending(q => q.UserId);
break;
case TicketOfUserOrder.Ticket:
query = query.OrderByDescending(q => q.TicketId);
break;
case TicketOfUserOrder.TicketStatus:
query = query.OrderByDescending(q => q.TicketStatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
