Ejemplo n.º 1
0
        public async Task <List <Currency> > GetUserDefaultCurrencies(string username)
        {
            var userSpec = new UserSpecification(username, true);
            var user     = (await _userRepository.ListAsync(userSpec)).FirstOrDefault();

            return(user?.UserCurrencyMapping.Select(x => x.Currency).ToList());
        }
Ejemplo n.º 2
0
 public async Task <List <UserSpecification> > GetShopFavouriteSpecificationAsync(string ShopId, string openIds)
 {
     EnsureConnectionOpen();
     SqlParameter[] sql = new SqlParameter[]
     {
         new SqlParameter("@ShopId", ShopId),
         new SqlParameter("@OpenIdIds", openIds)
     };
     //using (var command = CreateCommand("select* from(select ROW_NUMBER() over(partition by NickName order by num desc) gnum, *from(select WeChatUsers.NickName, PurchaseRecords.Specification, sum(PurchaseRecords.Quantity) num from PurchaseRecords inner join WeChatUsers on PurchaseRecords.OpenId = WeChatUsers.OpenId where ShopId = @ShopId group by WeChatUsers.NickName, PurchaseRecords.Specification)temp) temp2 where gnum = 1", CommandType.Text, sql))
     using (var command = CreateCommand("select * from(select ROW_NUMBER() over(partition by OpenId order by Num desc) gnum, * from (select OpenId,Specification, sum(Quantity) Num from PurchaseRecords where ShopId = @ShopId and charindex(','+OpenId+',',','+@OpenIdIds+',') > 0 group by OpenId,Specification )temp) temp2 where gnum = 1", CommandType.Text, sql))
     //using (var command = CreateCommand("select * from PurchaseRecords where ShopName like @ShopName", CommandType.Text,sql))
     {
         using (var dataReader = await command.ExecuteReaderAsync())
         {
             var result = new List <UserSpecification>();
             while (dataReader.Read())
             {
                 var userSpecification = new UserSpecification();
                 userSpecification.OpenId        = dataReader["OpenId"].ToString();
                 userSpecification.Specification = dataReader["Specification"].ToString();
                 userSpecification.Num           = (int)dataReader["Num"];
                 result.Add(userSpecification);
             }
             return(result);
         }
     }
 }
