public static Rule <T> InList <TList>(IEnumerable <TList> list, Expression <Func <T, TList> > convertExpression)
where TList : class
=> new Rule <T>(PredicateHelper.In <T, TList>(convertExpression, list));
public async Task <IEnumerable <BaseConhecimento> > GetWithBaseChildsAsync(string[] searchArr, decimal idUser, int?pageNumber, int pageSize)
{
List <Resumo> resumos = new List <Resumo>();
List <BuscaChave> tags = new List <BuscaChave>();
var lsVersion = new List <BaseConhecimento>();
IEnumerable <BaseConhecimento> data = null;
Expression <Func <BaseConhecimento, bool> > WhereVisibilidadeBase = null;
int totalFound = 0;
int total = 0;
// Monta filtro de Tipo de Visualização da Base de Conhecimento
if (idUser == 0)
{
WhereVisibilidadeBase = b => b.TpVisualizacao == EnumHelper.Visibilidade.PUBLICO.ToString();
}
else
{
WhereVisibilidadeBase = b =>
(
b.TpVisualizacao != EnumHelper.Visibilidade.PRIVADO.ToString() ||
(b.TpVisualizacao == EnumHelper.Visibilidade.PRIVADO.ToString() && b.IdUsuarioRegistro == idUser)
);
}
if (searchArr.Length > 0)
{
data = await _db
.Include(c => c.CausaRaiz)
.Include(r => r.Resumo)
.Include(s => s.SolucaoPaliativa)
.Include(s => s.BuscaChave)
.ThenInclude(e => e.PalavraChave)
.Include(p => p.BaseProduto)
.ThenInclude(e => e.Produto)
// Filtra a Base de Conhecimento de acordo com a(s) palavra(s) chave informada(s)
.Where(d => d.BuscaChave
.Where(a => searchArr.Contains(a.PalavraChave.Palavra.RemoveAccents().ToLower())).Any())
// Filtra a Base de Conhecimento de acordo com a Visibilidade
.Where(WhereVisibilidadeBase)
// Filtra Paginação na Base de Dados
.Skip(((pageNumber ?? 1) - 1) * pageSize).Take(pageSize)
.ToListAsync();
total = await _db
.Where(d => d.BuscaChave
.Where(a => searchArr.Contains(a.PalavraChave.Palavra.RemoveAccents().ToLower())).Any())
.Where(WhereVisibilidadeBase).CountAsync();
// Se não encontra, procura no Titulo, Resumo, etc
if (data.Count() == 0)
{
var WhereResumo = PredicateHelper.False <Resumo>();
foreach (var item in searchArr)
{
WhereResumo = WhereResumo.Or(p => p.DsTituloPuro.ToLower().Contains(item));
WhereResumo = WhereResumo.Or(p => p.TextoPuro.Contains(item));
}
data = await _db
.Include(c => c.CausaRaiz)
.Include(r => r.Resumo)
.Include(s => s.SolucaoPaliativa)
.Include(s => s.BuscaChave)
.ThenInclude(e => e.PalavraChave)
.Include(p => p.BaseProduto)
.ThenInclude(e => e.Produto)
// Filtra o Titulo e o Resumo de acordo com a(s) palavra(s) chave informada(s)
.Where(r => r.Resumo.AsQueryable()
.Where(WhereResumo).Any())
// Filtra a Base de Conhecimento de acordo com a Visibilidade
.Where(WhereVisibilidadeBase)
// Filtra Paginação na Base de Dados
.Skip(((pageNumber ?? 1) - 1) * pageSize).Take(pageSize)
.ToListAsync();
total = await _db
.Where(r => r.Resumo.AsQueryable()
.Where(WhereResumo).Any())
.Where(WhereVisibilidadeBase).CountAsync();
}
}
else
{
data = await _db
.Include(c => c.CausaRaiz)
.Include(r => r.Resumo)
.Include(s => s.SolucaoPaliativa)
.Include(s => s.BuscaChave)
.ThenInclude(e => e.PalavraChave)
.Include(p => p.BaseProduto)
.ThenInclude(e => e.Produto)
// Filtra a Base de Conhecimento de acordo com a Visibilidade
.Where(WhereVisibilidadeBase)
// Filtra Paginação na Base de Dados
.Skip(((pageNumber ?? 1) - 1) * pageSize).Take(pageSize)
.ToListAsync();
total = await _db.Where(WhereVisibilidadeBase).CountAsync();
}
// Adiciona Destaque(Cor Amarela) nas palavras encontradas na busca
foreach (var item in data)
{
AddHighLightWord
(
item.Resumo.Where(d => d.SeqVersao == item.Resumo.Select(y => y.SeqVersao).Max()),
item.BuscaChave,
searchArr,
resumos,
tags,
out totalFound,
searchArr.Length > 0
);
lsVersion.Add(
new BaseConhecimento
{
Id = item.Id,
DtHrRegistro = item.DtHrRegistro,
IdUsuarioRegistro = item.IdUsuarioRegistro,
TpVisualizacao = item.TpVisualizacao,
StBase = item.StBase,
Usuario = item.Usuario,
TipoVisualizacao = item.TipoVisualizacao,
SituacaoBase = item.SituacaoBase,
BuscaChave = tags.Where(c => c.Id == item.Id).ToList(),
TotalMath = total, //totalFound,
// Filtra a CausaRaiz de maior Versão
CausaRaiz = item.CausaRaiz
.Where(d => d.SeqVersao == item.CausaRaiz.Select(y => y.SeqVersao).Max()).ToList(),
// Filtra o Resumo de maior Versão
Resumo = resumos.Where(r => r.Id == item.Id).ToList(),
// Filtra a Solução Paliativa de maior Versão
SolucaoPaliativa = item.SolucaoPaliativa
.Where(d => d.SeqVersao == item.SolucaoPaliativa.Select(y => y.SeqVersao).Max()).ToList(),
BaseProduto = item.BaseProduto
}
);
}
lsVersion.OrderByDescending(b => b.DtHrRegistro);
return(lsVersion);
}
public MasterDataApprovalSettingDto GetAllEditableColumn(int pageId)
{
var page = _pageBLL.GetPageByID(pageId);
var tableDetails = _repository.GetTableDetail(page.MAIN_TABLE);
Expression <Func <MASTER_DATA_APPROVE_SETTING, bool> > queryFilter = PredicateHelper.True <MASTER_DATA_APPROVE_SETTING>();
queryFilter = queryFilter.And(c => c.PAGE_ID == page.PAGE_ID);
var masterDataSettings = _repository.Get(queryFilter, null, includeTables).ToList();
var rc = Mapper.Map <MasterDataApprovalSettingDto>(page);
foreach (var table in tableDetails)
{
var detail = Mapper.Map <MasterDataApprovalSettingDetail>(table);
var isApproval = masterDataSettings.Where(x => x.COLUMN_NAME == detail.COLUMN_NAME).Select(x => x.IS_APPROVAL).FirstOrDefault();
detail.IsPrimary = table.IsUniquePrimaryKey;
if (table.IsUniquePrimaryKey)
{
detail.IS_APPROVAL = true;
}
else
{
if (pageId == (int)Core.Enums.MenuList.POAMap)
{
if (!table.IsNullable)
{
detail.IS_APPROVAL = true;
detail.IsPrimary = true;
}
else
{
detail.IS_APPROVAL = isApproval;
}
}
else
{
detail.IS_APPROVAL = isApproval;
}
}
detail.PAGE_ID = page.PAGE_ID;
if (detail.ColumnDescription != null)
{
rc.Details.Add(detail);
}
}
if (pageId == (int)Core.Enums.MenuList.MaterialMaster)
{
rc.Details.Add(new MasterDataApprovalSettingDetail()
{
COLUMN_NAME = "CONVERTION",
ColumnDescription = "Convertion",
IS_APPROVAL = true,
IsPrimary = true,
PAGE_ID = pageId
});
}
return(rc);
}
public List <PO_REPORT_DATA> GetRptPo(RptPoByParamInput filter)
{
Expression <Func <PO_REPORT_DATA, bool> > queryFilter = PredicateHelper.True <PO_REPORT_DATA>();
if (filter != null)
{
//if (filter.PeriodFrom != null)
//{
// //queryFilter = queryFilter.And(c => (c.CREATED_DATE.Day >= filter.PeriodFrom.Day) &&
// // (c.CREATED_DATE.Month >= filter.PeriodFrom.Month) &&
// // (c.CREATED_DATE.Year >= filter.PeriodFrom.Year));
// queryFilter = queryFilter.And(c => (c.START_CONTRACT.Value.Day >= filter.PeriodFrom.Day) &&
// (c.START_CONTRACT.Value.Month >= filter.PeriodFrom.Month) &&
// (c.START_CONTRACT.Value.Year >= filter.PeriodFrom.Year));
//}
//if (filter.PeriodTo != null)
//{
// //queryFilter = queryFilter.And(c => (c.CREATED_DATE.Day <= filter.PeriodTo.Day) &&
// // (c.CREATED_DATE.Month <= filter.PeriodTo.Month) &&
// // (c.CREATED_DATE.Year <= filter.PeriodTo.Year));
// queryFilter = queryFilter.And(c => (c.END_CONTRACT.Value.Day <= filter.PeriodTo.Day) &&
// (c.END_CONTRACT.Value.Month <= filter.PeriodTo.Month) &&
// (c.END_CONTRACT.Value.Year <= filter.PeriodTo.Year));
//}
if (filter.MonthFrom > 0)
{
queryFilter = queryFilter.And(c => c.REPORT_MONTH >= filter.MonthFrom);
}
if (filter.YearFrom > 0)
{
queryFilter = queryFilter.And(c => c.REPORT_YEAR >= filter.YearFrom);
}
if (filter.MonthTo > 0)
{
queryFilter = queryFilter.And(c => c.REPORT_MONTH <= filter.MonthTo);
}
if (filter.YearTo > 0)
{
queryFilter = queryFilter.And(c => c.REPORT_YEAR <= filter.YearTo);
}
if (!string.IsNullOrEmpty(filter.EmployeeName))
{
queryFilter = queryFilter.And(c => c.EMPLOYEE_NAME.ToUpper() == filter.EmployeeName.ToUpper());
}
if (!string.IsNullOrEmpty(filter.CostCenter))
{
queryFilter = queryFilter.And(c => c.COST_CENTER.ToUpper() == filter.CostCenter.ToUpper());
}
if (!string.IsNullOrEmpty(filter.SupplyMethod))
{
queryFilter = queryFilter.And(c => c.SUPPLY_METHOD.ToUpper() == filter.SupplyMethod.ToUpper());
}
if (!string.IsNullOrEmpty(filter.PoliceNumber))
{
queryFilter = queryFilter.And(c => c.POLICE_NUMBER.ToUpper() == filter.PoliceNumber.ToUpper());
}
if (filter.GroupLevel > 0)
{
queryFilter = queryFilter.And(c => c.MST_EMPLOYEE.GROUP_LEVEL == filter.GroupLevel);
}
}
return(_rptPoRepository.Get(queryFilter, null, "").ToList());
}
public void String_Queries()
{
Assert.True(PredicateHelper.Create <string>("Length = 0")(string.Empty));
Assert.False(PredicateHelper.Create <string>("@ = Ahmed")("ahmed"));
Assert.True(PredicateHelper.Create <string>("@ = Ahmed")("Ahmed"));
}
internal static Expression <Func <LotProductionResults, bool?> > FilterByProductionBegin(DateTime?rangeStart, DateTime?rangeEnd)
{
var dateInRange = PredicateHelper.DateInRange(rangeStart, rangeEnd);
return(r => dateInRange.Invoke(r.ProductionBegin));
}
public void Integer_Queries(string q, int val, bool expected)
{
Assert.Equal(expected, PredicateHelper.Create <int>(q)(val));
}
public void Datetime_Tests()
{
var foo = new Foo()
{
DateTime = new DateTime(2000, 12, 31),
};
Assert.True(PredicateHelper.Create <Foo>("DateTime.Year = 2000")(foo));
Assert.True(PredicateHelper.Create <Foo>("NullableDateTimeNull = null")(foo)); Assert.True(PredicateHelper.Create <Foo>("NullableDateTimeHasValue.Year = 2000")(foo));
}
public List <LACK2> GetByParam(Lack2GetByParamInput input)
{
Expression <Func <LACK2, bool> > queryFilter = PredicateHelper.True <LACK2>();
if (!string.IsNullOrEmpty((input.NppbKcId)))
{
queryFilter = queryFilter.And(c => c.NPPBKC_ID == input.NppbKcId);
}
if (!string.IsNullOrEmpty((input.PlantId)))
{
queryFilter = queryFilter.And(c => c.LEVEL_PLANT_ID == input.PlantId);
}
if (!string.IsNullOrEmpty((input.Creator)))
{
queryFilter = queryFilter.And(c => c.CREATED_BY == input.Creator);
}
if (!string.IsNullOrEmpty((input.Poa)))
{
queryFilter = queryFilter.And(c => c.APPROVED_BY == input.Poa);
}
if (input.SubmissionDate.HasValue)
{
var date = input.SubmissionDate.Value.Day;
var month = input.SubmissionDate.Value.Month;
var year = input.SubmissionDate.Value.Year;
var dateToCompare = new DateTime(year, month, date);
queryFilter = queryFilter.And(c => c.SUBMISSION_DATE.Equals(dateToCompare));
}
queryFilter = input.IsOpenDocList ? queryFilter.And(c => c.STATUS != Enums.DocumentStatus.Completed) : queryFilter.And(c => c.STATUS == Enums.DocumentStatus.Completed);
//switch (input.UserRole)
//{
//case Enums.UserRole.POA:
// queryFilter = queryFilter.And(c => (c.CREATED_BY == input.UserId
// || (c.STATUS != Enums.DocumentStatus.Draft
// && input.NppbkcList.Contains(c.NPPBKC_ID))));
// break;
//case Enums.UserRole.Manager:
// queryFilter =
// queryFilter.And(
// c =>
// c.STATUS != Enums.DocumentStatus.Draft &&
// c.STATUS != Enums.DocumentStatus.WaitingForApproval &&
// input.DocumentNumberList.Contains(c.LACK2_NUMBER));
// break;
// default:
// queryFilter = queryFilter.And(c => c.CREATED_BY == input.UserId);
// break;
//}
if (input.UserRole != Enums.UserRole.Administrator && input.UserRole != Enums.UserRole.Controller)
{
queryFilter = queryFilter.And(c => input.PlantList.Contains(c.LEVEL_PLANT_ID));
}
Func <IQueryable <LACK2>, IOrderedQueryable <LACK2> > orderBy = null;
if (!string.IsNullOrEmpty(input.SortOrderColumn))
{
orderBy = c => c.OrderBy(OrderByHelper.GetOrderByFunction <LACK2>(input.SortOrderColumn));
}
var dbData = _repository.Get(queryFilter, orderBy, includeTables);
return(dbData == null ? null : dbData.ToList());
}
public List <LACK2> GetSummaryReportsByParam(Lack2GetSummaryReportByParamInput input)
{
Expression <Func <LACK2, bool> > queryFilter = PredicateHelper.True <LACK2>();
if (!string.IsNullOrEmpty(input.CompanyCode))
{
queryFilter = queryFilter.And(c => c.BUKRS.Contains(input.CompanyCode));
}
if (!string.IsNullOrEmpty(input.NppbkcId))
{
queryFilter = queryFilter.And(c => c.NPPBKC_ID.Contains(input.NppbkcId));
}
if (!string.IsNullOrEmpty(input.SendingPlantId))
{
queryFilter = queryFilter.And(c => c.LEVEL_PLANT_ID.Contains(input.SendingPlantId));
}
if (!string.IsNullOrEmpty(input.GoodType))
{
queryFilter = queryFilter.And(c => c.EX_GOOD_TYP.Contains(input.GoodType));
}
if (input.PeriodMonth.HasValue)
{
queryFilter =
queryFilter.And(c => c.PERIOD_MONTH == input.PeriodMonth.Value);
}
if (input.PeriodYear.HasValue)
{
queryFilter =
queryFilter.And(c => c.PERIOD_YEAR == input.PeriodYear.Value);
}
if (input.DocumentStatus.HasValue)
{
queryFilter = queryFilter.And(c => c.STATUS == input.DocumentStatus.Value);
}
if (input.CreatedDate.HasValue)
{
queryFilter =
queryFilter.And(
c =>
c.CREATED_DATE.Year == input.CreatedDate.Value.Year &&
c.CREATED_DATE.Month == input.CreatedDate.Value.Month &&
c.CREATED_DATE.Day == input.CreatedDate.Value.Day);
}
if (!string.IsNullOrEmpty(input.CreatedBy))
{
queryFilter = queryFilter.And(c => c.CREATED_BY == input.CreatedBy);
}
if (input.ApprovedDate.HasValue)
{
queryFilter =
queryFilter.And(
c =>
c.APPROVED_DATE.HasValue &&
c.APPROVED_DATE.Value.Year == input.ApprovedDate.Value.Year &&
c.APPROVED_DATE.Value.Month == input.ApprovedDate.Value.Month &&
c.APPROVED_DATE.Value.Day == input.ApprovedDate.Value.Day);
}
if (!string.IsNullOrEmpty(input.ApprovedBy))
{
queryFilter = queryFilter.And(c => c.APPROVED_BY == input.ApprovedBy);
}
if (!string.IsNullOrEmpty(input.Creator))
{
queryFilter = queryFilter.And(c => c.CREATED_BY == input.Creator);
}
if (!string.IsNullOrEmpty(input.Approver))
{
queryFilter = queryFilter.And(c => c.APPROVED_BY_MANAGER == input.Approver);
}
if (input.UserRole != Enums.UserRole.Administrator)
{
queryFilter = queryFilter.And(c => input.ListUserPlant.Contains(c.LEVEL_PLANT_ID));
}
return(_repository.Get(queryFilter, null, "LACK2_ITEM, LACK2_ITEM.CK5").ToList());
}
internal static Expression <Func <InventoryAdjustment, bool> > ByTimeStampRange(DateTime?rangeStart, DateTime?rangeEnd)
{
var dateInRange = PredicateHelper.DateTimeInRange(rangeStart, rangeEnd);
return(a => dateInRange.Invoke(a.AdjustmentDate));
}
internal static Expression <Func <Contract, bool> > ByTermBeginInRange(DateTime?rangeStart, DateTime?rangeEnd)
{
var dateInRange = PredicateHelper.DateInRange(rangeStart, rangeEnd);
return(c => dateInRange.Invoke(c.TermBegin));
}
public List <WasteDto> GetAllByParam(WasteGetByParamInput input)
{
Expression <Func <WASTE, bool> > queryFilter = PredicateHelper.True <WASTE>();
if (!string.IsNullOrEmpty(input.Company))
{
queryFilter = queryFilter.And(c => c.COMPANY_CODE == input.Company);
}
if (!string.IsNullOrEmpty(input.Plant))
{
queryFilter = queryFilter.And(c => c.WERKS == input.Plant);
}
if (!string.IsNullOrEmpty(input.WasteProductionDate))
{
var dt = Convert.ToDateTime(input.WasteProductionDate);
queryFilter = queryFilter.And(c => c.WASTE_PROD_DATE == dt);
}
if (input.Month > 0)
{
queryFilter = queryFilter.And(c => c.WASTE_PROD_DATE.Month == input.Month);
}
if (input.Year > 0)
{
queryFilter = queryFilter.And(c => c.WASTE_PROD_DATE.Year == input.Year);
}
if (!string.IsNullOrEmpty(input.UserId))
{
if (input.UserRole != Core.Enums.UserRole.Administrator)
{
queryFilter = queryFilter.And(c => input.ListUserPlants.Contains(c.WERKS));
}
}
if (input.BeginingProductionDate.HasValue)
{
queryFilter = queryFilter.And(c => c.WASTE_PROD_DATE >= input.BeginingProductionDate.Value);
}
if (input.EndProductionDate.HasValue)
{
queryFilter = queryFilter.And(c => c.WASTE_PROD_DATE <= input.EndProductionDate.Value);
}
if (!string.IsNullOrEmpty(input.FaCode))
{
queryFilter = queryFilter.And(c => c.FA_CODE == input.FaCode);
}
Func <IQueryable <WASTE>, IOrderedQueryable <WASTE> > orderBy = null;
{
if (!string.IsNullOrEmpty(input.ShortOrderColumn))
{
orderBy = c => c.OrderBy(OrderByHelper.GetOrderByFunction <WASTE>(input.ShortOrderColumn));
}
var dbData = _repository.Get(queryFilter, orderBy);
if (dbData == null)
{
throw new BLLException(ExceptionCodes.BLLExceptions.DataNotFound);
}
var mapResult = Mapper.Map <List <WasteDto> >(dbData.ToList());
return(mapResult);
}
}
