Ejemplo n.º 1
0
        /// <summary>
        /// Создает зарегестрированного пользователя
        /// </summary>
        /// <param name="model">Модель для регистрации пользователя</param>
        /// <returns>ServiceResponce</returns>
        public ServiceResponce CreateSystemUser(RegisterUserModel model)
        {
            if (!model.GeneratePassword && !PasswordService.IsPasswordAcceptable(model.Password))
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "Password not acceptable"));
            }

            model.Phone = PhoneService.PhoneConvert(model.Phone);
            if (_userRep.CountByCredentails(model.Email, model.Phone) != 0)
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "User with this Email or Phone already exist"));
            }

            // Генерируем и хэшируем пароль
            string UnHashedPassword = model.Password;

            if (model.GeneratePassword)
            {
                UnHashedPassword = PasswordService.GeneratePasswordString();
            }
            model.Password = PasswordService.GeneratePasswordHash(UnHashedPassword);

            User user = RegisterUserModelHelper.CreateUser(model);

            _userRep.Save(user);
            ServiceResponce response = ServiceResponce
                                       .FromSuccess()
                                       .Result("User registered")
                                       .Add("UserId", user.Id);

            if (model.GeneratePassword)
            {
                response.Add("GeneratedPassword", UnHashedPassword);
            }

            if (model.NotSendWelcome == false)
            {
                // Создаем задачу отправки сообщения в фоне и запускаем ее
                new Thread(send =>
                {
                    RegisteredEmailModel RegisteredEmailModel
                        = RegisteredEmailModelHelper.GetRegisteredEmailModel(model, UnHashedPassword);
                    string RegisteredText = _templateServ
                                            .Run("Emails/Registered", typeof(RegisteredEmailModel), RegisteredEmailModel);
                    EmailService.SendMail(RegisteredEmailModel, RegisteredText);
                }).Start();
            }

            return(response);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Отсылает пользователю новый сгенерированный пароль по Email,
        /// если, конечно он зарегестрирован в системе
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ServiceResponce RestorePassword(RestorePasswordModel model)
        {
            IList <User> users = _userRep.FindAllByCredentails(model.Email, model.Phone);

            if (users == null)
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "user doesn't exist"));
            }

            /*       if (users.Count > 1)
             *     {
             *         return ServiceResponce
             *             .FromFailed()
             *             .Add("error", "user doesn't exist");
             *     } */

            User user = new User();

            if (users.Count == 1)
            {
                foreach (User u in users)
                {
                    user = u;
                }
            }

            string Password = PasswordService.GeneratePasswordString();

            user.Password = PasswordService.GeneratePasswordHash(Password);
            _userRep.Save(user);

            new Thread(send =>
            {
                RestorePasswordEmailModel RestorePasswordEmailModel = RestorePasswordEmailModelHelper.GetRestorePasswordEmailModel(user.UserName, Password);
                string RestoreText = _templateServ
                                     .Run("Emails/RestorePassword", typeof(RestorePasswordEmailModel), RestorePasswordEmailModel);
                if (!EmailService.SendMail(RestorePasswordEmailModel, RestoreText))
                {
                    user.UserStatuses.Description = "Restore password Email was not delivered";
                    user.UserStatuses.UpdateTime  = DateTime.Now;
                }
                else
                {
                    user.UserStatuses.Description = "Restore password Email was delivered at " + DateTime.Now;
                    user.UserStatuses.UpdateTime  = DateTime.Now;
                }
            }).Start();

            return(ServiceResponce.FromSuccess());
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Проверяет аутентификацию пользователя по
        /// <paramref name="UserName" />, <paramref name="Phone" />, <paramref name="Password" />,
        /// в случае успеха возвращает сущность пользователя;
        /// При проверке <paramref name="Phone" /> преобразуется в формат <see cref="PhoneService.PhoneConvert(string)" />,
        /// <paramref name="UserName" /> приводится в нижний регистр
        /// </summary>
        /// <param name="UserName"></param>
        /// <param name="Phone"></param>
        /// <param name="Password"></param>
        /// <returns></returns>
        public User Authenticate(string UserName, string Phone, string Password)
        {
            Password = PasswordService.GeneratePasswordHash(Password);
            Phone    = PhoneService.IsPhoneValid(Phone) ? PhoneService.PhoneConvert(Phone) : null;
            UserName = !string.IsNullOrEmpty(UserName) ? UserName.ToLower() : null;
            UserStatusType AvailableStatus = UserStatusType.System;

            if (UserName == null && Phone == null)
            {
                return(null);
            }

            IList <User> users = null;

            if (UserName != null && Phone != null)
            {
                users = AuthRep.FindAllByNamePhone(UserName, Phone, Password, AvailableStatus);
            }
            else if (UserName != null)
            {
                users = AuthRep.FindAllByName(UserName, Password, AvailableStatus);
            }
            else
            {
                users = AuthRep.FindAllByPhone(Phone, Password, AvailableStatus);
            }

            if (users == null || users.Count == 0)
            {
                return(null);
            }
            else if (users.Count == 1)
            {
                //TODO это зачем?
                User toReturn = null;
                foreach (User u in users)
                {
                    toReturn = u;
                }
                return(toReturn);
            }
            else
            {
                throw new Exception("CredentailsService: found more than 1 user with specified credentails");
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Изменение пароля пользователя с идентификатором <paramref name="id" />
        /// пользователем с Email <paramref name="currentUserEmail" />;
        /// В случае если пользователь меняет пароль самому себе он должен указать старый пароль
        /// </summary>
        /// <param name="id">Идентификатор пользователя для которого меняется пароль</param>
        /// <param name="currentUserEmail">Email польозователя который меняет пароль</param>
        /// <param name="model"></param>
        /// <returns></returns>
        public ServiceResponce ChangePassword(int id, string currentUserEmail, ChangePasswordModel model)
        {
            User user = _userRep.FindOneById(id);

            if (user == null)
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "User with specified Id was not found"));
            }

            bool SelfChangePassword = false;

            if (user.UserName.Equals(currentUserEmail))
            {
                SelfChangePassword = true;
                if (!user.Password.Equals(PasswordService.GeneratePasswordHash(model.OldPassword)))
                {
                    return(ServiceResponce
                           .FromFailed()
                           .Add("error", "Incorrect OldPassword"));
                }
            }

            user.Password = PasswordService.GeneratePasswordHash(model.NewPassword);
            _userRep.Save(user);

            if (model.SendCopyPassword)
            {
                // Создаем задачу отправки сообщения в фоне и запускаем ее
                new Thread(send =>
                {
                    ChangePasswordEmailModel ChangePasswordEmailModel
                        = ChangePasswordEmailModelHelper.GetChangePasswordEmailModel(user.UserName, model.NewPassword, SelfChangePassword);
                    string ChangePasswordText = _templateServ
                                                .Run("Emails/ChangePassword", typeof(ChangePasswordEmailModel), ChangePasswordEmailModel);
                    EmailService.SendMail(ChangePasswordEmailModel, ChangePasswordText);
                }).Start();
            }

            return(ServiceResponce.FromSuccess());
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Обновляет данные приглашения пользователя
        /// и переводит статус приглашения в статус ожидающий
        /// "Акцепта(ТЗ стр.8)"
        /// </summary>
        /// <param name="code">Код приглашения</param>
        /// <param name="model">Модель с данными для обновления</param>
        /// <returns></returns>
        public ServiceResponce UpdateInvite(string code, UpdateInviteModel model)
        {
            InviteCode invite = InviteRep.FindOneByCode(code);

            if (invite == null)
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "invite not found"));
            }

            User user = UserRep.FindOneById(invite.User.Id);

            if (!StatusService.CanChangeStatus(user, UserStatusType.AcceptInvite))
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "it isn't possible to change the status to AcceptInvited"));
            }


            if (!UserService.CanUpdateUserCredentails(user.Id, model.Email, model.Phone, UserRep))
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "user with such Email or Phone already exists"));
            }

            if (!model.GeneratePassword && !PasswordService.IsPasswordAcceptable(model.Password))
            {
                return(ServiceResponce
                       .FromFailed()
                       .Add("error", "Password not acceptable"));
            }

            // Генерируем и хэшируем пароль
            string Password = model.Password;

            if (model.GeneratePassword)
            {
                Password = PasswordService.GeneratePasswordString();
            }
            model.Password = PasswordService.GeneratePasswordHash(Password);

            user = UpdateInviteModelHelper.UpdateInviteUser(user, model);



            UserRep.Save(user);
            InviteRep.Delete(invite.Id);

            ServiceResponce response = ServiceResponce
                                       .FromSuccess()
                                       .Result("invite accepted");

            if (model.GeneratePassword)
            {
                response.Add("GeneratedPassword", Password);
            }
            return(response);
        }