Ejemplo n.º 3
0
        static void Main(string[] args)
        {
            // Cat cat = new Dog();
            // Cat cat = (Cat)new Dog();
            // Cat cat = new Dog().AsCat();
            Cat cat = new WrappedDog(new Dog());


            IExpectAlternateContact spec =
                UserSpecification
                .ForPerson()
                .WithName("Max")
                .WithSurname("Planck")
                .WithPrimaryContact(
                    ContactSpecification.ForEmailAddress("*****@*****.**"));

            IBuildingSpecification <EmailAddress> contact =
                ContactSpecification.ForEmailAddress("*****@*****.**");

            if (!spec.CanAdd(contact))
            {
                Console.WriteLine("Cannot add desired contact...");
            }
            else
            {
                spec = spec.WithAlternateContact(contact);
                IUser user = spec.AndNoMoreContacts().Build();
                Console.WriteLine(user);
            }

            Console.ReadLine();
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Resets user's photo to default one
        /// </summary>
        public ResetPhotoResponse ResetPhoto(ISession session, ResetPhotoRequest request)
        {
            var response = request.CreateResponse <ResetPhotoResponse>();

            try
            {
                using (var uow = UnitOfWorkFactory.Create())
                {
                    var target = uow.UsersRepository.FirstMatching(UserSpecification.Id(request.TargetId));
                    if (target != null)
                    {
                        response.NewPhotoId = target.ResetPhoto(session.User);
                        uow.Commit();
                        response.Success = true;
                    }
                }
            }
            catch (ModeratorsRightsRequiredException)
            {
                response.Success = false;
            }
            if (response.Success)
            {
                _profileChangesNotificator.NotifyEverybodyInChatAboutProfileChanges(request.TargetId, new Dictionary <string, object> {
                    { "PhotoId", response.NewPhotoId }
                });
            }
            return(response);
        }
Ejemplo n.º 5
0
        public async Task <User> GetUserByUsernameAsync(string username)
        {
            var userSpec = new UserSpecification(username);
            var user     = (await _userRepository.ListAsync(userSpec)).FirstOrDefault();

            return(user);
        }
        public async Task <UserDto> Handle(GetUserDtoByIdQuery request, CancellationToken cancellationToken)
        {
            var userSpecification = new UserSpecification(request.UserId);
            var userDto           = await _userRepository.FindAsync(userSpecification).Select(MapFromUserDtoToUser);

            return(userDto);
        }
Ejemplo n.º 7
0
        public GetUserDetailsResponse GetUserDetails(ISession session, GetUserDetailsRequest request)
        {
            var response = request.CreateResponse <GetUserDetailsResponse>();

            using (var uow = UnitOfWorkFactory.Create())
            {
                Specification <User> spec = null;
                if (request.UserId != 0)
                {
                    spec = UserSpecification.Id(request.UserId);
                }
                else if (!string.IsNullOrEmpty(request.Name))
                {
                    spec = UserSpecification.Name(request.Name);
                }
                else
                {
                    return(response); //invalid request
                }

                var user = uow.UsersRepository.FirstMatching(spec);
                if (user != null)
                {
                    response.User     = user.ProjectedAs <UserDto>();
                    response.IsFriend = session.User.Friends.Any(p => p.Id == user.Id);

                    uow.Attach(session.User);
                }
            }
            return(response);
        }
Ejemplo n.º 8
0
        static void Main(string[] args)
        {
            IUser user =
                UserSpecification
                .ForMachine()
                .ProducedBy(
                    ProducerSpecification
                    .WithName("Big Co."))
                .WithModel("Shiny one")
                .OwnedBy(
                    LegalEntitySpecification
                    .Initialize()
                    .WithCompanyName("Properties Co.")
                    .WithEmailAddress(
                        ContactSpecification.ForEmailAddress("one@prop"))
                    .WithPhoneNumber(
                        ContactSpecification
                        .ForPhoneNumber()
                        .WithCountryCode(1)
                        .WithAreaCode(23)
                        .WithNumber(456))
                    .WithOtherContact(
                        ContactSpecification.ForEmailAddress("two@prop"))
                    .AndNoMoreContacts())
                .Build();

            Console.WriteLine(user);

            Console.WriteLine();
            Console.ReadLine();
        }
Ejemplo n.º 9
0
        public User GetUser(string username)
        {
            var specification = new UserSpecification(username: username);
            var user          = _userRepository.Query(specification).First();

            return(user);
        }
        public async Task <User> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
        {
            var userSpecification = new UserSpecification(request.UserId);
            var user = await _userRepository.FindAsync(userSpecification);

            return(user);
        }
Ejemplo n.º 11
0
        public RemoveFromFriendsResponse RemoveFromFriends(ISession session, RemoveFromFriendsRequest request)
        {
            var response = request.CreateResponse <RemoveFromFriendsResponse>();

            response.Success = true;

            if (session.User.Friends.All(i => i.Id != request.TargetUserId))
            {
                response.Success = false;
                return(response);
            }

            using (var uow = UnitOfWorkFactory.Create())
            {
                uow.Attach(session.User);
                var friend = uow.UsersRepository.FirstMatching(UserSpecification.Id(request.TargetUserId));
                if (friend == null)
                {
                    response.Success = false;
                }
                else
                {
                    session.User.Friends.Remove(friend);
                    uow.Commit();
                }
            }
            return(response);
        }
Ejemplo n.º 12
0
        /// <summary>
        /// </summary>
        public RegistrationResponse RegisterNewUser(ISession session, RegistrationRequest request)
        {
            var response = request.CreateResponse(new RegistrationResponse {
                Result = RegistrationResponseType.Success
            });
            User user = null;

            try
            {
                user = new User(request.Name, request.Password, request.Huid, request.Sex, request.Age, request.PushUri, request.Country, request.Platform);
            }
            catch (InvalidUserRegistrationDataException)
            {
                response.Result = RegistrationResponseType.InvalidData;
                return(response);
            }

            using (var uow = UnitOfWorkFactory.Create())
            {
                if (uow.UsersRepository.AnyMatching(UserSpecification.Name(user.Name)))
                {
                    response.Result = RegistrationResponseType.NameIsInUse;
                    return(response);
                }

                uow.UsersRepository.Add(user);
                uow.Commit();
            }
            response.User = user.ProjectedAs <UserDto>();
            session.SetUser(user);
            return(response);
        }
        public async Task <UserDto> CreateUser(UserDto userDto)
        {
            var authenticationDto = new AuthenticationDto();
            var userSpecification = new UserSpecification().
                                    And(new UserNameSpecification()).
                                    And(new PasswordSpecification()).
                                    And(new UniqueUserSpecification(this.userRepository));

            if (userSpecification.IsSatisfiedBy(userDto))
            {
                string passwordSalt = "";
                string passwordHash = "";
                ECWRNGRfcSaltedHashManager.GenrateSaltedHash(userDto.Password, out passwordHash, out passwordSalt);
                var newUser = new Logins
                {
                    UserName     = userDto.UserName,
                    PasswordSalt = passwordSalt,
                    PasswordHash = passwordHash
                };
                int identity = await this.userRepository.CreateLogin(newUser);

                if (identity <= 0)
                {
                    userDto.AddRule("User", "Creation faild!");
                }
                else
                {
                    userDto.AddRule("Success", "Authentication is successfull.");
                }
            }
            return(userDto);
        }
Ejemplo n.º 14
0
        public async Task <ServiceResult <UserDto> > LoginAsync(LoginDto model)
        {
            var userSpecification = new UserSpecification(model.Email, true);

            var user = await _userRepository.GetBySpecAsync(userSpecification);

            if (user == null)
            {
                var result = new ServiceResult <UserDto>();
                result.ErrorMessages.Add(string.Empty, Messages.CheckYourEmailAddressOrPassword);
                return(result);
            }

            if (!VerifyPasswordHash(model.Password, user.PasswordHash, user.PasswordSalt))
            {
                var result = new ServiceResult <UserDto>();
                result.ErrorMessages.Add(string.Empty, Messages.CheckYourEmailAddressOrPassword);
                return(result);
            }

            var userDto = _mapper.Map <UserDto>(user);

            _logger.LogInformation("User was logged in with id: {0} at {1}", userDto.Id, DateTime.Now);


            return(new ServiceResult <UserDto>
            {
                Result = userDto
            });
        }
Ejemplo n.º 15
0
        public async Task <IActionResult> SignIn(SignInViewModel data)
        {
            ViewData["Email"] = data.Email;

            if (!ModelState.IsValid)
            {
                return(PartialView());
            }

            var userSpecification = new UserSpecification()
            {
                Email = data.Email
            };

            AuthenticationUser = await _userRepository.ReadAsync(userSpecification);

            if (AuthenticationUser is null)
            {
                ModelState.AddModelError("Invalid", _localizer[AuthenticationErrorMessages.InvalidData]);
                return(PartialView());
            }

            var passwordVerification = _passwordHasherService.VerifyHashedPassword(
                user: AuthenticationUser,
                hashedPassword: AuthenticationUser.PassHash,
                providedPassword: SignInData.Password);

            if (passwordVerification == PasswordVerificationResult.Failed)
            {
                ModelState.AddModelError("Invalid", _localizer[AuthenticationErrorMessages.InvalidData]);
                return(PartialView());
            }

            var identity = new ClaimsIdentity(
                authenticationType: CookieAuthenticationDefaults.AuthenticationScheme,
                nameType: ClaimTypes.Name,
                roleType: ClaimTypes.Role);

            identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, AuthenticationUser.ID.ToString()));
            identity.AddClaim(new Claim(ClaimTypes.Name, AuthenticationUser.FullName));
            identity.AddClaim(new Claim(ClaimTypes.Email, AuthenticationUser.Email));

            foreach (var role in AuthenticationUser.Roles.Where(r => r.HasRole))
            {
                identity.AddClaim(new Claim(ClaimTypes.Role, role.Name));
            }

            var principal = new ClaimsPrincipal(identity);

            await HttpContext.SignInAsync(
                scheme : CookieAuthenticationDefaults.AuthenticationScheme,
                principal : principal,
                properties : new AuthenticationProperties {
                IsPersistent = data.RememberMe
            });

            return(Json(new { Route = Url.RouteUrl("default") }));
        }
