internal BitwiseExpression this[ExpressionKind type]
{
get
{
if (!type.IsBitwise())
{
throw new InvalidEnumArgumentException(nameof(type), (int)type, typeof(ExpressionKind));
}
if (_operations.ContainsKey(type))
{
return(_operations[type]);
}
Type concreteType = Type.GetType(GetType().Namespace + "." + Enum.GetName(typeof(ExpressionKind), type) + "Expression");
if ((concreteType == null) || !concreteType.IsBitwiseExpression())
{
throw new InvalidBitwiseTypeException();
}
BitwiseExpression obj = (BitwiseExpression)Activator.CreateInstance(concreteType);
_operations.Add(type, obj);
return(obj);
}
}
public virtual IList <long> GetProjectIds(BookTypeEnum bookType, int userId, ProjectTypeEnum projectType, IList <long> projectIds,
IList <int> categoryIds)
{
Project projectAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var query = GetSession().QueryOver <Snapshot>()
.JoinAlias(x => x.Project, () => projectAlias)
.JoinAlias(x => x.BookTypes, () => bookTypeAlias)
.JoinAlias(() => projectAlias.Categories, () => categoryAlias, JoinType.LeftOuterJoin)
.JoinAlias(() => projectAlias.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.And(() => bookTypeAlias.Type == bookType && userAlias.Id == userId && projectAlias.ProjectType == projectType && projectAlias.IsRemoved == false)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.Select(Projections.Distinct(Projections.Property(() => projectAlias.Id)));
if (projectIds != null && categoryIds != null)
{
query = query.Where(Restrictions.Or(
Restrictions.InG(Projections.Property(() => projectAlias.Id), projectIds),
Restrictions.InG(Projections.Property(() => categoryAlias.Id), categoryIds)
));
}
return(query.List <long>());
}
public override Object Visit(BitwiseExpression node, Object obj)
{
node.FirstOperand.Accept(this, obj);
node.SecondOperand.Accept(this, obj);
return(null);
}
public void NotHasBit_WithMatch_ReturnsMatchedUser()
{
CreateUser(Permissions.Read);
var criteria = BitwiseExpression.On <User>(x => x.Permissions).NotHasBit(Permissions.Write);
var users = Query(session => session.QueryOver <User>().Where(criteria).List());
Assert.That(users.Count == 1);
}
public void HasBit_WithoutMatch_ReturnsNoUser()
{
CreateUser(Permissions.Read | Permissions.Full);
var criteria = BitwiseExpression.On <User>(x => x.Permissions).HasBit(Permissions.Write);
var users = Query(session => session.QueryOver <User>().Where(criteria).List());
Assert.IsEmpty(users);
}
public override Object Visit(BitwiseExpression node, Object obj)
{
Expression clonedFirstOperand = (Expression)node.FirstOperand.Accept(this, obj);
Expression clonedSecondOperand = (Expression)node.SecondOperand.Accept(this, obj);
BitwiseExpression clonedBitwiseExpression = new BitwiseExpression(clonedFirstOperand, clonedSecondOperand, node.Operator, node.Location);
return(clonedBitwiseExpression);
}
public void MaskNotMatch_ReturnsNoUser()
{
CreateUser(Permissions.Read | Permissions.Write | Permissions.Full);
var permissionValue = Permissions.Read | Permissions.Write;
var criteria = BitwiseExpression.On <User>(x => x.Permissions).NotHasBit(permissionValue);
var users = Query(session => session.QueryOver <User>().Where(criteria).List());
Assert.That(users.Count == 0);
}
public virtual int GetRequiredPermissionCountForProject(long projectId, PermissionFlag requiredPermission)
{
var resultCount = GetSession().QueryOver <Permission>()
.Where(x => x.Project.Id == projectId)
.And(BitwiseExpression.On <Permission>(x => x.Flags).HasBit(requiredPermission))
.RowCount();
return(resultCount);
}
public override object Visit(BitwiseExpression node, object obj)
{
if (node.Location == ((AstNode)obj).Location || found)
{
found = true;
return(this.table);
}
return(base.Visit(node, obj));
}
public virtual ListWithTotalCountResult <Project> GetProjectList(int start, int count, ProjectTypeEnum?projectType,
string filterByName = null, int?includeUserId = null, int?excludeUserId = null)
{
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var query = GetSession().QueryOver <Project>()
.Where(x => x.IsRemoved == false)
.Fetch(SelectMode.Fetch, x => x.CreatedByUser);
if (projectType != null)
{
query.Where(x => x.ProjectType == projectType.Value);
}
if (!string.IsNullOrEmpty(filterByName))
{
query.WhereRestrictionOn(x => x.Name).IsInsensitiveLike(filterByName, MatchMode.Anywhere);
}
var permissionSubquery = QueryOver.Of <Project>()
.JoinAlias(x => x.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ReadProject));
if (includeUserId != null)
{
query.WithSubquery.WhereProperty(x => x.Id)
.In(permissionSubquery.Where(() => userAlias.Id == includeUserId.Value)
.Select(x => x.Id));
}
if (excludeUserId != null)
{
query.WithSubquery.WhereProperty(x => x.Id)
.NotIn(permissionSubquery.Where(() => userAlias.Id == excludeUserId.Value)
.Select(x => x.Id));
}
query.OrderBy(x => x.Name).Asc
.Skip(start)
.Take(count);
var list = query.Future();
var totalCount = query.ToRowCountQuery().FutureValue <int>();
return(new ListWithTotalCountResult <Project>
{
List = list.ToList(),
Count = totalCount.Value
});
}
public void HasAny_WithMatch_ReturnsMatchedUsers()
{
CreateUser(Permissions.Read | Permissions.Write | Permissions.Full);
CreateUser(Permissions.Write);
CreateUser(Permissions.Read);
var criteria = BitwiseExpression.On <User>(x => x.Permissions).HasAny(Permissions.Read, Permissions.Write);
var users = Query(session => session.QueryOver <User>().Where(criteria).List());
Assert.That(users.Count == 3);
}
public virtual IList <string> GetTitleAutocomplete(string queryString, BookTypeEnum?bookType, ProjectTypeEnum?projectType,
IList <int> selectedCategoryIds, IList <long> selectedProjectIds, int count, int userId)
{
queryString = EscapeQuery(queryString);
Resource resourceAlias = null;
Project projectAlias = null;
Snapshot snapshotAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
BookType bookTypeAlias = null;
Category categoryAlias = null;
var query = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.JoinAlias(() => resourceAlias.Project, () => projectAlias)
.JoinAlias(() => projectAlias.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => projectAlias.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved && userAlias.Id == userId && projectAlias.IsRemoved == false)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.AndRestrictionOn(x => x.Title).IsLike(queryString, MatchMode.Anywhere)
.Select(Projections.Distinct(Projections.Property <MetadataResource>(x => x.Title)))
.OrderBy(x => x.Title).Asc;
if (bookType != null)
{
query.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookType.Value);
}
if (projectType != null)
{
query.Where(() => projectAlias.ProjectType == projectType.Value);
}
if (selectedCategoryIds.Count > 0 || selectedProjectIds.Count > 0)
{
query.JoinAlias(() => projectAlias.Categories, () => categoryAlias, JoinType.LeftOuterJoin)
.Where(Restrictions.Or(
Restrictions.InG(Projections.Property(() => categoryAlias.Id), selectedCategoryIds),
Restrictions.InG(Projections.Property(() => projectAlias.Id), selectedProjectIds)
));
}
return(query
.Take(count)
.List <string>());
}
public virtual Resource GetResourceByUserGroupPermissions(int groupId, long resourceId, PermissionFlag permission)
{
Resource resourceAlias = null;
Project projectAlias = null;
Permission permissionAlias = null;
UserGroup groupAlias = null;
var filteredResource = GetSession().QueryOver(() => resourceAlias)
.JoinQueryOver(x => x.Project, () => projectAlias)
.JoinQueryOver(x => x.Permissions, () => permissionAlias)
.JoinQueryOver(x => x.UserGroup, () => groupAlias)
.Where(() => groupAlias.Id == groupId && resourceAlias.Id == resourceId && projectAlias.IsRemoved == false)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(permission))
.SingleOrDefault();
return(filteredResource);
}
public virtual IList <long> GetFilteredBookIdListByGroupPermissions(int groupId, IEnumerable <long> bookIds, PermissionFlag permission)
{
Project projectAlias = null;
Permission permissionAlias = null;
UserGroup groupAlias = null;
var filteredBookIds = GetSession().QueryOver(() => projectAlias)
.JoinQueryOver(x => x.Permissions, () => permissionAlias)
.JoinQueryOver(x => permissionAlias.UserGroup, () => groupAlias)
.Select(Projections.Distinct(Projections.Property(() => projectAlias.Id)))
.Where(() => groupAlias.Id == groupId && projectAlias.IsRemoved == false)
.AndRestrictionOn(() => projectAlias.Id).IsInG(bookIds)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(permission))
.List <long>();
return(filteredBookIds);
}
public override Object Visit(BitwiseExpression node, Object obj)
{
int indent = Convert.ToInt32(obj);
this.printIndentation(indent);
this.output.Write("BitwiseExpression ");
switch (node.Operator)
{
case BitwiseOperator.BitwiseOr: this.output.Write("|"); break;
case BitwiseOperator.BitwiseAnd: this.output.Write("&"); break;
case BitwiseOperator.BitwiseXOr: this.output.Write("^"); break;
case BitwiseOperator.ShiftLeft: this.output.Write("<<"); break;
case BitwiseOperator.ShiftRight: this.output.Write(">>"); break;
}
this.output.WriteLine(" Type: {0} [{1}:{2}]", printType(node.ExpressionType), node.Location.Line, node.Location.Column);
node.FirstOperand.Accept(this, indent + 1);
node.SecondOperand.Accept(this, indent + 1);
return(null);
}
public CGBitwiseOperation(VisitorILCodeGeneration <T> visitor, object obj, int indent, BitwiseExpression node) : base(visitor, obj, indent, node)
{
}
public void VisitBitwiseExpression(BitwiseExpression bitwiseExpression)
{
VisitExpression(bitwiseExpression.Left);
object left = ReturnValue;
VisitExpression(bitwiseExpression.Right);
object right = ReturnValue;
ReturnValue = double.NaN;
if (left != null && right != null) {
switch (bitwiseExpression.Operator) {
case TokenType.BitOr:
int i = ConvertToInteger(left) | ConvertToInteger(right);
if (i != 0)
ReturnValue = (double)i;
break;
case TokenType.BitXor:
int j = ConvertToInteger(left) ^ ConvertToInteger(right);
if (j != 0)
ReturnValue = (double)j;
break;
case TokenType.BitAnd:
int k = ConvertToInteger(left) & ConvertToInteger(right);
if (k != 0)
ReturnValue = (double)k;
break;
}
}
}
public virtual IList <MetadataResource> GetMetadataByBookTypeWithCategories(BookTypeEnum bookTypeEnum, int userId, ProjectTypeEnum projectType,
int start, int count)
{
Resource resourceAlias = null;
Snapshot snapshotAlias = null;
BookType bookTypeAlias = null;
Permission permissionAlias = null;
UserGroup userGroupAlias = null;
User userAlias = null;
var resultList = GetSession().QueryOver <MetadataResource>()
.JoinAlias(x => x.Resource, () => resourceAlias)
.Where(x => x.Id == resourceAlias.LatestVersion.Id && !resourceAlias.IsRemoved)
.WithSubquery.WhereProperty(() => resourceAlias.Project.Id).In(QueryOver.Of <Project>()
.Where(x => x.ProjectType == projectType && x.IsRemoved == false)
.JoinAlias(x => x.LatestPublishedSnapshot, () => snapshotAlias)
.JoinAlias(() => snapshotAlias.BookTypes, () => bookTypeAlias)
.Where(() => bookTypeAlias.Type == bookTypeEnum)
.JoinAlias(x => x.Permissions, () => permissionAlias)
.JoinAlias(() => permissionAlias.UserGroup, () => userGroupAlias)
.JoinAlias(() => userGroupAlias.Users, () => userAlias)
.Where(() => userAlias.Id == userId)
.And(BitwiseExpression.On(() => permissionAlias.Flags).HasBit(PermissionFlag.ShowPublished))
.Select(x => x.Id))
.OrderBy(x => x.Title).Asc
.Skip(start)
.Take(count)
.List();
GetSession().QueryOver <Project>()
.WhereRestrictionOn(x => x.Id).IsInG(resultList.Select(x => x.Resource.Project.Id))
.Fetch(SelectMode.Fetch, x => x.Categories)
.List();
return(resultList);
}
public abstract Object Visit(BitwiseExpression node, Object obj);
