public async Task <ActionResult <bool> > BulkDelete([FromBody] List <long> Ids)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
RepairTicketFilter RepairTicketFilter = new RepairTicketFilter();
RepairTicketFilter = await RepairTicketService.ToFilter(RepairTicketFilter);
RepairTicketFilter.Id = new IdFilter {
In = Ids
};
RepairTicketFilter.Selects = RepairTicketSelect.Id;
RepairTicketFilter.Skip = 0;
RepairTicketFilter.Take = int.MaxValue;
List <RepairTicket> RepairTickets = await RepairTicketService.List(RepairTicketFilter);
RepairTickets = await RepairTicketService.BulkDelete(RepairTickets);
if (RepairTickets.Any(x => !x.IsValidated))
{
return(BadRequest(RepairTickets.Where(x => !x.IsValidated)));
}
return(true);
}
public async Task <int> Count(RepairTicketFilter filter)
{
IQueryable <RepairTicketDAO> RepairTickets = DataContext.RepairTicket.AsNoTracking();
RepairTickets = DynamicFilter(RepairTickets, filter);
return(await RepairTickets.CountAsync());
}
private RepairTicketFilter ConvertFilterRepairTicket(Customer_RepairTicketFilterDTO Customer_RepairTicketFilterDTO)
{
RepairTicketFilter RepairTicketFilter = new RepairTicketFilter();
RepairTicketFilter.Selects = RepairTicketSelect.ALL;
RepairTicketFilter.Skip = Customer_RepairTicketFilterDTO.Skip;
RepairTicketFilter.Take = Customer_RepairTicketFilterDTO.Take;
RepairTicketFilter.OrderBy = Customer_RepairTicketFilterDTO.OrderBy;
RepairTicketFilter.OrderType = Customer_RepairTicketFilterDTO.OrderType;
RepairTicketFilter.Id = Customer_RepairTicketFilterDTO.Id;
RepairTicketFilter.Code = Customer_RepairTicketFilterDTO.Code;
RepairTicketFilter.DeviceSerial = Customer_RepairTicketFilterDTO.DeviceSerial;
RepairTicketFilter.OrderId = Customer_RepairTicketFilterDTO.OrderId;
RepairTicketFilter.OrderCategoryId = Customer_RepairTicketFilterDTO.OrderCategoryId;
RepairTicketFilter.RepairDueDate = Customer_RepairTicketFilterDTO.RepairDueDate;
RepairTicketFilter.ItemId = Customer_RepairTicketFilterDTO.ItemId;
RepairTicketFilter.RejectReason = Customer_RepairTicketFilterDTO.RejectReason;
RepairTicketFilter.DeviceState = Customer_RepairTicketFilterDTO.DeviceState;
RepairTicketFilter.RepairStatusId = Customer_RepairTicketFilterDTO.RepairStatusId;
RepairTicketFilter.RepairAddess = Customer_RepairTicketFilterDTO.RepairAddess;
RepairTicketFilter.ReceiveUser = Customer_RepairTicketFilterDTO.ReceiveUser;
RepairTicketFilter.ReceiveDate = Customer_RepairTicketFilterDTO.ReceiveDate;
RepairTicketFilter.RepairDate = Customer_RepairTicketFilterDTO.RepairDate;
RepairTicketFilter.ReturnDate = Customer_RepairTicketFilterDTO.ReturnDate;
RepairTicketFilter.RepairSolution = Customer_RepairTicketFilterDTO.RepairSolution;
RepairTicketFilter.Note = Customer_RepairTicketFilterDTO.Note;
RepairTicketFilter.RepairCost = Customer_RepairTicketFilterDTO.RepairCost;
RepairTicketFilter.PaymentStatusId = Customer_RepairTicketFilterDTO.PaymentStatusId;
RepairTicketFilter.CustomerId = Customer_RepairTicketFilterDTO.CustomerId;
RepairTicketFilter.CreatorId = Customer_RepairTicketFilterDTO.CreatorId;
RepairTicketFilter.CreatedAt = Customer_RepairTicketFilterDTO.CreatedAt;
RepairTicketFilter.UpdatedAt = Customer_RepairTicketFilterDTO.UpdatedAt;
return(RepairTicketFilter);
}
public async Task <List <RepairTicket> > List(RepairTicketFilter filter)
{
if (filter == null)
{
return(new List <RepairTicket>());
}
IQueryable <RepairTicketDAO> RepairTicketDAOs = DataContext.RepairTicket.AsNoTracking();
RepairTicketDAOs = DynamicFilter(RepairTicketDAOs, filter);
RepairTicketDAOs = DynamicOrder(RepairTicketDAOs, filter);
List <RepairTicket> RepairTickets = await DynamicSelect(RepairTicketDAOs, filter);
return(RepairTickets);
}
public async Task <List <RepairTicket> > List(RepairTicketFilter RepairTicketFilter)
{
try
{
List <RepairTicket> RepairTickets = await UOW.RepairTicketRepository.List(RepairTicketFilter);
var RetailIds = RepairTickets.Where(x => x.OrderCategoryId == OrderCategoryEnum.ORDER_CUSTOMER.Id).Select(x => x.OrderId).ToList();
var DirectIds = RepairTickets.Where(x => x.OrderCategoryId == OrderCategoryEnum.ORDER_DIRECT.Id).Select(x => x.OrderId).ToList();
List <CustomerSalesOrder> CustomerSalesOrders = await UOW.CustomerSalesOrderRepository.List(new CustomerSalesOrderFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CustomerSalesOrderSelect.Id | CustomerSalesOrderSelect.Code,
Id = new IdFilter {
In = RetailIds
}
});
List <DirectSalesOrder> DirectSalesOrders = await UOW.DirectSalesOrderRepository.List(new DirectSalesOrderFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = DirectSalesOrderSelect.Id | DirectSalesOrderSelect.Code,
Id = new IdFilter {
In = DirectIds
}
});
foreach (var RepairTicket in RepairTickets)
{
if (RepairTicket.OrderCategoryId == OrderCategoryEnum.ORDER_CUSTOMER.Id)
{
RepairTicket.CustomerSalesOrder = CustomerSalesOrders.Where(x => x.Id == RepairTicket.OrderId).FirstOrDefault();
}
if (RepairTicket.OrderCategoryId == OrderCategoryEnum.ORDER_DIRECT.Id)
{
RepairTicket.DirectSalesOrder = DirectSalesOrders.Where(x => x.Id == RepairTicket.OrderId).FirstOrDefault();
}
}
return(RepairTickets);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(RepairTicketService));
}
return(null);
}
public async Task <int> Count(RepairTicketFilter RepairTicketFilter)
{
try
{
int result = await UOW.RepairTicketRepository.Count(RepairTicketFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(RepairTicketService));
}
return(0);
}
private async Task <bool> ValidateCode(RepairTicket RepairTicket)
{
if (string.IsNullOrWhiteSpace(RepairTicket.Code))
{
RepairTicket.AddError(nameof(RepairTicketValidator), nameof(RepairTicket.Code), ErrorCode.CodeEmpty);
}
else
{
var Code = RepairTicket.Code;
if (RepairTicket.Code.Contains(" ") || !FilterExtension.ChangeToEnglishChar(Code).Equals(RepairTicket.Code))
{
RepairTicket.AddError(nameof(RepairTicketValidator), nameof(RepairTicket.Code), ErrorCode.CodeHasSpecialCharacter);
}
else
{
if (RepairTicket.Code.Length > 255)
{
RepairTicket.AddError(nameof(RepairTicketValidator), nameof(RepairTicket.Code), ErrorCode.CodeOverLength);
}
else
{
RepairTicketFilter RepairTicketFilter = new RepairTicketFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = RepairTicket.Id
},
Code = new StringFilter {
Equal = RepairTicket.Code
},
Selects = RepairTicketSelect.Code
};
int count = await UOW.RepairTicketRepository.Count(RepairTicketFilter);
if (count != 0)
{
RepairTicket.AddError(nameof(RepairTicketValidator), nameof(RepairTicket.Code), ErrorCode.CodeExisted);
}
}
}
}
return(RepairTicket.IsValidated);
}
public async Task <ActionResult <int> > CountRepairTicket([FromBody] Customer_RepairTicketFilterDTO Customer_RepairTicketFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
RepairTicketFilter RepairTicketFilter = ConvertFilterRepairTicket(Customer_RepairTicketFilterDTO);
RepairTicketFilter = await RepairTicketService.ToFilter(RepairTicketFilter);
int count = await RepairTicketService.Count(RepairTicketFilter);
return(count);
}
public async Task <bool> ValidateId(RepairTicket RepairTicket)
{
RepairTicketFilter RepairTicketFilter = new RepairTicketFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = RepairTicket.Id
},
Selects = RepairTicketSelect.Id
};
int count = await UOW.RepairTicketRepository.Count(RepairTicketFilter);
if (count == 0)
{
RepairTicket.AddError(nameof(RepairTicketValidator), nameof(RepairTicket.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <ActionResult <List <Customer_RepairTicketDTO> > > ListRepairTicket([FromBody] Customer_RepairTicketFilterDTO Customer_RepairTicketFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
RepairTicketFilter RepairTicketFilter = ConvertFilterRepairTicket(Customer_RepairTicketFilterDTO);
RepairTicketFilter = await RepairTicketService.ToFilter(RepairTicketFilter);
List <RepairTicket> RepairTickets = await RepairTicketService.List(RepairTicketFilter);
List <Customer_RepairTicketDTO> Customer_RepairTicketDTOs = RepairTickets
.Select(c => new Customer_RepairTicketDTO(c)).ToList();
return(Customer_RepairTicketDTOs);
}
private async Task <bool> HasPermission(long Id)
{
RepairTicketFilter RepairTicketFilter = new RepairTicketFilter();
RepairTicketFilter = await RepairTicketService.ToFilter(RepairTicketFilter);
if (Id == 0)
{
}
else
{
RepairTicketFilter.Id = new IdFilter {
Equal = Id
};
int count = await RepairTicketService.Count(RepairTicketFilter);
if (count == 0)
{
return(false);
}
}
return(true);
}
private async Task <List <RepairTicket> > DynamicSelect(IQueryable <RepairTicketDAO> query, RepairTicketFilter filter)
{
List <RepairTicket> RepairTickets = await query.Select(q => new RepairTicket()
{
Id = filter.Selects.Contains(RepairTicketSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(RepairTicketSelect.Code) ? q.Code : default(string),
DeviceSerial = filter.Selects.Contains(RepairTicketSelect.DeviceSerial) ? q.DeviceSerial : default(string),
OrderId = filter.Selects.Contains(RepairTicketSelect.Order) ? q.OrderId : default(long),
OrderCategoryId = filter.Selects.Contains(RepairTicketSelect.OrderCategory) ? q.OrderCategoryId : default(long),
RepairDueDate = filter.Selects.Contains(RepairTicketSelect.RepairDueDate) ? q.RepairDueDate : default(DateTime?),
ItemId = filter.Selects.Contains(RepairTicketSelect.Item) ? q.ItemId : default(long?),
IsRejectRepair = filter.Selects.Contains(RepairTicketSelect.IsRejectRepair) ? q.IsRejectRepair : default(bool?),
RejectReason = filter.Selects.Contains(RepairTicketSelect.RejectReason) ? q.RejectReason : default(string),
DeviceState = filter.Selects.Contains(RepairTicketSelect.DeviceState) ? q.DeviceState : default(string),
RepairStatusId = filter.Selects.Contains(RepairTicketSelect.RepairStatus) ? q.RepairStatusId : default(long?),
RepairAddess = filter.Selects.Contains(RepairTicketSelect.RepairAddess) ? q.RepairAddess : default(string),
ReceiveUser = filter.Selects.Contains(RepairTicketSelect.ReceiveUser) ? q.ReceiveUser : default(string),
ReceiveDate = filter.Selects.Contains(RepairTicketSelect.ReceiveDate) ? q.ReceiveDate : default(DateTime?),
RepairDate = filter.Selects.Contains(RepairTicketSelect.RepairDate) ? q.RepairDate : default(DateTime?),
ReturnDate = filter.Selects.Contains(RepairTicketSelect.ReturnDate) ? q.ReturnDate : default(DateTime?),
RepairSolution = filter.Selects.Contains(RepairTicketSelect.RepairSolution) ? q.RepairSolution : default(string),
Note = filter.Selects.Contains(RepairTicketSelect.Note) ? q.Note : default(string),
RepairCost = filter.Selects.Contains(RepairTicketSelect.RepairCost) ? q.RepairCost : default(decimal?),
PaymentStatusId = filter.Selects.Contains(RepairTicketSelect.PaymentStatus) ? q.PaymentStatusId : default(long?),
CustomerId = filter.Selects.Contains(RepairTicketSelect.Customer) ? q.CustomerId : default(long),
CreatorId = filter.Selects.Contains(RepairTicketSelect.Creator) ? q.CreatorId : default(long),
Creator = filter.Selects.Contains(RepairTicketSelect.Creator) && q.Creator != null ? new AppUser
{
Id = q.Creator.Id,
Username = q.Creator.Username,
DisplayName = q.Creator.DisplayName,
Address = q.Creator.Address,
Email = q.Creator.Email,
Phone = q.Creator.Phone,
SexId = q.Creator.SexId,
Birthday = q.Creator.Birthday,
Avatar = q.Creator.Avatar,
Department = q.Creator.Department,
OrganizationId = q.Creator.OrganizationId,
Longitude = q.Creator.Longitude,
Latitude = q.Creator.Latitude,
StatusId = q.Creator.StatusId,
RowId = q.Creator.RowId,
Used = q.Creator.Used,
} : null,
Customer = filter.Selects.Contains(RepairTicketSelect.Customer) && q.Customer != null ? new Customer
{
Id = q.Customer.Id,
Code = q.Customer.Code,
Name = q.Customer.Name,
Phone = q.Customer.Phone,
Email = q.Customer.Email,
Address = q.Customer.Address,
StatusId = q.Customer.StatusId,
NationId = q.Customer.NationId,
ProvinceId = q.Customer.ProvinceId,
DistrictId = q.Customer.DistrictId,
WardId = q.Customer.WardId,
ProfessionId = q.Customer.ProfessionId,
Used = q.Customer.Used,
} : null,
Item = filter.Selects.Contains(RepairTicketSelect.Item) && q.Item != null ? new Item
{
Id = q.Item.Id,
ProductId = q.Item.ProductId,
Code = q.Item.Code,
Name = q.Item.Name,
ScanCode = q.Item.ScanCode,
SalePrice = q.Item.SalePrice,
RetailPrice = q.Item.RetailPrice,
StatusId = q.Item.StatusId,
Used = q.Item.Used,
RowId = q.Item.RowId,
} : null,
OrderCategory = filter.Selects.Contains(RepairTicketSelect.OrderCategory) && q.OrderCategory != null ? new OrderCategory
{
Id = q.OrderCategory.Id,
Code = q.OrderCategory.Code,
Name = q.OrderCategory.Name,
} : null,
PaymentStatus = filter.Selects.Contains(RepairTicketSelect.PaymentStatus) && q.PaymentStatus != null ? new PaymentStatus
{
Id = q.PaymentStatus.Id,
Code = q.PaymentStatus.Code,
Name = q.PaymentStatus.Name,
} : null,
RepairStatus = filter.Selects.Contains(RepairTicketSelect.RepairStatus) && q.RepairStatus != null ? new RepairStatus
{
Id = q.RepairStatus.Id,
Name = q.RepairStatus.Name,
Code = q.RepairStatus.Code,
} : null,
}).ToListAsync();
return(RepairTickets);
}
private IQueryable <RepairTicketDAO> DynamicFilter(IQueryable <RepairTicketDAO> query, RepairTicketFilter 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.Code != null && filter.Code.HasValue)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.DeviceSerial != null && filter.DeviceSerial.HasValue)
{
query = query.Where(q => q.DeviceSerial, filter.DeviceSerial);
}
if (filter.OrderId != null && filter.OrderId.HasValue)
{
query = query.Where(q => q.OrderId, filter.OrderId);
}
if (filter.OrderCategoryId != null && filter.OrderCategoryId.HasValue)
{
query = query.Where(q => q.OrderCategoryId, filter.OrderCategoryId);
}
if (filter.RepairDueDate != null && filter.RepairDueDate.HasValue)
{
query = query.Where(q => q.RepairDueDate == null).Union(query.Where(q => q.RepairDueDate.HasValue).Where(q => q.RepairDueDate, filter.RepairDueDate));
}
if (filter.ItemId != null && filter.ItemId.HasValue)
{
query = query.Where(q => q.ItemId.HasValue).Where(q => q.ItemId, filter.ItemId);
}
if (filter.RejectReason != null && filter.RejectReason.HasValue)
{
query = query.Where(q => q.RejectReason, filter.RejectReason);
}
if (filter.DeviceState != null && filter.DeviceState.HasValue)
{
query = query.Where(q => q.DeviceState, filter.DeviceState);
}
if (filter.RepairStatusId != null && filter.RepairStatusId.HasValue)
{
query = query.Where(q => q.RepairStatusId.HasValue).Where(q => q.RepairStatusId, filter.RepairStatusId);
}
if (filter.RepairAddess != null && filter.RepairAddess.HasValue)
{
query = query.Where(q => q.RepairAddess, filter.RepairAddess);
}
if (filter.ReceiveUser != null && filter.ReceiveUser.HasValue)
{
query = query.Where(q => q.ReceiveUser, filter.ReceiveUser);
}
if (filter.ReceiveDate != null && filter.ReceiveDate.HasValue)
{
query = query.Where(q => q.ReceiveDate == null).Union(query.Where(q => q.ReceiveDate.HasValue).Where(q => q.ReceiveDate, filter.ReceiveDate));
}
if (filter.RepairDate != null && filter.RepairDate.HasValue)
{
query = query.Where(q => q.RepairDate == null).Union(query.Where(q => q.RepairDate.HasValue).Where(q => q.RepairDate, filter.RepairDate));
}
if (filter.ReturnDate != null && filter.ReturnDate.HasValue)
{
query = query.Where(q => q.ReturnDate == null).Union(query.Where(q => q.ReturnDate.HasValue).Where(q => q.ReturnDate, filter.ReturnDate));
}
if (filter.RepairSolution != null && filter.RepairSolution.HasValue)
{
query = query.Where(q => q.RepairSolution, filter.RepairSolution);
}
if (filter.Note != null && filter.Note.HasValue)
{
query = query.Where(q => q.Note, filter.Note);
}
if (filter.RepairCost != null && filter.RepairCost.HasValue)
{
query = query.Where(q => q.RepairCost.HasValue).Where(q => q.RepairCost, filter.RepairCost);
}
if (filter.PaymentStatusId != null && filter.PaymentStatusId.HasValue)
{
query = query.Where(q => q.PaymentStatusId.HasValue).Where(q => q.PaymentStatusId, filter.PaymentStatusId);
}
if (filter.CustomerId != null && filter.CustomerId.HasValue)
{
query = query.Where(q => q.CustomerId, filter.CustomerId);
}
if (filter.CreatorId != null && filter.CreatorId.HasValue)
{
query = query.Where(q => q.CreatorId, filter.CreatorId);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <RepairTicketDAO> DynamicOrder(IQueryable <RepairTicketDAO> query, RepairTicketFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case RepairTicketOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case RepairTicketOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case RepairTicketOrder.DeviceSerial:
query = query.OrderBy(q => q.DeviceSerial);
break;
case RepairTicketOrder.Order:
query = query.OrderBy(q => q.OrderId);
break;
case RepairTicketOrder.OrderCategory:
query = query.OrderBy(q => q.OrderCategoryId);
break;
case RepairTicketOrder.RepairDueDate:
query = query.OrderBy(q => q.RepairDueDate);
break;
case RepairTicketOrder.Item:
query = query.OrderBy(q => q.ItemId);
break;
case RepairTicketOrder.IsRejectRepair:
query = query.OrderBy(q => q.IsRejectRepair);
break;
case RepairTicketOrder.RejectReason:
query = query.OrderBy(q => q.RejectReason);
break;
case RepairTicketOrder.DeviceState:
query = query.OrderBy(q => q.DeviceState);
break;
case RepairTicketOrder.RepairStatus:
query = query.OrderBy(q => q.RepairStatusId);
break;
case RepairTicketOrder.RepairAddess:
query = query.OrderBy(q => q.RepairAddess);
break;
case RepairTicketOrder.ReceiveUser:
query = query.OrderBy(q => q.ReceiveUser);
break;
case RepairTicketOrder.ReceiveDate:
query = query.OrderBy(q => q.ReceiveDate);
break;
case RepairTicketOrder.RepairDate:
query = query.OrderBy(q => q.RepairDate);
break;
case RepairTicketOrder.ReturnDate:
query = query.OrderBy(q => q.ReturnDate);
break;
case RepairTicketOrder.RepairSolution:
query = query.OrderBy(q => q.RepairSolution);
break;
case RepairTicketOrder.Note:
query = query.OrderBy(q => q.Note);
break;
case RepairTicketOrder.RepairCost:
query = query.OrderBy(q => q.RepairCost);
break;
case RepairTicketOrder.PaymentStatus:
query = query.OrderBy(q => q.PaymentStatusId);
break;
case RepairTicketOrder.Customer:
query = query.OrderBy(q => q.CustomerId);
break;
case RepairTicketOrder.Creator:
query = query.OrderBy(q => q.CreatorId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case RepairTicketOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case RepairTicketOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case RepairTicketOrder.DeviceSerial:
query = query.OrderByDescending(q => q.DeviceSerial);
break;
case RepairTicketOrder.Order:
query = query.OrderByDescending(q => q.OrderId);
break;
case RepairTicketOrder.OrderCategory:
query = query.OrderByDescending(q => q.OrderCategoryId);
break;
case RepairTicketOrder.RepairDueDate:
query = query.OrderByDescending(q => q.RepairDueDate);
break;
case RepairTicketOrder.Item:
query = query.OrderByDescending(q => q.ItemId);
break;
case RepairTicketOrder.IsRejectRepair:
query = query.OrderByDescending(q => q.IsRejectRepair);
break;
case RepairTicketOrder.RejectReason:
query = query.OrderByDescending(q => q.RejectReason);
break;
case RepairTicketOrder.DeviceState:
query = query.OrderByDescending(q => q.DeviceState);
break;
case RepairTicketOrder.RepairStatus:
query = query.OrderByDescending(q => q.RepairStatusId);
break;
case RepairTicketOrder.RepairAddess:
query = query.OrderByDescending(q => q.RepairAddess);
break;
case RepairTicketOrder.ReceiveUser:
query = query.OrderByDescending(q => q.ReceiveUser);
break;
case RepairTicketOrder.ReceiveDate:
query = query.OrderByDescending(q => q.ReceiveDate);
break;
case RepairTicketOrder.RepairDate:
query = query.OrderByDescending(q => q.RepairDate);
break;
case RepairTicketOrder.ReturnDate:
query = query.OrderByDescending(q => q.ReturnDate);
break;
case RepairTicketOrder.RepairSolution:
query = query.OrderByDescending(q => q.RepairSolution);
break;
case RepairTicketOrder.Note:
query = query.OrderByDescending(q => q.Note);
break;
case RepairTicketOrder.RepairCost:
query = query.OrderByDescending(q => q.RepairCost);
break;
case RepairTicketOrder.PaymentStatus:
query = query.OrderByDescending(q => q.PaymentStatusId);
break;
case RepairTicketOrder.Customer:
query = query.OrderByDescending(q => q.CustomerId);
break;
case RepairTicketOrder.Creator:
query = query.OrderByDescending(q => q.CreatorId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <RepairTicketDAO> OrFilter(IQueryable <RepairTicketDAO> query, RepairTicketFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <RepairTicketDAO> initQuery = query.Where(q => false);
foreach (RepairTicketFilter RepairTicketFilter in filter.OrFilter)
{
IQueryable <RepairTicketDAO> queryable = query;
if (RepairTicketFilter.Id != null && RepairTicketFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, RepairTicketFilter.Id);
}
if (RepairTicketFilter.Code != null && RepairTicketFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, RepairTicketFilter.Code);
}
if (RepairTicketFilter.DeviceSerial != null && RepairTicketFilter.DeviceSerial.HasValue)
{
queryable = queryable.Where(q => q.DeviceSerial, RepairTicketFilter.DeviceSerial);
}
if (RepairTicketFilter.OrderId != null && RepairTicketFilter.OrderId.HasValue)
{
queryable = queryable.Where(q => q.OrderId, RepairTicketFilter.OrderId);
}
if (RepairTicketFilter.OrderCategoryId != null && RepairTicketFilter.OrderCategoryId.HasValue)
{
queryable = queryable.Where(q => q.OrderCategoryId, RepairTicketFilter.OrderCategoryId);
}
if (RepairTicketFilter.RepairDueDate != null && RepairTicketFilter.RepairDueDate.HasValue)
{
queryable = queryable.Where(q => q.RepairDueDate.HasValue).Where(q => q.RepairDueDate, RepairTicketFilter.RepairDueDate);
}
if (RepairTicketFilter.ItemId != null && RepairTicketFilter.ItemId.HasValue)
{
queryable = queryable.Where(q => q.ItemId.HasValue).Where(q => q.ItemId, RepairTicketFilter.ItemId);
}
if (RepairTicketFilter.RejectReason != null && RepairTicketFilter.RejectReason.HasValue)
{
queryable = queryable.Where(q => q.RejectReason, RepairTicketFilter.RejectReason);
}
if (RepairTicketFilter.DeviceState != null && RepairTicketFilter.DeviceState.HasValue)
{
queryable = queryable.Where(q => q.DeviceState, RepairTicketFilter.DeviceState);
}
if (RepairTicketFilter.RepairStatusId != null && RepairTicketFilter.RepairStatusId.HasValue)
{
queryable = queryable.Where(q => q.RepairStatusId.HasValue).Where(q => q.RepairStatusId, RepairTicketFilter.RepairStatusId);
}
if (RepairTicketFilter.RepairAddess != null && RepairTicketFilter.RepairAddess.HasValue)
{
queryable = queryable.Where(q => q.RepairAddess, RepairTicketFilter.RepairAddess);
}
if (RepairTicketFilter.ReceiveUser != null && RepairTicketFilter.ReceiveUser.HasValue)
{
queryable = queryable.Where(q => q.ReceiveUser, RepairTicketFilter.ReceiveUser);
}
if (RepairTicketFilter.ReceiveDate != null && RepairTicketFilter.ReceiveDate.HasValue)
{
queryable = queryable.Where(q => q.ReceiveDate.HasValue).Where(q => q.ReceiveDate, RepairTicketFilter.ReceiveDate);
}
if (RepairTicketFilter.RepairDate != null && RepairTicketFilter.RepairDate.HasValue)
{
queryable = queryable.Where(q => q.RepairDate.HasValue).Where(q => q.RepairDate, RepairTicketFilter.RepairDate);
}
if (RepairTicketFilter.ReturnDate != null && RepairTicketFilter.ReturnDate.HasValue)
{
queryable = queryable.Where(q => q.ReturnDate.HasValue).Where(q => q.ReturnDate, RepairTicketFilter.ReturnDate);
}
if (RepairTicketFilter.RepairSolution != null && RepairTicketFilter.RepairSolution.HasValue)
{
queryable = queryable.Where(q => q.RepairSolution, RepairTicketFilter.RepairSolution);
}
if (RepairTicketFilter.Note != null && RepairTicketFilter.Note.HasValue)
{
queryable = queryable.Where(q => q.Note, RepairTicketFilter.Note);
}
if (RepairTicketFilter.RepairCost != null && RepairTicketFilter.RepairCost.HasValue)
{
queryable = queryable.Where(q => q.RepairCost.HasValue).Where(q => q.RepairCost, RepairTicketFilter.RepairCost);
}
if (RepairTicketFilter.PaymentStatusId != null && RepairTicketFilter.PaymentStatusId.HasValue)
{
queryable = queryable.Where(q => q.PaymentStatusId.HasValue).Where(q => q.PaymentStatusId, RepairTicketFilter.PaymentStatusId);
}
if (RepairTicketFilter.CustomerId != null && RepairTicketFilter.CustomerId.HasValue)
{
queryable = queryable.Where(q => q.CustomerId, RepairTicketFilter.CustomerId);
}
if (RepairTicketFilter.CreatorId != null && RepairTicketFilter.CreatorId.HasValue)
{
queryable = queryable.Where(q => q.CreatorId, RepairTicketFilter.CreatorId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <RepairTicketFilter> ToFilter(RepairTicketFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <RepairTicketFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
foreach (var currentFilter in CurrentContext.Filters)
{
RepairTicketFilter subFilter = new RepairTicketFilter();
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.OrderId))
{
subFilter.OrderId = FilterBuilder.Merge(subFilter.OrderId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.OrderCategoryId))
{
subFilter.OrderCategoryId = FilterBuilder.Merge(subFilter.OrderCategoryId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairDueDate))
{
subFilter.RepairDueDate = FilterBuilder.Merge(subFilter.RepairDueDate, FilterPermissionDefinition.DateFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ItemId))
{
subFilter.ItemId = FilterBuilder.Merge(subFilter.ItemId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RejectReason))
{
subFilter.RejectReason = FilterBuilder.Merge(subFilter.RejectReason, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.DeviceState))
{
subFilter.DeviceState = FilterBuilder.Merge(subFilter.DeviceState, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairStatusId))
{
subFilter.RepairStatusId = FilterBuilder.Merge(subFilter.RepairStatusId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairAddess))
{
subFilter.RepairAddess = FilterBuilder.Merge(subFilter.RepairAddess, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ReceiveUser))
{
subFilter.ReceiveUser = FilterBuilder.Merge(subFilter.ReceiveUser, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ReceiveDate))
{
subFilter.ReceiveDate = FilterBuilder.Merge(subFilter.ReceiveDate, FilterPermissionDefinition.DateFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairDate))
{
subFilter.RepairDate = FilterBuilder.Merge(subFilter.RepairDate, FilterPermissionDefinition.DateFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.ReturnDate))
{
subFilter.ReturnDate = FilterBuilder.Merge(subFilter.ReturnDate, FilterPermissionDefinition.DateFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairSolution))
{
subFilter.RepairSolution = FilterBuilder.Merge(subFilter.RepairSolution, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.Note))
{
subFilter.Note = FilterBuilder.Merge(subFilter.Note, FilterPermissionDefinition.StringFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.RepairCost))
{
subFilter.RepairCost = FilterBuilder.Merge(subFilter.RepairCost, FilterPermissionDefinition.DecimalFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.PaymentStatusId))
{
subFilter.PaymentStatusId = FilterBuilder.Merge(subFilter.PaymentStatusId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.CustomerId))
{
subFilter.CustomerId = FilterBuilder.Merge(subFilter.CustomerId, FilterPermissionDefinition.IdFilter);
}
if (FilterPermissionDefinition.Name == nameof(subFilter.CreatorId))
{
subFilter.CreatorId = FilterBuilder.Merge(subFilter.CreatorId, 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);
}