Ejemplo n.º 16
0
        public async Task <IActionResult> CreateAsync(UserViewModel <TUser> userModel)
        {
            var roles = await _userRoleRepository.ListAsync();

            // populate the role list data not returned in post request
            foreach (var userRole in userModel.User.Roles)
            {
                var role = roles.Where(r => r.ID == userRole.ID).FirstOrDefault();
                userRole.Name         = role.Name;
                userRole.DisplayTitle = role.DisplayTitle;
            }

            string email = userModel.User.Email;

            // validate user e-mail address
            if (email.HasValue())
            {
                if (!_emailValidatorService.IsValidEmail(email))
                {
                    ModelState.AddModelError("InvalidEmail", _localizer[UserErrorMessages.InvalidEmail]);
                }

                var userSpecification = new UserSpecification()
                {
                    Email = email
                };

                var duplicateUser = await _userRepository.ReadAsync(userSpecification);

                if (duplicateUser != null)
                {
                    ModelState.AddModelError("DuplicateUser", _localizer[UserErrorMessages.DuplicateUser]);
                }
            }

            if (!ModelState.IsValid)
            {
                return(PartialView("_Editor", userModel));
            }

            // persist new user to data store
            var newUserID = await _userRepository.CreateAsync(userModel.User, UserID);

            if (newUserID == 0)
            {
                return(NoContent());
            }

            // publish user creation and invitation events so notification services can be called
            userModel.User.ID = newUserID;
            var userDTO          = new UserDTO(userModel.User);
            var userCreatedEvent = new UserCreated(userDTO);
            await _mediator.Publish(userCreatedEvent);

            var uri = Url.Action("ReadAsync", "User", new { id = newUserID });

            return(Created(uri, newUserID));
        }
