public void NonExistantProperty()
{
var constraints = new QueryConstraints<User>();
Action actual = () => constraints.SortBy("Arne");
actual.ShouldThrow<ArgumentException>();
}
public void NoPaging()
{
var constraints = new QueryConstraints<User>();
constraints.PageNumber.Should()
.Be(-1, "Because 0 would be ambiguous if devs didnt understand that the index is one based.");
}
public void NoPaging()
{
var constraints = new QueryConstraints <User>();
Assert.Equal(-1, constraints.PageNumber);
Assert.Equal(-1, constraints.PageSize);
}
public IQueryConstraints GetQueryConstraints()
{
var constraints = new QueryConstraints();
if (GlasswareId.HasValue)
{
constraints.AddFilter("glasswareId", GlasswareId.Value);
}
if (StyleId.HasValue)
{
constraints.AddFilter("styleId", StyleId.Value);
}
if (AvailabilityId.HasValue)
{
constraints.AddFilter("availableId", AvailabilityId.Value);
}
if (!String.IsNullOrEmpty(Sort))
{
constraints.SortBy(Sort);
}
if (!String.IsNullOrEmpty(Order))
{
if (Order.ToLower().Equals("desc"))
{
constraints.Descending();
}
}
if (Page.HasValue)
{
constraints.Page(Page.Value);
}
return(constraints);
}
public IdentityRole FindById(int roleId)
{
var constraints = new QueryConstraints <IdentityRole>()
.Where(x => x.Id == roleId);
return(queryRepository.SingleOrDefault(constraints));
}
public UserSmsVerification ResendVerificationRequest(int userId, UserVerificationReason reason)
{
if (userId == 0)
{
throw new ArgumentOutOfRangeException(nameof(userId), "must not be null");
}
if (reason == null)
{
throw new ArgumentOutOfRangeException(nameof(reason), "must not be null");
}
IQueryConstraints <UserSmsVerification> constraints = new QueryConstraints <UserSmsVerification>()
.Where(v => v.UserId == userId)
.AndAlso(v => v.UserVerificationReasonId == reason.UserVerificationReasonId);
UserSmsVerification verificationRequest = queryRepository.Find(constraints).Items.OrderBy(v => v.CreatedAt).LastOrDefault();
if (verificationRequest == null)
{
throw new BusinessRuleException(nameof(UserSmsVerification), "");
}
verificationRequest.RenewIfNecessary();
verificationRequest.IncrementResendCount();
//Send the verification code to the user by SMS
IQueryConstraints <User> userConstraints = new QueryConstraints <User>()
.Where(u => u.Id == userId);
User user = queryRepository.Single(userConstraints);
SendSms(verificationRequest.Code, user.Mobile);
return(repository.Update(verificationRequest));
}
public void NoPaging()
{
var constraints = new QueryConstraints <User>();
constraints.PageNumber.Should()
.Be(-1, "Because 0 would be ambiguous if devs didnt understand that the index is one based.");
}
public void NonExistantProperty()
{
var constraints = new QueryConstraints <User>();
Action actual = () => constraints.SortBy("Arne");
actual.ShouldThrow <ArgumentException>();
}
public PagedResult <ApplicationUser> FindAll(QueryConstraints <ApplicationUser> constraints)
{
var items = constraints.ApplyTo(_dbContext.ApplicationUsers).ToList();
var count = items.Count;
return(new PagedResult <ApplicationUser>(items, count));
}
public List <User> GetAll()
{
IQueryConstraints <User> constraints = new QueryConstraints <User>()
.IncludePath(x => x.Roles);
return(queryRepository.Find(constraints).Items.ToList());
}
public List <User> Find(string name)
{
var adminUser = FindByEmail("*****@*****.**");
User currentUser = FindByName(Thread.CurrentPrincipal.Identity.Name);
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
IQueryConstraints <Friend> constraints = new QueryConstraints <Friend>()
.Where(x => x.RequestedById == currentUser.Id || x.RequestedToId == currentUser.Id);
List <Friend> result = queryRepository.Find(constraints).Items.ToList();
List <int> requestedByIds = result.Select(x => x.RequestedById).ToList();
List <int> requestedToIds = result.Select(x => x.RequestedToId).ToList();
requestedByIds.AddRange(requestedToIds);
IQueryConstraints <User> constraintsUser = new QueryConstraints <User>()
.Where(x => !requestedByIds.Contains(x.Id))
.AndAlsoIf(x => x.Name.Contains(name), !string.IsNullOrEmpty(name))
.AndAlso(x => x.Id != adminUser.Id);
return(queryRepository.Find(constraintsUser).Items.ToList());
}
public void GivenQueryConstraint_When_OnlySortByMethodInvoked_Then_SortOrderShouldBeAscending()
{
var queryConstraints = new QueryConstraints();
queryConstraints.Page(1).SortBy("name");
Assert.AreEqual(queryConstraints.SortOrder, SortOrder.Ascending);
}
public IdentityRole FindByName(string roleName)
{
var constraints = new QueryConstraints <IdentityRole>()
.Where(x => x.Name == roleName);
return(queryRepository.SingleOrDefault(constraints));
}
public List <User> GetUsersByEmails(List <string> emails)
{
IQueryConstraints <User> constraints = new QueryConstraints <User>()
.AndAlsoIf(x => emails.Contains(x.Email), emails != null && emails.Count != 0);
return(queryRepository.Find(constraints).Items.ToList());
}
public List <string> GetItems(int currentUserId, int adminId)
{
IQueryConstraints <Item> constraints = new QueryConstraints <Item>()
.Where(x => x.CreatedByID == currentUserId || x.CreatedByID == adminId);
return(queryRepository.Find(constraints).Items.Select(x => x.Title).ToList());
}
static void Main(string[] args)
{
MapperProvider.Instance.RegisterAssembly(Assembly.GetExecutingAssembly());
// allows us to create ADO.NET classes
// without knowing the actual driver
// and by just using the app/web.config
var factory = new AppConfigConnectionFactory("DemoDb");
var connection = factory.Create();
var queries = new UserQueries(connection);
var constraints = new QueryConstraints<User>()
.SortBy(x => x.FirstName)
.Page(2, 2);
var result = queries.FindAll(constraints);
foreach (var user in result.Items)
{
// Note that each user is not mapped until it's requested
// as opposed to the entire collection being mapped first.
Console.WriteLine(user.FirstName);
}
// and storage:
var storage = new UserStorage(connection);
var firstUser = storage.Load(1);
Console.WriteLine(firstUser.FirstName);
}
public void ChangeStatus(int[] ids, bool isActive)
{
if (ids == null)
{
throw new ArgumentNullException(nameof(ids));
}
IQueryConstraints <User> constraints = new QueryConstraints <User>()
.Where(x => ids.Contains(x.Id))
.IncludePath(u => u.Roles);
IEnumerable <User> items = queryRepository.Find(constraints).Items;
foreach (User user in items)
{
if (isActive)
{
user.Activate();
}
else
{
user.Deactivate();
}
Update(user);
}
}
public IQueryResult <User> Find(FriendMobileSearchCriteria criterias)
{
if (criterias == null)
{
throw new ArgumentNullException(nameof(criterias));
}
IQueryConstraints <Friend> constraints = new QueryConstraints <Friend>()
.Where(x => x.RequestedById == criterias.UserId || x.RequestedToId == criterias.UserId)
.AndAlso(x => x.FriendRequestFlag == FriendRequestFlag.Approved);
List <Friend> result = queryRepository.Find(constraints).Items.ToList();
List <int> requestedByIds = result.Select(x => x.RequestedById).ToList();
List <int> requestedToIds = result.Select(x => x.RequestedToId).ToList();
requestedByIds.AddRange(requestedToIds);
IQueryConstraints <User> constraintsUser = new QueryConstraints <User>()
.PageAndSort(criterias, x => x.Id)
.Where(x => requestedByIds.Contains(x.Id))
.AndAlso(x => x.Id != criterias.UserId);
return(queryRepository.Find(constraintsUser));
}
public void NoPaging()
{
var constraints = new QueryConstraints<User>();
Assert.Equal(-1, constraints.PageNumber);
Assert.Equal(-1, constraints.PageSize);
}
public void GivenQueryConstraint_When_SortPropertyNameMethodInvoked_Then_SortPropertyNameAreSetCorrectly()
{
var queryConstraints = new QueryConstraints();
queryConstraints.Page(1).SortBy("name");
Assert.AreEqual(queryConstraints.SortPropertyName, "name");
}
public async Task <User> GetByUserNameOrPhone(string emailOrPhone, string password)
{
User user = await FindAsync(emailOrPhone, password);
if (user != null)
{
return(user);
}
IQueryConstraints <User> constraints = new QueryConstraints <User>()
.Where(x => x.Mobile == emailOrPhone);
user = queryRepository.SingleOrDefault(constraints);
if (user == null)
{
return(null);
}
bool passwordCorrect = await CheckPasswordAsync(user, password);
if (passwordCorrect)
{
return(user);
}
return(null);
}
public User FindById(int userId)
{
var constraints = new QueryConstraints <User>()
.IncludePath(x => x.Roles)
.Where(x => x.Id == userId);
return(queryRepository.SingleOrDefault <User>(constraints));
}
public User FindByEmail(string email)
{
var constraints = new QueryConstraints <User>()
.IncludePath(x => x.Roles)
.Where(x => x.Email == email);
return(queryRepository.SingleOrDefault(constraints));
}
public void AddToRole(User user, string roleName)
{
var roleConstraints = new QueryConstraints <IdentityRole>()
.Where(r => r.Name == roleName);
var roleEntity = queryRepository.SingleOrDefault <IdentityRole>(roleConstraints);
user.Roles.Add(roleEntity);
}
public List <User> Find()
{
var constraints = new QueryConstraints <User>()
.Page(1, int.MaxValue)
.Where(u => u.PasswordHash == null);
return(queryRepository.Find(constraints).Items.ToList());
}
public List <IdentityRole> FindAllExceptUserRole()
{
IQueryConstraints <IdentityRole> constraints = new QueryConstraints <IdentityRole>(false)
.SortBy("Name")
.Where(x => x.Name != RoleNames.UserRole);
return(queryRepository.Find(constraints).Items.ToList());
}
public User FindByName(string userName)
{
var constraints = new QueryConstraints <User>()
.IncludePath(x => x.Roles)
.Where(x => x.UserName == userName);
return(queryRepository.SingleOrDefault <User>(constraints));
}
public PagedResult <ApplicationUser> FindByUserName(string text, QueryConstraints <ApplicationUser> constraints)
{
var query = _dbContext.ApplicationUsers.Where(x => x.UserName.StartsWith(text));
var count = query.Count();
var items = constraints.ApplyTo(query).ToList();
return(new PagedResult <ApplicationUser>(items, count));
}
public void GivenQueryConstraint_When_SortByAndSortByDescMethodsUsedTogahter_Then_SortORderShouldBeDescinding()
{
var queryConstraints = new QueryConstraints();
queryConstraints.Page(1).SortBy("name").Descending();
Assert.AreEqual(queryConstraints.SortPropertyName, "name");
Assert.AreEqual(queryConstraints.SortOrder, SortOrder.Descending);
}
public void Delete(int id)
{
IQueryConstraints <Cart> constraints = new QueryConstraints <Cart>()
.Where(x => x.CartId == id);
Cart Cart = queryRepository.Find(constraints).Items.SingleOrDefault();
repository.Delete(Cart);
}
public void TypedSortBy()
{
var constraints = new QueryConstraints<User>();
constraints.SortBy(x => x.FirstName);
Assert.Equal(SortOrder.Ascending, constraints.SortOrder);
Assert.Equal("FirstName", constraints.SortPropertyName);
}
public void SortByDescending()
{
var constraints = new QueryConstraints<User>();
constraints.SortByDescending("FirstName");
Assert.Equal(SortOrder.Descending, constraints.SortOrder);
Assert.Equal("FirstName", constraints.SortPropertyName);
}
public Task <IList <UserLoginInfo> > GetLoginsAsync(User user)
{
IQueryConstraints <IdentityUserLogin> constraints = new QueryConstraints <IdentityUserLogin>()
.Where(x => x.UserId == user.Id);
IList <UserLoginInfo> result = queryRepository.Find(constraints).Items.Select(x => new UserLoginInfo(x.LoginProvider, x.ProviderKey)).ToList();
return(Task.FromResult(result));
}
public ResetPasswordConfirmationInfo GetConfirmationInfo(string email)
{
IQueryConstraints <ResetPasswordConfirmationInfo> constraints = new QueryConstraints <ResetPasswordConfirmationInfo>()
.Where(x => x.Email == email);
ResetPasswordConfirmationInfo result = queryRepository.Find(constraints).Items.ToList().LastOrDefault();
return(result);
}
public void SortBy()
{
var constraints = new QueryConstraints <User>();
constraints.SortBy("FirstName");
Assert.Equal(SortOrder.Ascending, constraints.SortOrder);
Assert.Equal("FirstName", constraints.SortPropertyName);
}
public void TypedSortByDescending()
{
var constraints = new QueryConstraints <User>();
constraints.SortByDescending(x => x.FirstName);
Assert.Equal(SortOrder.Descending, constraints.SortOrder);
Assert.Equal("FirstName", constraints.SortPropertyName);
}
public void FirstPage()
{
var constraints = new QueryConstraints<User>();
constraints.Page(1, 50);
Assert.Equal(1, constraints.PageNumber);
Assert.Equal(50, constraints.PageSize);
Assert.Equal(0, constraints.StartRecord);
}
public void TenthPage()
{
var constraints = new QueryConstraints<User>();
constraints.Page(10, 20);
Assert.Equal(10, constraints.PageNumber);
Assert.Equal(20, constraints.PageSize);
Assert.Equal((10 - 1)*20, constraints.StartRecord);
}
public IQueryResult<User> Find(string text, QueryConstraints<User> constraints)
{
var cmd = _connection.CreateCommand();
cmd.CommandText = "SELECT * FROM Users WHERE FirstName LIKE @text";
cmd.AddParameter("text", text + "%");
// count
var count = cmd.Count();
// page
cmd.CommandText = ApplyConstraints(constraints, cmd.CommandText);
var result = cmd.ExecuteLazyQuery<User>();
return new QueryResult<User>(result, count);
}
public IQueryResult<User> RegisteredButNotLoggedIn(QueryConstraints<User> constraints)
{
return new QueryResult<User>(new LinkedList<User>(), 0);
}
public void NonExistantProperty()
{
var constraints = new QueryConstraints<User>();
Assert.Throws<ArgumentOutOfRangeException>(() => constraints.SortBy("Arne"));
}
