private static void Main()
{
MongoInitializer = new MongoInitializer();
var user = new User
{
Id = MongoInitializer.SampleDb.Users.NewId()
};
MongoInitializer.SampleDb.Users.InsertOne(user);
MongoInitializer.SampleDb.Articles.InsertOne(new Article
{
AuthorId = user.Id
});
var article = MongoInitializer.SampleDb.Articles.AsQueryable().First(x => x.AuthorId == user.Id);
MongoInitializer.SampleDb.Articles.UpdateById(article.Id, x => x.PushEach(a => a.Comments, new List <Comment>
{
new Comment(),
new Comment
{
UserId = user.Id
}
}));
MongoInitializer.SampleDb.Articles.UpdateArrayById(article.Id,
x => x.Comments,
QueryExtensions.EQ <Comment>(a => a.UserId, user.Id),
(builder, array) => builder.Set(array, c => c.Text, "new text"));
var count = new GetUserCommentsCountCommand(MongoInitializer).ByArticle(article.Id, user.Id);
Console.WriteLine(count);
}
private IQuery <Session> BuildSessionQuery <T>(Expression <Func <Session, T> > lambda)
{
var query = GetShareFileClient().Sessions.Get();
query = QueryExtensions.ApplySelectsAndExpands(query, lambda);
return(query);
}
public List <ViajeDistribucion> GetList(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> vehiculos, IEnumerable <int> empleados)
{
var departamentos = new[] { -1 };
var transportistas = new[] { -1 };
var centrosDeCosto = new[] { -1 };
var tiposVehiculo = new[] { -1 };
var tiposEmpleado = new[] { -1 };
var q = Query.FilterEmpresa(Session, empresas)
.FilterLinea(Session, empresas, lineas);
if (!QueryExtensions.IncludesAll(transportistas) || !QueryExtensions.IncludesAll(centrosDeCosto) ||
!QueryExtensions.IncludesAll(tiposVehiculo) || !QueryExtensions.IncludesAll(vehiculos))
{
q = q.FilterVehiculo(Session, empresas, lineas, transportistas, departamentos, centrosDeCosto, tiposVehiculo, vehiculos);
}
if (!QueryExtensions.IncludesAll(transportistas) || !QueryExtensions.IncludesAll(tiposEmpleado) ||
!QueryExtensions.IncludesAll(empleados))
{
q = q.FilterEmpleado(Session, empresas, lineas, transportistas, tiposEmpleado, empleados);
}
return(q.ToList());
}
public IQueryable <PuntoEntrega> FindByCodeLike(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> clientes, string codigo, int limit = 10)
{
Cliente c = null;
Empresa e = null;
Linea l = null;
var queryOver = Session.QueryOver <PuntoEntrega>()
.JoinAlias(p => p.Cliente, () => c)
.JoinAlias(p => p.Cliente.Empresa, () => e)
.Left.JoinAlias(p => p.Cliente.Linea, () => l)
.WhereRestrictionOn(p => p.Codigo).IsLike(codigo + '%')
.AndNot(p => p.Baja);
if (!QueryExtensions.IncludesAll(empresas))
{
queryOver = queryOver.WhereRestrictionOn(() => e.Id).IsIn(empresas.ToArray());
}
if (!QueryExtensions.IncludesAll(lineas))
{
queryOver = queryOver.Where(Restrictions.Or(
Restrictions.On(() => l.Id).IsIn(lineas.ToArray()),
Restrictions.On(() => c.Linea).IsNull
));
}
return(queryOver.Take(limit).Future().AsQueryable());
//return Query.FilterCliente(Session, empresas, lineas, clientes)
// .Where(p => !p.Baja)
// .Where(p => p.Codigo.Contains(codigo))
// .Cacheable()
// .AsQueryable();
}
public List <Empleado.VerificadorEmpleado> GetVerificadorEmpleados(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> centrosDeCosto, IEnumerable <int> departamentos, IEnumerable <int> categoriasDeAcceso, string legajo, IEnumerable <int> tiposZonaAcceso, IEnumerable <int> zonasAcceso, IEnumerable <int> puertasAcceso)
{
var empleados = DAOFactory.EmpleadoDAO.GetList(empresas,
lineas,
new[] { -1 },
new[] { -1 },
centrosDeCosto,
departamentos,
categoriasDeAcceso,
legajo)
.Select(emp => DAOFactory.EmpleadoDAO.GetLastLog(emp));
if (!QueryExtensions.IncludesAll(tiposZonaAcceso))
{
empleados = empleados.Where(emp => emp.ZonaAcceso != null && tiposZonaAcceso.Contains(emp.ZonaAcceso.TipoZonaAcceso.Id));
}
if (!QueryExtensions.IncludesAll(zonasAcceso))
{
empleados = empleados.Where(emp => emp.ZonaAcceso != null && zonasAcceso.Contains(emp.ZonaAcceso.Id));
}
if (!QueryExtensions.IncludesAll(puertasAcceso))
{
empleados = empleados.Where(emp => emp.PuertaAcceso != null && puertasAcceso.Contains(emp.PuertaAcceso.Id));
}
return(empleados.ToList());
}
public List <ProgramButtonSearchResultDto> Search(ProgramButtonSearchRequestDto searchRequest, ref GridParams gridParams)
{
var query = from programButton in _programButtonRepository.Table
join program in _programRepository.Table
on programButton.ProgramID equals program.ProgramID
join button in _buttonRepository.Table
on programButton.ButtonID equals button.ButtonID
select new ProgramButtonSearchResultDto {
ProgramButtonID = programButton.ProgramButtonID,
ProgramID = program.ProgramID,
ButtonID = button.ButtonID,
ProgramName = program.ProgramName,
ButtonName = button.ButtonName,
Url = programButton.Url,
ButtonText = button.ButtonText
};
query = query.Where(b => !(
(searchRequest.ButtonID != 0 && b.ButtonID != searchRequest.ButtonID) ||
(searchRequest.ProgramID != 0 && b.ProgramID != searchRequest.ProgramID) ||
(searchRequest.ProgramButtonID != 0 && b.ProgramButtonID != searchRequest.ProgramButtonID)
));
gridParams.TotalCount = query.Count();
return(QueryExtensions.SortAndPage(query, gridParams).ToList());
}
public IQueryable <Empleado> GetByCodigoTipoEmpleado(IEnumerable <int> empresas, IEnumerable <int> lineas, string codigo)
{
Empresa jEmpresa = null;
Linea jLinea = null;
var q = Session.QueryOver <Empleado>()
.Left.JoinAlias(empleado => empleado.Empresa, () => jEmpresa)
.Left.JoinAlias(empleado => empleado.Linea, () => jLinea)
;
if (!QueryExtensions.IncludesAll(empresas))
{
q = q.Where(Restrictions.Or(
Restrictions.Where <Empleado>(empleado => empleado.Empresa == null),
Restrictions.On(() => jEmpresa.Id).IsIn(empresas.ToArray())));
}
if (!QueryExtensions.IncludesAll(lineas))
{
q = q.Where(Restrictions.Or(
Restrictions.Where <Empleado>(empleado => empleado.Linea == null),
Restrictions.On(() => jLinea.Id).IsIn(lineas.ToArray())));
}
var w = q.JoinQueryOver(empleado => empleado.TipoEmpleado).Where(empleado => empleado.Codigo == codigo);
return(w.Future().AsQueryable());
}
public List <ProgramSearchResultDto> Search(ProgramSearchRequestDto searchRequest, ref GridParams gridParams)
{
var query = from program in _programRepository.Table
join parent in _programRepository.Table
on program.ParentID equals parent.ProgramID
select new ProgramSearchResultDto()
{
ProgramID = program.ProgramID,
ProgramName = program.ProgramName,
ParentID = program.ParentID,
ParentName = parent.ProgramName,
Url = program.Url,
Icon = program.Icon,
IsVisible = program.IsVisible,
Priority = program.Priority,
StatusFlag = program.StatusFlag
};
query = query.Where(b => !(
(searchRequest.ProgramID != 0 && b.ProgramID != searchRequest.ProgramID) ||
(!string.IsNullOrEmpty(searchRequest.ProgramName) && b.ProgramName.Trim() != searchRequest.ProgramName) ||
(searchRequest.ParentID != 0 && b.ParentID != searchRequest.ParentID)
));
gridParams.TotalCount = query.Count();
return(QueryExtensions.SortAndPage(query, gridParams).ToList());
}
public List <SupportTicket> GetList(IEnumerable <int> empresas, IEnumerable <int> categorias, IEnumerable <int> subcategorias, IEnumerable <int> niveles, DateTime desde, DateTime hasta)
{
var q = Session.Query <SupportTicket>().Where(st => !st.Baja);
if (!QueryExtensions.IncludesAll(empresas))
{
q = q.FilterEmpresa(Session, empresas);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(categorias))
{
q = q.FilterCategoria(Session, empresas, categorias);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(categorias) || !QueryExtensions.IncludesAll(subcategorias))
{
q = q.FilterSubcategoria(Session, empresas, categorias, subcategorias);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(niveles))
{
q = q.FilterNivel(Session, empresas, niveles);
}
q = q.Where(st => st.Fecha >= desde && st.Fecha <= hasta);
return(q.ToList());
}
public List <LogEvento> GetList(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> dispositivos, IEnumerable <int> sensores, IEnumerable <int> tiposEntidad, IEnumerable <int> entidades, IEnumerable <int> subentidades, IEnumerable <string> mensajesCodes, DateTime fechaDesde, DateTime fechaHasta)
{
var q = Query;
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(lineas) || !QueryExtensions.IncludesAll(dispositivos))
{
q = q.FilterDispositivo(Session, empresas, lineas, dispositivos);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(lineas) || !QueryExtensions.IncludesAll(dispositivos) || !QueryExtensions.IncludesAll(sensores))
{
q = q.FilterSensor(Session, empresas, lineas, dispositivos, sensores);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(lineas) || !QueryExtensions.IncludesAll(tiposEntidad) ||
!QueryExtensions.IncludesAll(entidades) || !QueryExtensions.IncludesAll(subentidades))
{
q = q.FilterSubEntidad(Session, empresas, lineas, tiposEntidad, entidades, subentidades);
}
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(lineas) || !QueryExtensions.IncludesAll(mensajesCodes))
{
q = q.FilterMensajeCodes(Session, empresas, lineas, mensajesCodes);
}
return(q.Where(e => e.Fecha < fechaHasta && e.Fecha > fechaDesde)
.OrderBy(e => e.Fecha)
.ToList());
}
public IEnumerable <Domain.Model.Client> Find(string query)
{
return(CurrentSession.Advanced.LuceneQuery <Domain.Model.Client>("ClientIndex")
.Include(c => c.Industry)
.Include(c => c.Positions)
.WhereContains("Name", QueryExtensions.CleanseAndSplit(query)).ToList());
}
public List <RoleUserSearchResultDto> Search(RoleUserSearchRequestDto searchRequest, ref GridParams gridParams)
{
var query = from roleUser in _roleUserRepository.Table
join role in _roleMasterRepository.Table
on roleUser.RoleID equals role.RoleID
join user in _userMasterRepository.Table
on roleUser.UserID equals user.UserID
select new RoleUserSearchResultDto()
{
UserRoleID = roleUser.UserRoleID,
RoleID = role.RoleID,
RoleDesc = role.RoleDesc,
UserID = user.UserID,
UserName = user.UserName
};
query = query.Where(b => !(
(searchRequest.UserRoleID != 0 && b.UserRoleID != searchRequest.UserRoleID) ||
(!string.IsNullOrEmpty(searchRequest.UserID) && b.UserID.Trim() != searchRequest.UserID) ||
(searchRequest.RoleID != 0 && b.RoleID != searchRequest.RoleID)
));
gridParams.TotalCount = query.Count();
return(QueryExtensions.SortAndPage(query, gridParams).ToList());
}
public static Task <Dictionary <string, Object> > read(string path)
{
path = WebUtility.UrlEncode(path);
return(Task <Dictionary <string, Object> > .Factory.StartNew(() =>
{
try
{
if (FireAuth.isTokenExpired())
{
FireAuth.RenewAuthToken(Settings.RefreshToken).RunSynchronously();
}
var reference = firebase.Child(path);
var authReference = QueryExtensions.WithAuth(reference, FireAuth.auth.FirebaseToken);
var result = authReference.OnceSingleAsync <Dictionary <string, Object> >().Result;
return result;
}
catch (Exception e)
{
Console.WriteLine("FireDatabase.cs:read(): ERROR: " + e.GetBaseException());
Console.WriteLine(path);
return new Dictionary <string, Object>();
}
}));
}
public List <ViajeDistribucion> GetByTexto(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> transportistas, IEnumerable <int> coches, DateTime fechaDesde, DateTime fechaHasta, string texto)
{
var q = Query.FilterEmpresa(Session, empresas)
.FilterLinea(Session, empresas, lineas);
if (!QueryExtensions.IncludesAll(transportistas) || !QueryExtensions.IncludesAll(coches))
{
q = q.FilterVehiculo(Session, empresas, lineas, transportistas, new[] { -1 }, new[] { -1 }, new[] { -1 }, coches);
}
q = q.Where(t => t.Inicio >= fechaDesde &&
t.Inicio < fechaHasta &&
t.Estado != ViajeDistribucion.Estados.Eliminado);
var viajes = q.ToList();
if (string.IsNullOrEmpty(texto))
{
return(viajes);
}
var textoUi = texto.ToUpperInvariant();
return(viajes.Where(t => t.Codigo.ToUpperInvariant().Contains(textoUi) ||
t.NumeroViaje.ToString("#0").ToUpperInvariant().Contains(textoUi))
.ToList());
}
protected override List <ResumenDeRutasVo> GetResults()
{
var results = new List <ResumenDeRutasVo>();
var viajes = new List <ViajeDistribucion>();
tbl_totales.Visible = false;
if (lbVehiculo.Items.Count > 0)
{
if (QueryExtensions.IncludesAll(lbVehiculo.SelectedValues))
{
lbVehiculo.ToogleItems();
}
viajes = DAOFactory.ViajeDistribucionDAO.GetList(new[] { ddlLocacion.Selected },
new[] { ddlPlanta.Selected },
new[] { -1 }, //lbTransportista.SelectedValues,}
new[] { -1 }, //lbDepartamento.SelectedValues,
new[] { -1 }, //lbCentroDeCostos.SelectedValues,
new[] { -1 }, //lbSubCentroDeCostos.SelectedValues,
lbVehiculo.SelectedValues,
dpDesde.SelectedDate.GetValueOrDefault().ToDataBaseDateTime(),
dpHasta.SelectedDate.GetValueOrDefault().ToDataBaseDateTime());
if (txtRuta.Text.Trim() != string.Empty)
{
viajes = viajes.Where(v => v.Codigo.Contains(txtRuta.Text.Trim())).ToList();
}
results = viajes.Select(v => new ResumenDeRutasVo(v, chkVerKm.Checked)).ToList();
}
ShowTotales(viajes);
return(results);
}
public List <ReferenciaGeografica> GetList(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> tiposGeoRef, string SearchString)
{
if (string.IsNullOrEmpty(SearchString))
{
var q = Query.FilterEmpresa(Session, empresas)
.FilterLinea(Session, empresas, lineas);
if (!QueryExtensions.IncludesAll(tiposGeoRef))
{
q = q.FilterTipoReferenciaGeografica(Session, empresas, lineas, tiposGeoRef);
}
return(q.Where(r => !r.Baja)
.Where(r => !r.Vigencia.Fin.HasValue || (r.Vigencia.Fin.HasValue && r.Vigencia.Fin.Value > DateTime.UtcNow))
.Cacheable()
.ToList());
}
else
{
var q = Query.FilterEmpresa(Session, empresas)
.FilterLinea(Session, empresas, lineas);
if (!QueryExtensions.IncludesAll(tiposGeoRef))
{
q = q.FilterTipoReferenciaGeografica(Session, empresas, lineas, tiposGeoRef);
}
return(q.Where(r => !r.Baja && (r.Codigo.ToUpper().Contains(SearchString.ToUpper()) || r.Descripcion.ToUpper().Contains(SearchString.ToUpper())))
.Where(r => !r.Vigencia.Fin.HasValue || (r.Vigencia.Fin.HasValue && r.Vigencia.Fin.Value > DateTime.UtcNow))
.Cacheable()
.ToList());
}
}
public List <UserMaster> Search(UserMasterSearchDto model, ref GridParams gridParams)
{
var query = from u in _userMasterRepository.Table
select u;
if (!String.IsNullOrEmpty(model.UserID))
{
query = query.Where(t => t.UserID == model.UserID);
}
if (!String.IsNullOrEmpty(model.EmailAdd))
{
query = query.Where(t => t.EmailAdd == model.EmailAdd);
}
if (model.ReaderType.HasValue)
{
query = query.Where(t => t.ReaderType == model.ReaderType);
}
if (model.BranchCode.HasValue)
{
query = query.Where(t => t.BranchCode == model.BranchCode);
}
if (model.PasswordExprityDateFrom != Convert.ToDateTime("1900-01-01"))
{
query = query.Where(t => t.PasswordExprityDate >= model.PasswordExprityDateFrom);
}
if (model.PasswordExprityDateTo != Convert.ToDateTime("1900-01-01"))
{
query = query.Where(t => t.PasswordExprityDate < model.PasswordExprityDateTo);
}
gridParams.TotalCount = query.Count();
return(QueryExtensions.SortAndPage(query, gridParams).ToList());
}
public async Task <PagedResults <OrganizationDto> > GetAllOrganizationsAsync(
Paginator paginator,
Expression <Func <OrganizationDto, bool> > dtoFilter,
string orderBy,
bool isAscending)
{
await using var context = ContextFactory.CreateDataContext(null);
var query = context.Organizations.AsNoTracking().AsQueryable();
if (dtoFilter != null)
{
var entityFilter = dtoFilter.ReplaceParameter <OrganizationDto, Organization>();
query = query.Where(entityFilter);
}
if (!string.IsNullOrEmpty(orderBy))
{
var sortOrder = QueryExtensions.GenerateSortOrder <Organization>(orderBy, isAscending);
query = sortOrder(query);
}
else
{
query = query.OrderBy(x => x.Name);
}
return(await Mapper.ProjectTo <OrganizationDto>(query)
.PaginateAsync(paginator)
.ConfigureAwait(false));
}
public void TimeoutShouldBeCarriedToNewCreatedFactory()
{
var db = new QueryFactory();
db.QueryTimeout = 4000;
var newFactory = QueryExtensions.CreateQueryFactory(db.Query());
Assert.Equal(db.QueryTimeout, newFactory.QueryTimeout);
}
public IQueryable <TEntity> GetByIds(ICollection <Guid> ids)
{
if (ids == null || ids.Any() == false)
{
return(Enumerable.Empty <TEntity>().AsQueryable());
}
return(Get().Where(QueryExtensions.ContainsById <TEntity>(ids)));
}
public string GetPublisherPrefixFromSolution(IOrganizationService client, string solutionName)
{
var fetchQuery = SolutionPublisherQuery.Replace("{{SolutionName}}", solutionName);
var publisher =
QueryExtensions.RetrieveRecordFromQuery(client, new FetchExpression(fetchQuery))
.ToEntity <Publisher>();
return(publisher.CustomizationPrefix);
}
public void QueryWithResultsReturnsNull()
{
var context = new XrmFakedContext();
var orgService = context.GetOrganizationService();
var retrievedAccount = (Account)QueryExtensions.RetrieveRecordFromQuery <QueryExpression>(orgService, SampleAccountQueryExpression);
Assert.IsNull(retrievedAccount);
}
protected override List <LogEventoVo> GetResults()
{
var data = LoadSearchData();
var inicio = DateTime.UtcNow;
try
{
if (QueryExtensions.IncludesAll(data.EntidadesId))
{
data.EntidadesId = DAOFactory.EntidadDAO.GetList(new[] { ddlLocacion.Selected },
new[] { ddlPlanta.Selected },
new[] { -1 },
new[] { ddlTipoEntidad.Selected })
.Select(e => e.Id)
.ToList();
}
if (ctrlFiltros.Filtros.Count > 0)
{
data.EntidadesId = DAOFactory.EntidadDAO.GetEntidadesByFiltros(data.EntidadesId, ctrlFiltros.Filtros)
.Cast <EntidadPadre>()
.Select(e => e.Id)
.ToList();
if (data.EntidadesId.Count == 0)
{
data.EntidadesId.Add(-100);
}
}
var results = DAOFactory.LogEventoDAO.GetList(ddlLocacion.SelectedValues,
ddlPlanta.SelectedValues,
new[] { -1 },
new[] { -1 },
new[] { -1 },
data.EntidadesId,
data.SubentidadesId,
data.MensajesId,
data.InitialDate,
data.FinalDate)
.Select(e => new LogEventoVo(e))
.ToList();
var duracion = (DateTime.UtcNow - inicio).TotalSeconds.ToString("##0.00");
STrace.Trace("Reporte de Eventos M2M", String.Format("Duración de la consulta: {0} segundos", duracion));
return(results);
}
catch (Exception e)
{
STrace.Exception("Reporte de Eventos M2M", e, String.Format("Reporte: Reporte de Eventos M2M. Duración de la consulta: {0:##0.00} segundos", (DateTime.UtcNow - inicio).TotalSeconds));
throw;
}
}
//Get Data From Database By Passing name of table and other parameters
public static PagedData <T> ListView(int PageSize, Func <T, object> orderByColumn, string filter = null, string orderBy = null, int orderByAsc = 1, int page = 1)
{
page = page == 0 ? 1 : page;
PageSize = PageSize == 0 ? 1 : PageSize;
Dictionary <string, string> values = null;
if (filter != null)
{
values = JsonConvert.DeserializeObject <Dictionary <string, string> >(filter);
}
DbSet <T> dbSet;
DS_CMS_DB_Entities dbContext = new DS_CMS_DB_Entities();
dbSet = dbContext.Set <T>();
IQueryable <T> query = dbSet;
var listObj = new PagedData <T>();
listObj.CurrentPage = page;
if (filter != null)
{
query = QueryExtensions.Filter <T>(query, values);
}
var data = orderByColumn;
if (orderBy != null)
{
data = QueryExtensions.GetOrderByExpression <T>(orderBy);
}
if (PageSize == 101)
{
if (orderByAsc == 1)
{
listObj.Data = query.OrderBy(data).ToList();
}
else
{
listObj.Data = query.OrderByDescending(data).ToList();
}
}
else
{
if (orderByAsc == 1)
{
listObj.Data = query.OrderBy(data).Skip(PageSize * (page - 1)).Take(PageSize).ToList();
}
else
{
listObj.Data = query.OrderByDescending(data).Skip(PageSize * (page - 1)).Take(PageSize).ToList();
}
}
listObj.NumberOfPages = Convert.ToInt32(Math.Ceiling((double)query.Count() / PageSize));
return(listObj);
}
public void GetSortExpressionDescendingForChainedParameter()
{
// Arrange
var source = new[] { new MockQueryClass() }.AsQueryable();
var expected = source.OrderByDescending(p => String.Concat(p.Name, p.Id)).Expression as MethodCallExpression;
// Act
var expression = QueryExtensions.GetSortExpression(source, new[] { "Name", "Id" }, ListSortDirection.Descending);
AreExpressionsEqual(expected, expression);
}
public List <ViajeProgramado> GetList(IEnumerable <int> empresas, IEnumerable <int> transportistas)
{
var q = Query.FilterEmpresa(Session, empresas);
if (!QueryExtensions.IncludesAll(transportistas))
{
q = q.FilterTransportista(Session, empresas, new[] { -1 }, transportistas);
}
return(q.ToList());
}
public void GetSortExpressionForSingleParameter()
{
// Arrange
var source = new[] { new MockQueryClass() }.AsQueryable();
var expected = source.OrderBy(p => p.Id).Expression as MethodCallExpression;
// Act
var expression = QueryExtensions.GetSortExpression(source, new[] { "Id" }, ListSortDirection.Ascending);
AreExpressionsEqual(expected, expression);
}
// public SensorDAO(ISession session) : base(session) { }
public List <Sensor> GetList(IEnumerable <int> empresas, IEnumerable <int> lineas, IEnumerable <int> dispositivos, IEnumerable <int> tiposMedicion)
{
var q = Query.FilterTipoMedicion(Session, tiposMedicion);
if (!QueryExtensions.IncludesAll(empresas) || !QueryExtensions.IncludesAll(lineas) || !QueryExtensions.IncludesAll(dispositivos))
{
q = q.FilterDispositivo(Session, empresas, lineas, dispositivos);
}
return(q.Where(m => !m.Baja)
.ToList());
}
// public TipoEntidadDAO(ISession session) : base(session) { }
public List <TipoEntidad> GetList(IEnumerable <int> empresas, IEnumerable <int> lineas)
{
var q = Query.FilterEmpresa(Session, empresas);
if (!QueryExtensions.IncludesAll(lineas))
{
q = q.FilterLinea(Session, empresas, lineas);
}
return(q.Where(m => !m.Baja)
.ToList());
}
protected void BtnCalcular_OnClick(object sender, EventArgs e)
{
var coches = DAOFactory.CocheDAO.GetList(new[] { ddlEmpresa.Selected }, new[] { ddlPlanta.Selected })
.Where(c => ddlMovil.SelectedValues.Contains(c.Id) || QueryExtensions.IncludesAll((IEnumerable <int>)ddlMovil.SelectedValues))
.ToList();
CalcularReportes(coches);
LoadLabelsHoy();
LoadGaugesHoy();
divHoy.Visible = true;
}