/// <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)));
}