public async Task <int> Count(CustomerFeedbackTypeFilter filter)
{
IQueryable <CustomerFeedbackTypeDAO> CustomerFeedbackTypes = DataContext.CustomerFeedbackType.AsNoTracking();
CustomerFeedbackTypes = DynamicFilter(CustomerFeedbackTypes, filter);
return(await CustomerFeedbackTypes.CountAsync());
}
public async Task <ActionResult <List <CustomerFeedback_CustomerFeedbackTypeDTO> > > FilterListCustomerFeedbackType([FromBody] CustomerFeedback_CustomerFeedbackTypeFilterDTO CustomerFeedback_CustomerFeedbackTypeFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CustomerFeedbackTypeFilter CustomerFeedbackTypeFilter = new CustomerFeedbackTypeFilter();
CustomerFeedbackTypeFilter.Skip = 0;
CustomerFeedbackTypeFilter.Take = int.MaxValue;
CustomerFeedbackTypeFilter.Take = 20;
CustomerFeedbackTypeFilter.OrderBy = CustomerFeedbackTypeOrder.Id;
CustomerFeedbackTypeFilter.OrderType = OrderType.ASC;
CustomerFeedbackTypeFilter.Selects = CustomerFeedbackTypeSelect.ALL;
List <CustomerFeedbackType> CustomerFeedbackTypes = await CustomerFeedbackTypeService.List(CustomerFeedbackTypeFilter);
List <CustomerFeedback_CustomerFeedbackTypeDTO> CustomerFeedback_CustomerFeedbackTypeDTOs = CustomerFeedbackTypes
.Select(x => new CustomerFeedback_CustomerFeedbackTypeDTO(x)).ToList();
return(CustomerFeedback_CustomerFeedbackTypeDTOs);
}
public async Task <List <CustomerFeedbackType> > List(CustomerFeedbackTypeFilter CustomerFeedbackTypeFilter)
{
try
{
List <CustomerFeedbackType> CustomerFeedbackTypes = await UOW.CustomerFeedbackTypeRepository.List(CustomerFeedbackTypeFilter);
return(CustomerFeedbackTypes);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerFeedbackTypeService));
}
return(null);
}
public async Task <int> Count(CustomerFeedbackTypeFilter CustomerFeedbackTypeFilter)
{
try
{
int result = await UOW.CustomerFeedbackTypeRepository.Count(CustomerFeedbackTypeFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerFeedbackTypeService));
}
return(0);
}
public async Task <List <CustomerFeedbackType> > List(CustomerFeedbackTypeFilter filter)
{
if (filter == null)
{
return(new List <CustomerFeedbackType>());
}
IQueryable <CustomerFeedbackTypeDAO> CustomerFeedbackTypeDAOs = DataContext.CustomerFeedbackType.AsNoTracking();
CustomerFeedbackTypeDAOs = DynamicFilter(CustomerFeedbackTypeDAOs, filter);
CustomerFeedbackTypeDAOs = DynamicOrder(CustomerFeedbackTypeDAOs, filter);
List <CustomerFeedbackType> CustomerFeedbackTypes = await DynamicSelect(CustomerFeedbackTypeDAOs, filter);
return(CustomerFeedbackTypes);
}
public async Task <ActionResult> Export([FromBody] CustomerFeedback_CustomerFeedbackFilterDTO CustomerFeedback_CustomerFeedbackFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
MemoryStream memoryStream = new MemoryStream();
using (ExcelPackage excel = new ExcelPackage(memoryStream))
{
#region CustomerFeedback
var CustomerFeedbackFilter = ConvertFilterDTOToFilterEntity(CustomerFeedback_CustomerFeedbackFilterDTO);
CustomerFeedbackFilter.Skip = 0;
CustomerFeedbackFilter.Take = int.MaxValue;
CustomerFeedbackFilter = await CustomerFeedbackService.ToFilter(CustomerFeedbackFilter);
List <CustomerFeedback> CustomerFeedbacks = await CustomerFeedbackService.List(CustomerFeedbackFilter);
var CustomerFeedbackHeaders = new List <string[]>()
{
new string[] {
"Id",
"IsSystemCustomer",
"CustomerId",
"FullName",
"Email",
"PhoneNumber",
"CustomerFeedbackTypeId",
"Title",
"SendDate",
"Content",
"StatusId",
}
};
List <object[]> CustomerFeedbackData = new List <object[]>();
for (int i = 0; i < CustomerFeedbacks.Count; i++)
{
var CustomerFeedback = CustomerFeedbacks[i];
CustomerFeedbackData.Add(new Object[]
{
CustomerFeedback.Id,
CustomerFeedback.IsSystemCustomer,
CustomerFeedback.CustomerId,
CustomerFeedback.FullName,
CustomerFeedback.Email,
CustomerFeedback.PhoneNumber,
CustomerFeedback.CustomerFeedbackTypeId,
CustomerFeedback.Title,
CustomerFeedback.SendDate,
CustomerFeedback.Content,
CustomerFeedback.StatusId,
});
}
excel.GenerateWorksheet("CustomerFeedback", CustomerFeedbackHeaders, CustomerFeedbackData);
#endregion
#region Customer
var CustomerFilter = new CustomerFilter();
CustomerFilter.Selects = CustomerSelect.ALL;
CustomerFilter.OrderBy = CustomerOrder.Id;
CustomerFilter.OrderType = OrderType.ASC;
CustomerFilter.Skip = 0;
CustomerFilter.Take = int.MaxValue;
List <Customer> Customers = await CustomerService.List(CustomerFilter);
var CustomerHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
"Phone",
"Address",
"NationId",
"ProvinceId",
"DistrictId",
"WardId",
"CustomerTypeId",
"Birthday",
"Email",
"ProfessionId",
"CustomerResourceId",
"SexId",
"StatusId",
"CompanyId",
"ParentCompanyId",
"TaxCode",
"Fax",
"Website",
"NumberOfEmployee",
"BusinessTypeId",
"Investment",
"RevenueAnnual",
"IsSupplier",
"Descreption",
"Used",
"RowId",
}
};
List <object[]> CustomerData = new List <object[]>();
for (int i = 0; i < Customers.Count; i++)
{
var Customer = Customers[i];
CustomerData.Add(new Object[]
{
Customer.Id,
Customer.Code,
Customer.Name,
Customer.Phone,
Customer.Address,
Customer.NationId,
Customer.ProvinceId,
Customer.DistrictId,
Customer.WardId,
Customer.CustomerTypeId,
Customer.Birthday,
Customer.Email,
Customer.ProfessionId,
Customer.CustomerResourceId,
Customer.SexId,
Customer.StatusId,
Customer.CompanyId,
Customer.ParentCompanyId,
Customer.TaxCode,
Customer.Fax,
Customer.Website,
Customer.NumberOfEmployee,
Customer.BusinessTypeId,
Customer.Investment,
Customer.RevenueAnnual,
Customer.IsSupplier,
Customer.Descreption,
Customer.Used,
Customer.RowId,
});
}
excel.GenerateWorksheet("Customer", CustomerHeaders, CustomerData);
#endregion
#region CustomerFeedbackType
var CustomerFeedbackTypeFilter = new CustomerFeedbackTypeFilter();
CustomerFeedbackTypeFilter.Selects = CustomerFeedbackTypeSelect.ALL;
CustomerFeedbackTypeFilter.OrderBy = CustomerFeedbackTypeOrder.Id;
CustomerFeedbackTypeFilter.OrderType = OrderType.ASC;
CustomerFeedbackTypeFilter.Skip = 0;
CustomerFeedbackTypeFilter.Take = int.MaxValue;
List <CustomerFeedbackType> CustomerFeedbackTypes = await CustomerFeedbackTypeService.List(CustomerFeedbackTypeFilter);
var CustomerFeedbackTypeHeaders = new List <string[]>()
{
new string[] {
"Id",
"Code",
"Name",
}
};
List <object[]> CustomerFeedbackTypeData = new List <object[]>();
for (int i = 0; i < CustomerFeedbackTypes.Count; i++)
{
var CustomerFeedbackType = CustomerFeedbackTypes[i];
CustomerFeedbackTypeData.Add(new Object[]
{
CustomerFeedbackType.Id,
CustomerFeedbackType.Code,
CustomerFeedbackType.Name,
});
}
excel.GenerateWorksheet("CustomerFeedbackType", CustomerFeedbackTypeHeaders, CustomerFeedbackTypeData);
#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
excel.Save();
}
return(File(memoryStream.ToArray(), "application/octet-stream", "CustomerFeedback.xlsx"));
}
public async Task <ActionResult> Import(IFormFile file)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CustomerFilter CustomerFilter = new CustomerFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CustomerSelect.ALL
};
List <Customer> Customers = await CustomerService.List(CustomerFilter);
CustomerFeedbackTypeFilter CustomerFeedbackTypeFilter = new CustomerFeedbackTypeFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = CustomerFeedbackTypeSelect.ALL
};
List <CustomerFeedbackType> CustomerFeedbackTypes = await CustomerFeedbackTypeService.List(CustomerFeedbackTypeFilter);
StatusFilter StatusFilter = new StatusFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = StatusSelect.ALL
};
List <Status> Statuses = await StatusService.List(StatusFilter);
List <CustomerFeedback> CustomerFeedbacks = new List <CustomerFeedback>();
using (ExcelPackage excelPackage = new ExcelPackage(file.OpenReadStream()))
{
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.FirstOrDefault();
if (worksheet == null)
{
return(Ok(CustomerFeedbacks));
}
int StartColumn = 1;
int StartRow = 1;
int IdColumn = 0 + StartColumn;
int IsSystemCustomerColumn = 1 + StartColumn;
int CustomerIdColumn = 2 + StartColumn;
int FullNameColumn = 3 + StartColumn;
int EmailColumn = 4 + StartColumn;
int PhoneNumberColumn = 5 + StartColumn;
int CustomerFeedbackTypeIdColumn = 6 + StartColumn;
int TitleColumn = 7 + StartColumn;
int SendDateColumn = 8 + StartColumn;
int ContentColumn = 9 + StartColumn;
int StatusIdColumn = 10 + 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 IsSystemCustomerValue = worksheet.Cells[i + StartRow, IsSystemCustomerColumn].Value?.ToString();
string CustomerIdValue = worksheet.Cells[i + StartRow, CustomerIdColumn].Value?.ToString();
string FullNameValue = worksheet.Cells[i + StartRow, FullNameColumn].Value?.ToString();
string EmailValue = worksheet.Cells[i + StartRow, EmailColumn].Value?.ToString();
string PhoneNumberValue = worksheet.Cells[i + StartRow, PhoneNumberColumn].Value?.ToString();
string CustomerFeedbackTypeIdValue = worksheet.Cells[i + StartRow, CustomerFeedbackTypeIdColumn].Value?.ToString();
string TitleValue = worksheet.Cells[i + StartRow, TitleColumn].Value?.ToString();
string SendDateValue = worksheet.Cells[i + StartRow, SendDateColumn].Value?.ToString();
string ContentValue = worksheet.Cells[i + StartRow, ContentColumn].Value?.ToString();
string StatusIdValue = worksheet.Cells[i + StartRow, StatusIdColumn].Value?.ToString();
CustomerFeedback CustomerFeedback = new CustomerFeedback();
CustomerFeedback.FullName = FullNameValue;
CustomerFeedback.Email = EmailValue;
CustomerFeedback.PhoneNumber = PhoneNumberValue;
CustomerFeedback.Title = TitleValue;
CustomerFeedback.SendDate = DateTime.TryParse(SendDateValue, out DateTime SendDate) ? SendDate : DateTime.Now;
CustomerFeedback.Content = ContentValue;
Customer Customer = Customers.Where(x => x.Id.ToString() == CustomerIdValue).FirstOrDefault();
CustomerFeedback.CustomerId = Customer == null ? 0 : Customer.Id;
CustomerFeedback.Customer = Customer;
CustomerFeedbackType CustomerFeedbackType = CustomerFeedbackTypes.Where(x => x.Id.ToString() == CustomerFeedbackTypeIdValue).FirstOrDefault();
CustomerFeedback.CustomerFeedbackTypeId = CustomerFeedbackType == null ? 0 : CustomerFeedbackType.Id;
CustomerFeedback.CustomerFeedbackType = CustomerFeedbackType;
Status Status = Statuses.Where(x => x.Id.ToString() == StatusIdValue).FirstOrDefault();
CustomerFeedback.StatusId = Status == null ? 0 : Status.Id;
CustomerFeedback.Status = Status;
CustomerFeedbacks.Add(CustomerFeedback);
}
}
CustomerFeedbacks = await CustomerFeedbackService.Import(CustomerFeedbacks);
if (CustomerFeedbacks.All(x => x.IsValidated))
{
return(Ok(true));
}
else
{
List <string> Errors = new List <string>();
for (int i = 0; i < CustomerFeedbacks.Count; i++)
{
CustomerFeedback CustomerFeedback = CustomerFeedbacks[i];
if (!CustomerFeedback.IsValidated)
{
string Error = $"Dòng {i + 2} có lỗi:";
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.Id)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.Id)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.IsSystemCustomer)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.IsSystemCustomer)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.CustomerId)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.CustomerId)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.FullName)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.FullName)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.Email)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.Email)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.PhoneNumber)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.PhoneNumber)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.CustomerFeedbackTypeId)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.CustomerFeedbackTypeId)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.Title)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.Title)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.SendDate)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.SendDate)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.Content)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.Content)];
}
if (CustomerFeedback.Errors.ContainsKey(nameof(CustomerFeedback.StatusId)))
{
Error += CustomerFeedback.Errors[nameof(CustomerFeedback.StatusId)];
}
Errors.Add(Error);
}
}
return(BadRequest(Errors));
}
}
private IQueryable <CustomerFeedbackTypeDAO> DynamicOrder(IQueryable <CustomerFeedbackTypeDAO> query, CustomerFeedbackTypeFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case CustomerFeedbackTypeOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case CustomerFeedbackTypeOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case CustomerFeedbackTypeOrder.Name:
query = query.OrderBy(q => q.Name);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case CustomerFeedbackTypeOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case CustomerFeedbackTypeOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case CustomerFeedbackTypeOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <CustomerFeedbackTypeDAO> OrFilter(IQueryable <CustomerFeedbackTypeDAO> query, CustomerFeedbackTypeFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <CustomerFeedbackTypeDAO> initQuery = query.Where(q => false);
foreach (CustomerFeedbackTypeFilter CustomerFeedbackTypeFilter in filter.OrFilter)
{
IQueryable <CustomerFeedbackTypeDAO> queryable = query;
if (CustomerFeedbackTypeFilter.Id != null && CustomerFeedbackTypeFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, CustomerFeedbackTypeFilter.Id);
}
if (CustomerFeedbackTypeFilter.Code != null && CustomerFeedbackTypeFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, CustomerFeedbackTypeFilter.Code);
}
if (CustomerFeedbackTypeFilter.Name != null && CustomerFeedbackTypeFilter.Name.HasValue)
{
queryable = queryable.Where(q => q.Name, CustomerFeedbackTypeFilter.Name);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
private IQueryable <CustomerFeedbackTypeDAO> DynamicFilter(IQueryable <CustomerFeedbackTypeDAO> query, CustomerFeedbackTypeFilter 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);
}
private async Task <List <CustomerFeedbackType> > DynamicSelect(IQueryable <CustomerFeedbackTypeDAO> query, CustomerFeedbackTypeFilter filter)
{
List <CustomerFeedbackType> CustomerFeedbackTypes = await query.Select(q => new CustomerFeedbackType()
{
Id = filter.Selects.Contains(CustomerFeedbackTypeSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(CustomerFeedbackTypeSelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(CustomerFeedbackTypeSelect.Name) ? q.Name : default(string),
}).ToListAsync();
return(CustomerFeedbackTypes);
}