Ejemplo n.º 17
0
        public void MatchesNoBasketsIfIdNotPresent()
        {
            var badId = Guid.Empty;
            var spec  = new UserSpecification(badId);

            GetTestUsersCollection()
            .AsQueryable()
            .Any(spec.Criteria).ShouldBeFalse();
        }
        public async Task <PagedResult <UserDto> > Handle(GetUserPagedResultQuery request, CancellationToken cancellationToken)
        {
            var pagedUserSpecification = new UserSpecification(request, request.Email, request.Name);
            var result = await _userRepository.GetAllPagedAsync(pagedUserSpecification, request);

            var usersDto = result.Items.Select(MapFromUserDtoToUser);

            return(PagedResult <UserDto> .Create(usersDto, request.Page, request.PageSize, result.TotalPages, result.TotalItems));
        }
        public async Task Handle(UpdateUserRefreshTokenCommand notification, CancellationToken cancellationToken)
        {
            var userSpecification = new UserSpecification(notification.UserId);
            var user = await _userRepository.FindAsync(userSpecification);

            user.AddRefreshToken(notification.RefreshToken, notification.UserId, notification.RemoteIpAddress);
            await _userRepository.UpdateAsync(user, notification.UserId);

            await _unitOfWork.CommitAsync();
        }
Ejemplo n.º 20
0
        public void MatchesUserWithGivenId()
        {
            var spec = new UserSpecification(_userId);

            var result = GetTestUsersCollection()
                         .AsQueryable()
                         .FirstOrDefault(spec.Criteria);

            result.ShouldNotBeNull();
            result.Id.ShouldBe(_userId);
        }
        public async Task Handle(ExchangeRefreshTokenCommand notification, CancellationToken cancellationToken)
        {
            var userSpecification = new UserSpecification(notification.UserId);
            var user = await _userRepository.FindAsync(userSpecification);

            user.RemoveRefreshToken(notification.OldRefreshToken);
            user.AddRefreshToken(notification.NewRefreshToken, user.Id, "");
            await _userRepository.UpdateAsync(user, user.Id);

            await _unitOfWork.CommitAsync();
        }
