public async Task <List <Store_ProvinceDTO> > SingleListProvince([FromBody] Store_ProvinceFilterDTO Store_ProvinceFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ProvinceFilter ProvinceFilter = new ProvinceFilter();
ProvinceFilter.Skip = 0;
ProvinceFilter.Take = 20;
ProvinceFilter.OrderBy = ProvinceOrder.Id;
ProvinceFilter.OrderType = OrderType.ASC;
ProvinceFilter.Selects = ProvinceSelect.ALL;
ProvinceFilter.Id = Store_ProvinceFilterDTO.Id;
ProvinceFilter.Code = Store_ProvinceFilterDTO.Code;
ProvinceFilter.Name = Store_ProvinceFilterDTO.Name;
ProvinceFilter.Priority = Store_ProvinceFilterDTO.Priority;
ProvinceFilter.StatusId = Store_ProvinceFilterDTO.StatusId;
List <Province> Provinces = await ProvinceService.List(ProvinceFilter);
List <Store_ProvinceDTO> Store_ProvinceDTOs = Provinces
.Select(x => new Store_ProvinceDTO(x)).ToList();
return(Store_ProvinceDTOs);
}
public async Task <List <ProvinceDTO> > ListProvince([FromBody] ProvinceFilterDTO provinceFilterDTO)
{
ProvinceFilter provinceFilter = new ProvinceFilter
{
Code = new StringFilter {
StartWith = provinceFilterDTO.Code
},
Name = new StringFilter {
StartWith = provinceFilterDTO.Name
},
Skip = provinceFilterDTO.Skip,
Take = int.MaxValue,
OrderBy = ProvinceOrder.Name,
OrderType = OrderType.ASC
};
var listProvince = await ProvinceService.List(provinceFilter);
if (listProvince == null)
{
return(null);
}
return(listProvince.Select(p => new ProvinceDTO
{
Id = p.Id,
Code = p.Code,
Name = p.Name
}).ToList());
}
private IQueryable <ProvinceDAO> OrFilter(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <ProvinceDAO> initQuery = query.Where(q => false);
foreach (ProvinceFilter ProvinceFilter in filter.OrFilter)
{
IQueryable <ProvinceDAO> queryable = query;
if (ProvinceFilter.Id != null)
{
queryable = queryable.Where(q => q.Id, ProvinceFilter.Id);
}
if (ProvinceFilter.Name != null)
{
queryable = queryable.Where(q => q.Name, ProvinceFilter.Name);
}
if (ProvinceFilter.Priority != null)
{
queryable = queryable.Where(q => q.Priority, ProvinceFilter.Priority);
}
if (ProvinceFilter.StatusId != null)
{
queryable = queryable.Where(q => q.StatusId, ProvinceFilter.StatusId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <int> Count(ProvinceFilter provinceFilter)
{
IQueryable <ProvinceDAO> provinceDAOs = tFContext.Province;
provinceDAOs = DynamicFilter(provinceDAOs, provinceFilter);
return(await provinceDAOs.CountAsync());
}
public async Task <int> Count(ProvinceFilter filter)
{
IQueryable <ProvinceDAO> ProvinceDAOs = DataContext.Province;
ProvinceDAOs = DynamicFilter(ProvinceDAOs, filter);
return(await ProvinceDAOs.CountAsync());
}
public async Task <ActionResult <List <Contract_ProvinceDTO> > > SingleListProvince([FromBody] Contract_ProvinceFilterDTO Contract_ProvinceFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ProvinceFilter ProvinceFilter = new ProvinceFilter();
ProvinceFilter.Skip = 0;
ProvinceFilter.Take = 20;
ProvinceFilter.OrderBy = ProvinceOrder.Id;
ProvinceFilter.OrderType = OrderType.ASC;
ProvinceFilter.Selects = ProvinceSelect.ALL;
ProvinceFilter.Id = Contract_ProvinceFilterDTO.Id;
ProvinceFilter.Code = Contract_ProvinceFilterDTO.Code;
ProvinceFilter.Name = Contract_ProvinceFilterDTO.Name;
ProvinceFilter.Priority = Contract_ProvinceFilterDTO.Priority;
ProvinceFilter.StatusId = new IdFilter {
Equal = StatusEnum.ACTIVE.Id
};
List <Province> Provinces = await ProvinceService.List(ProvinceFilter);
List <Contract_ProvinceDTO> Contract_ProvinceDTOs = Provinces
.Select(x => new Contract_ProvinceDTO(x)).ToList();
return(Contract_ProvinceDTOs);
}
private async Task <bool> ValidateCode(Province Province)
{
if (string.IsNullOrEmpty(Province.Code))
{
Province.AddError(nameof(ProvinceValidator), nameof(Province.Code), ErrorCode.CodeEmpty);
return(false);
}
ProvinceFilter ProvinceFilter = new ProvinceFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
NotEqual = Province.Id
},
Code = new StringFilter {
Equal = Province.Code
},
Selects = ProvinceSelect.Code
};
int count = await UOW.ProvinceRepository.Count(ProvinceFilter);
if (count != 0)
{
Province.AddError(nameof(ProvinceValidator), nameof(Province.Code), ErrorCode.CodeExisted);
}
return(count == 0);
}
public async Task <List <DistrictDetail_ProvinceDTO> > SingleListProvince([FromBody] DistrictDetail_ProvinceFilterDTO DistrictDetail_ProvinceFilterDTO)
{
ProvinceFilter ProvinceFilter = new ProvinceFilter();
ProvinceFilter.Skip = 0;
ProvinceFilter.Take = 20;
ProvinceFilter.OrderBy = ProvinceOrder.Id;
ProvinceFilter.OrderType = OrderType.ASC;
ProvinceFilter.Selects = ProvinceSelect.ALL;
ProvinceFilter.Id = new LongFilter {
Equal = DistrictDetail_ProvinceFilterDTO.Id
};
ProvinceFilter.Name = new StringFilter {
StartsWith = DistrictDetail_ProvinceFilterDTO.Name
};
ProvinceFilter.OrderNumber = new LongFilter {
Equal = DistrictDetail_ProvinceFilterDTO.OrderNumber
};
List <Province> Provinces = await ProvinceService.List(ProvinceFilter);
List <DistrictDetail_ProvinceDTO> DistrictDetail_ProvinceDTOs = Provinces
.Select(x => new DistrictDetail_ProvinceDTO(x)).ToList();
return(DistrictDetail_ProvinceDTOs);
}
public async Task <int> Count([FromBody] ProvinceMaster_ProvinceFilterDTO ProvinceMaster_ProvinceFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
ProvinceFilter ProvinceFilter = ConvertFilterDTOToFilterEntity(ProvinceMaster_ProvinceFilterDTO);
return(await ProvinceService.Count(ProvinceFilter));
}
public async Task <List <ProvinceMaster_ProvinceDTO> > List([FromBody] ProvinceMaster_ProvinceFilterDTO ProvinceMaster_ProvinceFilterDTO)
{
if (!ModelState.IsValid)
{
throw new MessageException(ModelState);
}
ProvinceFilter ProvinceFilter = ConvertFilterDTOToFilterEntity(ProvinceMaster_ProvinceFilterDTO);
List <Province> Provinces = await ProvinceService.List(ProvinceFilter);
return(Provinces.Select(c => new ProvinceMaster_ProvinceDTO(c)).ToList());
}
public async Task <List <Province> > List(ProvinceFilter provinceFilter)
{
if (provinceFilter == null)
{
return(new List <Province>());
}
IQueryable <ProvinceDAO> provinceDAOs = tFContext.Province;
provinceDAOs = DynamicFilter(provinceDAOs, provinceFilter);
provinceDAOs = DynamicOrder(provinceDAOs, provinceFilter);
var provinces = await DynamicSelect(provinceDAOs);
return(provinces);
}
public async Task <List <Province> > List(ProvinceFilter filter)
{
if (filter == null)
{
return(new List <Province>());
}
IQueryable <ProvinceDAO> ProvinceDAOs = DataContext.Province;
ProvinceDAOs = DynamicFilter(ProvinceDAOs, filter);
ProvinceDAOs = DynamicOrder(ProvinceDAOs, filter);
var Provinces = await DynamicSelect(ProvinceDAOs, filter);
return(Provinces);
}
public ProvinceFilter ConvertFilterDTOToFilterEntity(ProvinceMaster_ProvinceFilterDTO ProvinceMaster_ProvinceFilterDTO)
{
ProvinceFilter ProvinceFilter = new ProvinceFilter();
ProvinceFilter.Selects = ProvinceSelect.ALL;
ProvinceFilter.Id = new LongFilter {
Equal = ProvinceMaster_ProvinceFilterDTO.Id
};
ProvinceFilter.Name = new StringFilter {
StartsWith = ProvinceMaster_ProvinceFilterDTO.Name
};
ProvinceFilter.OrderNumber = new LongFilter {
Equal = ProvinceMaster_ProvinceFilterDTO.OrderNumber
};
return(ProvinceFilter);
}
public async Task <DataFile> Export(ProvinceFilter ProvinceFilter)
{
List <Province> Provinces = await UOW.ProvinceRepository.List(ProvinceFilter);
MemoryStream MemoryStream = new MemoryStream();
using (ExcelPackage excelPackage = new ExcelPackage(MemoryStream))
{
//Set some properties of the Excel document
excelPackage.Workbook.Properties.Author = CurrentContext.UserName;
excelPackage.Workbook.Properties.Title = nameof(Province);
excelPackage.Workbook.Properties.Created = StaticParams.DateTimeNow;
//Create the WorkSheet
ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.Add("Sheet 1");
int StartColumn = 1;
int StartRow = 2;
int IdColumn = 0 + StartColumn;
int NameColumn = 1 + StartColumn;
int PriorityColumn = 2 + StartColumn;
int StatusIdColumn = 3 + StartColumn;
worksheet.Cells[1, IdColumn].Value = nameof(Province.Id);
worksheet.Cells[1, NameColumn].Value = nameof(Province.Name);
worksheet.Cells[1, PriorityColumn].Value = nameof(Province.Priority);
worksheet.Cells[1, StatusIdColumn].Value = nameof(Province.StatusId);
for (int i = 0; i < Provinces.Count; i++)
{
Province Province = Provinces[i];
worksheet.Cells[i + StartRow, IdColumn].Value = Province.Id;
worksheet.Cells[i + StartRow, NameColumn].Value = Province.Name;
worksheet.Cells[i + StartRow, PriorityColumn].Value = Province.Priority;
worksheet.Cells[i + StartRow, StatusIdColumn].Value = Province.StatusId;
}
excelPackage.Save();
}
DataFile DataFile = new DataFile
{
Name = nameof(Province),
Content = MemoryStream,
};
return(DataFile);
}
public async Task <bool> ValidateId(Province Province)
{
ProvinceFilter ProvinceFilter = new ProvinceFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Province.Id
},
Selects = ProvinceSelect.Id
};
int count = await UOW.ProvinceRepository.Count(ProvinceFilter);
if (count == 0)
{
Province.AddError(nameof(ProvinceValidator), nameof(Province.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <int> Count(ProvinceFilter ProvinceFilter)
{
try
{
int result = await UOW.ProvinceRepository.Count(ProvinceFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ProvinceService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <List <Province> > List(ProvinceFilter ProvinceFilter)
{
try
{
List <Province> Provinces = await UOW.ProvinceRepository.List(ProvinceFilter);
return(Provinces);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ProvinceService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <List <Province> > List(ProvinceFilter provinceFilter)
{
return(await UOW.ProvinceRepository.List(provinceFilter));
}
public async Task <int> Count(ProvinceFilter ProvinceFilter)
{
int result = await UOW.ProvinceRepository.Count(ProvinceFilter);
return(result);
}
private IQueryable <ProvinceDAO> DynamicFilter(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Name != null)
{
query = query.Where(q => q.Name, filter.Name);
}
if (filter.OrderNumber != null)
{
query = query.Where(q => q.OrderNumber, filter.OrderNumber);
}
if (filter.Ids != null)
{
query = query.Where(q => filter.Ids.Contains(q.Id));
}
if (filter.ExceptIds != null)
{
query = query.Where(q => !filter.ExceptIds.Contains(q.Id));
}
return(query);
}
private IQueryable <ProvinceDAO> DynamicOrder(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case ProvinceOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case ProvinceOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case ProvinceOrder.OrderNumber:
query = query.OrderBy(q => q.OrderNumber);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case ProvinceOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case ProvinceOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case ProvinceOrder.OrderNumber:
query = query.OrderByDescending(q => q.OrderNumber);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private async Task <List <Province> > DynamicSelect(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
List <Province> Provinces = await query.Select(q => new Province()
{
Id = filter.Selects.Contains(ProvinceSelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(ProvinceSelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(ProvinceSelect.Name) ? q.Name : default(string),
Priority = filter.Selects.Contains(ProvinceSelect.Priority) ? q.Priority : default(long?),
StatusId = filter.Selects.Contains(ProvinceSelect.Status) ? q.StatusId : default(long),
Status = filter.Selects.Contains(ProvinceSelect.Status) && q.Status != null ? new Status
{
Id = q.Status.Id,
Code = q.Status.Code,
Name = q.Status.Name,
} : null,
Districts = filter.Selects.Contains(ProvinceSelect.Districts) && q.Districts == null ? null :
q.Districts.Select(p => new District
{
Name = p.Name,
Code = p.Code,
Wards = p.Wards.Select(w => new Ward
{
Name = w.Name,
Code = w.Code,
}).ToList(),
}).ToList(),
RowId = filter.Selects.Contains(ProvinceSelect.RowId) ? q.RowId : default(Guid)
}).ToListAsync();
return(Provinces);
}
public async Task <List <Province> > List(ProvinceFilter ProvinceFilter)
{
List <Province> Provinces = await UOW.ProvinceRepository.List(ProvinceFilter);
return(Provinces);
}
private async Task <List <Province> > DynamicSelect(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
List <Province> Provinces = await query.Select(q => new Province()
{
Id = filter.Selects.Contains(ProvinceSelect.Id) ? q.Id : default(long),
Name = filter.Selects.Contains(ProvinceSelect.Name) ? q.Name : default(string),
OrderNumber = filter.Selects.Contains(ProvinceSelect.OrderNumber) ? q.OrderNumber : default(long),
}).ToListAsync();
return(Provinces);
}
private IQueryable <ProvinceDAO> DynamicOrder(IQueryable <ProvinceDAO> query, ProvinceFilter provinceFilter)
{
switch (provinceFilter.OrderType)
{
case OrderType.ASC:
switch (provinceFilter.OrderBy)
{
case ProvinceOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case ProvinceOrder.Name:
query = query.OrderBy(q => q.Name);
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
break;
case OrderType.DESC:
switch (provinceFilter.OrderBy)
{
case ProvinceOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case ProvinceOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
default:
query = query.OrderByDescending(q => q.CX);
break;
}
break;
default:
query = query.OrderBy(q => q.CX);
break;
}
query = query.Skip(provinceFilter.Skip).Take(provinceFilter.Take);
return(query);
}
private IQueryable <ProvinceDAO> DynamicFilter(IQueryable <ProvinceDAO> query, ProvinceFilter provinceFilter)
{
if (provinceFilter == null)
{
return(query.Where(q => 1 == 0));
}
if (provinceFilter.Id != null)
{
query = query.Where(q => q.Id, provinceFilter.Id);
}
if (provinceFilter.Name != null)
{
query = query.Where(q => q.Name, provinceFilter.Name);
}
if (provinceFilter.Code != null)
{
query = query.Where(q => q.Code, provinceFilter.Code);
}
return(query);
}
private IQueryable <ProvinceDAO> DynamicFilter(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
query = query.Where(q => !q.DeletedAt.HasValue);
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.Priority != null)
{
query = query.Where(q => q.Priority, filter.Priority);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <ProvinceDAO> DynamicOrder(IQueryable <ProvinceDAO> query, ProvinceFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case ProvinceOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case ProvinceOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case ProvinceOrder.Name:
query = query.OrderBy(q => q.Name);
break;
case ProvinceOrder.Priority:
query = query.OrderBy(q => q.Priority == null).ThenBy(x => x.Priority);
break;
case ProvinceOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case ProvinceOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case ProvinceOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case ProvinceOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
case ProvinceOrder.Priority:
query = query.OrderByDescending(q => q.Priority == null).ThenByDescending(x => x.Priority);
break;
case ProvinceOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
