/// <summary> /// The function may return permissions for more claims than required. /// </summary> public IEnumerable <PrincipalPermissionInfo> GetPrincipalPermissions(IPrincipal principal, IEnumerable <Guid> claimIds = null) { CsUtility.Materialize(ref claimIds); if (claimIds != null && !claimIds.Any()) { return(Enumerable.Empty <PrincipalPermissionInfo>()); } var query = _principalPermissionRepository.Query() .Where(principalPermission => principalPermission.IsAuthorized != null && principalPermission.PrincipalID == principal.ID); if (claimIds != null && claimIds.Count() < _sqlFilterItemsLimit) { query = query.Where(principalPermission => claimIds.Contains(principalPermission.ClaimID.Value)); } return(query.Select(principalPermission => new PrincipalPermissionInfo { ID = principalPermission.ID, PrincipalID = principalPermission.PrincipalID.Value, ClaimID = principalPermission.ClaimID.Value, IsAuthorized = principalPermission.IsAuthorized.Value, }) .ToList()); }
/// <summary> /// Query all data of specific type. /// This is only a projection, actual query will be done after materialization from IQueryable<TValue> /// </summary> /// <typeparam name="TValue">data type</typeparam> /// <param name="repository">queryable repository</param> /// <returns>projection to data</returns> public static IQueryable <TValue> Query <TValue>(this IQueryableRepository <TValue> repository) where TValue : IDataSource { Contract.Requires(repository != null); return(repository.Query <TValue>(null)); }
public static IQueryable <TQueryableEntity> Query <TQueryableEntity, TParameter>(this IQueryableRepository <TQueryableEntity> repository, TParameter parameter) where TQueryableEntity : class, IEntity { Type filterType = parameter != null?parameter.GetType() : typeof(TParameter); return(repository.Query(parameter, filterType)); }
private Guid GetPrincipalID(string username) { return(_principalRepository.Query() .Where(p => p.Name == username) .Select(p => p.ID) .SingleOrDefault()); }
private static void TestGroup <TEntity, TGroup>( RhetosTestContainer container, IQueryableRepository <IEntity> entityRepository, TGroup group, string format, string expectedCode) where TEntity : class, IEntity, new() { var writeableRepository = (IWritableRepository <TEntity>)entityRepository; Guid id = Guid.NewGuid(); dynamic entity = new TEntity(); entity.ID = id; entity.Code = format; try { entity.Grouping = group; } catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException) { entity.GroupingID = ((dynamic)group).ID; } writeableRepository.Insert((TEntity)entity); var query = entityRepository.Query().Where(e => e.ID == id); Console.WriteLine(query.GetType().FullName); Console.WriteLine(query.Expression.ToString()); Console.WriteLine(query.ToString()); dynamic loaded = query.Single(); string generatedCode = loaded.Code; Console.WriteLine(format + " => " + generatedCode); Assert.AreEqual(expectedCode, generatedCode); }
/// <summary> /// The function may return permissions for more claims than required. /// </summary> public IEnumerable <RolePermissionInfo> GetRolePermissions(IEnumerable <Guid> roleIds, IEnumerable <Guid> claimIds = null) { CsUtility.Materialize(ref roleIds); CsUtility.Materialize(ref claimIds); if (!roleIds.Any() || (claimIds != null && !claimIds.Any())) { return(Enumerable.Empty <RolePermissionInfo>()); } var query = _rolePermissionRepository.Query() .Where(rolePermission => rolePermission.IsAuthorized != null && roleIds.Contains(rolePermission.RoleID.Value)); if (claimIds != null && claimIds.Count() < _sqlFilterItemsLimit) { query = query.Where(rolePermission => claimIds.Contains(rolePermission.ClaimID.Value)); } return(query.Select(rolePermission => new RolePermissionInfo { ID = rolePermission.ID, RoleID = rolePermission.RoleID.Value, ClaimID = rolePermission.ClaimID.Value, IsAuthorized = rolePermission.IsAuthorized.Value, }) .ToList()); }
public static IQueryable <TSource> Find <TSource, TCondition>( this IQueryableRepository <TSource> repository, Expression <Func <TCondition, bool> > condition) where TSource : TCondition where TCondition : IDataSource { return(repository.Query(new SpecificationByExpression <TCondition>(condition))); }
private void CheckInvalid() { if (Invalid) { Invalid = false; Data = Repository.Query().ToList().ToDictionary(it => it.URI, it => it); } }
public Stream OdobreneKade(int offset, int limit) { limit = limit == 0 ? 100 : Math.Min(limit, 100); var kade = Kade.Query(new KadaIzvorPodataka.OdobreneKade()).Skip(offset).Take(limit).ToList(); return(Serialize(Locator, kade)); }
public static IEnumerable <TQueryableEntity> LoadOldDataWithNavigationProperties <TQueryableEntity>(IEnumerable <IEntity> items, IQueryableRepository <TQueryableEntity> repository) where TQueryableEntity : class, IEntity { var loaded = items.Any() ? repository.Query(items.Select(item => item.ID)).ToList() : new List <TQueryableEntity>(); Graph.SortByGivenOrder(loaded, items.Select(item => item.ID), item => item.ID); return(loaded); }
/// <summary> /// Note that the result will not include roles that do not exist, and that the order of returned items might not match the parameter. /// </summary> public IDictionary <Guid, string> GetRoles(IEnumerable <Guid> roleIds = null) { CsUtility.Materialize(ref roleIds); if (roleIds != null && !roleIds.Any()) { return(new Dictionary <Guid, string>()); } var query = _roleRepository.Query(); if (roleIds != null) { query = query.Where(role => roleIds.Contains(role.ID)); } return(query .Select(role => new { role.ID, role.Name }) // This select avoids loading extra columns from database. .ToDictionary(role => role.ID, role => role.Name)); }
/// <summary> /// The function may return more claims than required. /// Note that the result will not include claims that are inactive or do not exist, and that the order of returned items might not match the parameter. /// </summary> public IDictionary <Claim, ClaimInfo> GetClaims(IEnumerable <Claim> requiredClaims = null) { CsUtility.Materialize(ref requiredClaims); if (requiredClaims != null && requiredClaims.Count() == 0) { return(new Dictionary <Claim, ClaimInfo>()); } var queryClaims = _claimRepository.Query().Where(claim => claim.Active != null && claim.Active.Value); if (requiredClaims != null) { var claimsResources = requiredClaims.Select(claim => claim.Resource).Distinct().ToList(); var claimsRights = requiredClaims.Select(claim => claim.Right).Distinct().ToList(); if (claimsResources.Count < _sqlFilterItemsLimit && claimsRights.Count < _sqlFilterItemsLimit) { queryClaims = queryClaims.Where(claim => claimsResources.Contains(claim.ClaimResource) && claimsRights.Contains(claim.ClaimRight)); } } var loadedClaims = queryClaims .Select(claim => new ClaimInfo { ID = claim.ID, Resource = claim.ClaimResource, Right = claim.ClaimRight }) .ToList(); Dictionary <Claim, ClaimInfo> claimsIndex; try { claimsIndex = loadedClaims.ToDictionary(item => new Claim(item.Resource, item.Right)); } catch { var duplicates = loadedClaims.GroupBy(item => new Claim(item.Resource, item.Right)) .Where(g => g.Count() > 1) .FirstOrDefault(); if (duplicates != null) { throw new FrameworkException(string.Format("Loaded duplicate claims: '{0} {1}' and '{2} {3}'.", duplicates.First().Resource, duplicates.First().Right, duplicates.Last().Resource, duplicates.Last().Right)); } throw; } return(claimsIndex); }
private void ProcessAll() { try { bool shouldRetry; lock (sync) { var notSent = Repository.Query(new NotSentSpecification()).ToList(); if (notSent.Count > 0) { TraceSource.TraceEvent( TraceEventType.Verbose, 1011, "Processing mail queue items ({0}): {1}", notSent.Count, string.Join(", ", notSent.Select(it => it.URI))); } else { TraceSource.TraceEvent(TraceEventType.Verbose, 1011, "Mail queue empty"); } shouldRetry = notSent.Any(it => !MailService.TrySend(it.URI)); } if (shouldRetry) { for (int i = 0; i < 10; i++) { if (!IsAlive) { break; } Thread.Sleep(TimeSpan.FromSeconds(6)); } } } catch (Exception ex) { TraceSource.TraceEvent(TraceEventType.Critical, 1011, "{0}", ex); var mm = new System.Net.Mail.MailMessage(FromEmail, ToAdminEmail) { Subject = "Fatal error sending email", Body = ex.ToString() }; try { Revenj.Features.Mailer.MailService.SendNow(mm); } catch (Exception sendEx) { mm.Body += Environment.NewLine + sendEx.ToString(); try { MailService.TrySend(MailService.Queue(mm)); } catch { } } Stop(); } }
/// <summary> /// Note that the result will not include roles that do not exist, and that the order of returned items might not match the parameter. /// </summary> public IDictionary <Guid, string> GetRoles(IEnumerable <Guid> roleIds = null) { CsUtility.Materialize(ref roleIds); if (roleIds != null && roleIds.Count() == 0) { return(new Dictionary <Guid, string>()); } var query = _roleRepository.Query(); if (roleIds != null) { query = query.Where(role => roleIds.Contains(role.ID)); } return(query .Select(role => new { ID = role.ID, Name = role.Name }) .ToList() .ToDictionary(role => role.ID, role => role.Name)); }
public static IQueryable <TResource> Query <TResource>(this IQueryableRepository <TResource> repository, Expression <Func <TResource, bool> > predicate) where TResource : class, IClientResource { return(repository.Query().Where(predicate)); }
private object QueryCovarianceIEntity(IQueryableRepository <IEntity> repository, Guid id) { return(repository.Query().Where(item => item.ID == id).FirstOrDefault()); }
private object QueryCovarianceGeneric <TEntity>(IQueryableRepository <TEntity> repository, Guid id) where TEntity : class, IEntity { return(repository.Query().Where(item => item.ID == id).FirstOrDefault()); }
public static IQueryable <global::UseCase1.SelectedSubmission> Where(this IQueryableRepository <global::UseCase1.SelectedSubmission> repository, string uri) { return(repository.Query(new global::UseCase1.SelectedSubmission.Where(uri: uri))); }
public static IQueryable <TQueryableEntity> Query <TQueryableEntity>(this IQueryableRepository <TQueryableEntity> repository, Expression <Func <TQueryableEntity, bool> > filter) where TQueryableEntity : class, IEntity { return(repository.Query(null, typeof(FilterAll)).Where(filter)); }
public static IQueryable <TQueryableEntity> Query <TQueryableEntity>(this IQueryableRepository <TQueryableEntity> repository) where TQueryableEntity : class, IEntity { return(repository.Query(null, typeof(FilterAll))); }
public IEnumerable <Guid> GetRoleRoles(Guid roleId) { return(_roleRolesRepository.Query().Where(rr => rr.UsersFromID == roleId).Select(rr => rr.PermissionsFromID.Value).ToList()); }
public IEnumerable <Guid> GetPrincipalRoles(IPrincipal principal) { return(_principalRolesRepository.Query(principal).Select(pr => pr.RoleID.Value).ToList()); }
public static IQueryable <global::Test.XYZ> FindBy(this IQueryableRepository <global::Test.XYZ> repository, string from) { return(repository.Query(new global::Test.XYZ.FindBy(from: from))); }
public static IQueryable <global::FormABC.Input> Where(this IQueryableRepository <global::FormABC.Input> repository, string submissionURI) { return(repository.Query(new global::FormABC.Input.Where(submissionURI: submissionURI))); }