Ejemplo n.º 22
0
        public UsersSearchResponse SearchUser(ISession session, UsersSearchRequest request)
        {
            var response = request.CreateResponse <UsersSearchResponse>();

            using (var uow = UnitOfWorkFactory.Create())
            {
                var users    = uow.UsersRepository.AllMatching(UserSpecification.NameLike(request.QueryString), 20);
                var userDtos = users.ProjectedAsCollection <UserDto>();

                response.Result = userDtos.ToArray();
            }
            return(response);
        }
Ejemplo n.º 23
0
        public async Task <IActionResult> Get(string name = null)
        {
            // var queryOptions = QueryOptionsExtensions.GetFromRequest(Request);
            var specification = new UserSpecification(name);
            var result        = await _queryBus.ExecuteAsync(new UserQuery(specification));

            var count = await _queryBus.ExecuteAsync(new UserTotalQuery(specification));

            return(Ok(new PageableCollection <UserQueryModel>()
            {
                Results = result, Total = count
            }));
        }
Ejemplo n.º 24
0
        public BanResponse Ban(ISession session, BanRequest request)
        {
            var response = request.CreateResponse <BanResponse>();

            User targetUser = null;

            using (var uow = UnitOfWorkFactory.Create())
            {
                targetUser = uow.UsersRepository.FirstMatching(UserSpecification.Id(request.TargetUserId));
                if (targetUser != null)
                {
                    try
                    {
                        if (request.Ban)
                        {
                            targetUser.Ban(session.User);
                        }
                        else
                        {
                            targetUser.UnBan(session.User);
                        }

                        response.Result = BanResponseType.Success;
                        uow.Commit();
                    }
                    catch (ModeratorsRightsRequiredException)
                    {
                        response.Result = BanResponseType.Failed;
                    }
                }
            }

            if (response.Result == BanResponseType.Success && targetUser != null)
            {
                //let's kick him\her from the server!
                _sessionManager.CloseSessionByUserId(targetUser.Id);

                //send a notification to everybody that we've banned him\her
                _sessionManager.SendToEachChatSessions(
                    new BanNotification
                {
                    Ban        = request.Ban,
                    ActorName  = session.User.Name,
                    Reason     = request.Reason,
                    TargetId   = session.User.Id,
                    TargetName = targetUser.Name
                });
            }

            return(response);
        }
Ejemplo n.º 25
0
        public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel data)
        {
            ViewData["Email"] = data.Email;

            if (!ModelState.IsValid)
            {
                return(PartialView(data));
            }

            if (!_emailValidatorService.IsValidEmail(data.Email))
            {
                ModelState.AddModelError("InvalidEmail", _localizer[AuthenticationErrorMessages.InvalidEmail]);
                return(PartialView(data));
            }

            var userSpecification = new UserSpecification()
            {
                Email = data.Email
            };

            AuthenticationUser = await _userRepository.ReadAsync(userSpecification);

            if (AuthenticationUser is null)
            {
                ModelState.AddModelError("UserDoesNotExist", _localizer[AuthenticationErrorMessages.UserDoesNotExist]);
                return(PartialView(data));
            }

            string token     = Convert.ToBase64String(Guid.NewGuid().ToByteArray());
            var    userDTO   = new UserDTO(AuthenticationUser);
            var    saveToken = await _userPasswordRepository.SavePasswordTokenAsync(userDTO, token);

            if (!saveToken)
            {
                ModelState.AddModelError("ReminderFailed", _localizer[AuthenticationErrorMessages.PasswordReminderFailed]);
                return(PartialView(data));
            }

            var domain = Request.Host.Value;

            domain += (Request.PathBase.Value.HasValue()) ? Request.PathBase.Value : string.Empty;
            var emailSubject = _forgotPasswordEmail.Subject();
            var emailBody    = _forgotPasswordEmail.Body(AuthenticationUser, domain, emailSubject, token);

            await _emailSenderService.SendEmailAsync(data.Email, emailSubject, emailBody);

            data.SendReminderSuccess = true;

            return(PartialView(data));
        }
Ejemplo n.º 26
0
        public async Task <IActionResult> InviteAsync(int userID)
        {
            var userSpecification = new UserSpecification()
            {
                ID = userID
            };

            var user = await _userRepository.ReadAsync(userSpecification);

            var userDTO             = new UserDTO(user);
            var userInvitationEvent = new UserInvitation(userDTO);
            await _mediator.Publish(userInvitationEvent);

            return(Ok());
        }
        public async Task <Token> Handle(LogInUserCommand request, CancellationToken cancellationToken)
        {
            var passwordHash = _hashingService.GenerateHash(request.Password, _configuration.SaltString);
            var spec         = UserSpecification.GetByCredentials(request.UserName, passwordHash);
            var user         = await _data.Users.SingleOrDefaultAsync(spec);

            if (user == null)
            {
                throw new AuthenticationApplicationException(ErrorMessagesConstants.InvalidCredentials);
            }

            var token = await _tokenService.GenerateAsync(user);

            return(token);
        }
Ejemplo n.º 28
0
        public async Task <User> Login(string username, string password)
        {
            var  userSpec = new UserSpecification(username);
            User user     = await _userRepository.FirstOrDefaultAsync(userSpec);

            if (user == null)
            {
                return(null);
            }
            if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
            {
                return(null);
            }
            return(user);
        }
Ejemplo n.º 29
0
        public bool LoginAccount(string userName, string pwd)
        {
            UserSpecification spec = new UserSpecification(new UserInfo {
                UserName = userName.ToLower(), UserPwd = pwd
            });
            var users = _userInfoRepository.GetBySpec(spec);

            if (users != null && users.Any())
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
        public async Task Handle(UpdateProjectParticipantsCommand command, CancellationToken cancellationToken)
        {
            var specification = new UserSpecification(command.Participants);
            var users         = await _useRepository.GetAllAsync(specification);

            var projectSpecification = new ProjectSpecification(command.Id);
            var project = await _projectRepository.GetSingleOrDefaultAsync(projectSpecification);

            var existingParticipant = project.Participants.Select(user => user).ToArray();
            var newParticipants     = users.Except(existingParticipant).ToArray();
            var deletedParticipants = existingParticipant.Except(users).ToArray();
            var participants        = existingParticipant.Except(deletedParticipants).Concat(newParticipants).ToArray();

            project.UpdateProjectParticipants(participants);
            await _unitOfWork.SaveChangesAsync();
        }
Ejemplo n.º 31
0
        /// <summary>
        /// Initializes a new instance of the <see cref="HomeQuery"/> class.
        /// </summary>
        /// <param name="status">The status.</param>
        /// <param name="sort">The sort.</param>
        /// <param name="order">The order.</param>
        /// <param name="page">The page.</param>
        public HomeQuery(string status, SortUser sort, SortOrder order, int? page)
        {
            IUserSpecification specification = null;

            if (!string.IsNullOrEmpty(status))
            {
                specification = new UserStatusSpecification(status.AsEnum<UserStatus>());
            }

            if (specification == null)
            {
                specification = new UserSpecification();
            }

            specification.Page = page;
            specification.Limit = Setting.UserPageLimit.Value;
            specification.Sort = sort;
            specification.Order = order;

            this.Specification = specification;
        }