Example #1
0
        public void We_Can_Create_New_User_Without_Groups_And_Languages()
        {
            // arrange
            var newUserStsId = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";

            var newUserRequest = new NewUserRequestDto()
            {
                About         = "About",
                Email         = "*****@*****.**",
                FirstName     = "Stecho",
                Gender        = GenderEnum.Male,
                IdsrvUniqueId = newUserStsId,
                PhoneNumber   = "+359886585549"
            };

            // act
            var newUserId = this._userService.InsertNewUser(newUserRequest);

            // assert
            var newUser = this._userService.GetUserById(newUserId);

            Assert.IsNotNull(newUser);
            Assert.AreEqual(newUser.IdsrvUniqueId, newUserStsId);
            Assert.IsNotNull(newUser.AutomaticSubscriptionSettings);
            Assert.IsNotNull(newUser.BirthDate);
            Assert.AreEqual(newUser.BirthDate, DateTime.Parse(this.InitialDateString));
        }
Example #2
0
        public async Task <IHttpActionResult> Post([FromBody] NewUserRequestDto newUser)
        {
            var validator = new NewUserRequestDtoValidator(this._phoneValidationManager, this._userService);
            var results   = await validator.ValidateAsync(newUser);

            var detailedError = new StringBuilder();

            foreach (var error in results.Errors.Select(e => e.ErrorMessage))
            {
                detailedError.Append(error + "; ");
            }

            if (!results.IsValid)
            {
                return(BadRequest(detailedError.ToString())); // TODO: Think of returning the errors in a better way
            }
            try
            {
                var newlyCreatedUserId = this._userService.InsertNewUser(newUser);

                return(Created("api/v1/users/" + newlyCreatedUserId, "Success"));
            }
            catch (Exception ex)
            {
                var errorMessage = _apiLogger.OnActionException(ActionContext, ex);
                return(InternalServerError(new HttpException(errorMessage)));
            }
        }
Example #3
0
        public Guid InsertNewUser(NewUserRequestDto newUser)
        {
            var userEntity = this._mapper.Map <NewUserRequestDto, User>(newUser);

            userEntity.Id = Guid.NewGuid();

            if (newUser.BirthDate != null)
            {
                var userBirthdate = DateTime.Parse(newUser.BirthDate.ToString());
                var minDateForSql = DateTime.Parse(InitialDateString);

                userEntity.BirthDate = userBirthdate <= minDateForSql ? minDateForSql : newUser.BirthDate;
            }
            else
            {
                userEntity.BirthDate = DateTime.Parse(InitialDateString);
            }

            // add groups
            if (newUser.GroupIds != null && newUser.GroupIds.Any())
            {
                userEntity.Groups = new List <Group>();
                var groupEntities =
                    this._unitOfWork.GroupRepository.GetGroups().Where(gr => newUser.GroupIds.Contains(gr.Id));
                foreach (var groupEntity in groupEntities)
                {
                    userEntity.Groups.Add(groupEntity);
                }
            }

            // add languages
            if (newUser.LanguageIds != null && newUser.LanguageIds.Any())
            {
                userEntity.Languages = new List <Language>();
                var languageEntities =
                    this._unitOfWork.LanguageRepository.GetAlLanguages().Where(l => newUser.LanguageIds.Contains(l.Id));
                foreach (var languageEntity in languageEntities)
                {
                    userEntity.Languages.Add(languageEntity);
                }
            }

            // add default notification settings
            var newNotificationSettingEntity = new AutomaticSubscriptionSetting()
            {
                AutomaticallySubscribeToAllGroupsWithTag = false,
                AutomaticallySubscribeToAllGroups        = false
            };

            userEntity.AutomaticSubscriptionSettings = newNotificationSettingEntity;

            this._unitOfWork.UserRepository.InsertNewUser(userEntity);
            this._unitOfWork.Save();

            return(userEntity.Id);
        }
Example #4
0
        public async Task <IActionResult> Register([FromBody] NewUserRequestDto data)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            if (data == null)
            {
                return(BadRequest("Null parameter"));
            }
            var result = await _authService.Register(data);

            return(Ok(result));
        }
Example #5
0
        public void We_Can_Get_Notification_Settings_For_User()
        {
            // arrange
            var newUserStsId = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";

            var newUserRequest = new NewUserRequestDto()
            {
                About         = "About",
                Email         = "*****@*****.**",
                FirstName     = "Stecho",
                Gender        = GenderEnum.Male,
                IdsrvUniqueId = newUserStsId,
                PhoneNumber   = "+359886585549"
            };

            // act
            var newUserId = this._userService.InsertNewUser(newUserRequest);

            // assert
            var newUser = this._userService.GetUserById(newUserId);

            Assert.IsNotNull(newUser);

            // arrange
            // 1. Create new update user notifications request with tags
            var newUpdatedUserNotifications = new EditUserAutomaticSubscriptionSettingsRequestDto()
            {
                AutomaticallySubscribeToAllGroups        = false,
                AutomaticallySubscribeToAllGroupsWithTag = true,
                SubscribedTagIds = new List <Guid>()
                {
                    Guid.Parse("caf77dee-a94f-49cb-b51f-e0c0e1067541"), Guid.Parse("bd456f08-f137-4382-8358-d52772c2dfc8")
                }
            };

            // act
            this._userService.UpdateUserAutomaticSubscriptionSettings(newUserId, newUpdatedUserNotifications);

            // assert
            var updatedNotificationSettings = this._userService.GetAutomaticSubscriptionSettingsForUserWithId(newUserId);

            Assert.IsNotNull(updatedNotificationSettings);
            Assert.IsNotNull(updatedNotificationSettings.SubscribedTagIds);
            // 1. Notificiation settings were updated and now we have tags
        }
        public async Task <NewUserResponseDto> Register(NewUserRequestDto data)
        {
            var appUser = await _userManager.FindByEmailAsync(data.Email);

            if (appUser != null)
            {
                return(new NewUserResponseDto
                {
                    HasError = true,
                    Message = "Email in use"
                });
            }
            appUser = await _userManager.FindByEmailAsync(data.Email);

            if (appUser != null)
            {
                return(new NewUserResponseDto
                {
                    HasError = true,
                    Message = "User in use"
                });
            }
            appUser          = _mapper.Map <ApplicationUser>(data);
            appUser.UserName = $"{data.FirstName}.{data.LastName}";
            var result = await _userManager.CreateAsync(appUser, data.Password);

            if (result.Succeeded)
            {
                return(new NewUserResponseDto
                {
                    HasError = false,
                    Message = "User created successfuly",
                    UserId = appUser.Id,
                    UserName = appUser.UserName
                });
            }
            else
            {
                return(new NewUserResponseDto
                {
                    HasError = true,
                    Message = "An error ocurred"
                });
            }
        }
Example #7
0
        public async Task Bad_Request_Is_Returned_When_Phone_Number_Invalid()
        {
            // arrange
            var phoneValidationManagerMock = new Mock <IPhoneValidationManager>();
            var userServiceMock            = new Mock <IUserService>();

            userServiceMock.Setup(us => us.GetAllUsers()).Returns(new List <UserDto>()
            {
                new UserDto()
                {
                    IdsrvUniqueId = "idsrvid",
                    Email         = "*****@*****.**",
                    PhoneNumber   = "+359883899902"
                }
            });

            var request = new NewUserRequestDto()
            {
                IdsrvUniqueId = "idsrvid",
                Email         = "*****@*****.**",
                PhoneNumber   = "+359883899902"
            };

            var userController = new UserController(
                userServiceMock.Object,
                this._apiLogger.Object,
                null,
                null,
                phoneValidationManagerMock.Object);

            // act
            var actionResult = await userController.Post(request);

            // assert
            var contentResult = actionResult as BadRequestErrorMessageResult;

            Assert.IsNotNull(contentResult);
            Assert.AreEqual("'First Name' must not be empty.; Phone number provided is invalid; User with the same STS id has been already added.; User with the same email has been already added.; ", contentResult.Message);
        }
Example #8
0
        public void We_Can_Insert_New_User()
        {
            // arrange
            var firstLanguageId  = Guid.Parse("e9260fb3-5183-4c3e-9bd2-c606d03b7bcb");
            var secondLanguageId = Guid.Parse("05872235-365b-41f8-ab50-3913ffe9c601");
            var newUserStsId     = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";

            var groupOneId = Guid.NewGuid();
            var groupOne   = new Group()
            {
                Id = groupOneId, Name = "GroupOne", Users = new List <User>()
            };

            var area = new Area()
            {
                Id        = Guid.NewGuid(),
                Latitude  = 10,
                Longitude = 10,
                Groups    = new List <Group>()
                {
                    groupOne
                }
            };

            groupOne.Areas = new List <Area>()
            {
                area
            };

            var populatedDatabase = new FakeLikkleDbContext()
            {
                Groups = new FakeDbSet <Group>()
                {
                    groupOne
                },
                Areas = new FakeDbSet <Area>()
                {
                    area
                }
            }
            .Seed();

            this._mockedLikkleUoW.Setup(uow => uow.AreaRepository).Returns(new AreaRepository(populatedDatabase));
            this._mockedLikkleUoW.Setup(uow => uow.GroupRepository).Returns(new GroupRepository(populatedDatabase));

            var newUserRequestDto = new NewUserRequestDto()
            {
                FirstName     = "Stefcho",
                LastName      = "Stefchev",
                Email         = "*****@*****.**",
                IdsrvUniqueId = newUserStsId,
                LanguageIds   = new List <Guid>()
                {
                    firstLanguageId, secondLanguageId
                },
                GroupIds = new List <Guid>()
                {
                    groupOneId
                },
                BirthDate = DateTime.Parse(this.InitialDateString)
            };

            // act
            var userId = this._userService.InsertNewUser(newUserRequestDto);

            // assert
            Assert.IsNotNull(userId);

            var user = this._userService.GetUserById(userId);

            Assert.IsNotNull(user);
            Assert.IsNotNull(user.Id);
            Assert.AreEqual(userId, user.Id);
            Assert.AreEqual(user.Languages.Count(), 2);
            Assert.AreEqual(user.BirthDate, DateTime.Parse(this.InitialDateString));
        }
Example #9
0
        public void Updating_Non_Existing_User_Throws_ArgumentException()
        {
            // arrange
            var newUserStsId = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";
            // TODO: Extract this as a common part between this one and the one above
            var newUserRequest = new NewUserRequestDto()
            {
                About         = "About",
                Email         = "*****@*****.**",
                FirstName     = "Stecho",
                LastName      = "Stefchev",
                Gender        = GenderEnum.Male,
                IdsrvUniqueId = newUserStsId,
                PhoneNumber   = "+359886585549"
            };

            // act
            var newUserId = this._userService.InsertNewUser(newUserRequest);

            // assert
            var newUser = this._userService.GetUserById(newUserId);

            Assert.IsNotNull(newUser);
            Assert.AreEqual(newUser.IdsrvUniqueId, newUserStsId);
            Assert.IsNotNull(newUser.AutomaticSubscriptionSettings);
            Assert.IsNotNull(newUser.BirthDate);
            Assert.AreEqual(newUser.BirthDate, DateTime.Parse(this.InitialDateString));

            var updatedBirthDate = DateTime.UtcNow;
            var updatedAbout     = "UpdatedAbout";
            var updatedEmail     = "*****@*****.**";
            var firstNameUpdated = "UpdatedStecho";
            var lastNameUpdated  = "UpdatedStefchev";
            var firstLanguageId  = Guid.Parse("e9260fb3-5183-4c3e-9bd2-c606d03b7bcb");
            var secondLanguageId = Guid.Parse("05872235-365b-41f8-ab50-3913ffe9c601");

            var updateData = new UpdateUserInfoRequestDto()
            {
                About       = updatedAbout,
                BirthDate   = updatedBirthDate,
                Email       = updatedEmail,
                FirstName   = firstNameUpdated,
                Gender      = GenderEnum.Female,
                LastName    = lastNameUpdated,
                LanguageIds = new List <Guid>()
                {
                    firstLanguageId,
                    secondLanguageId
                },
                PhoneNumber = "Updated+359886585549"
            };

            // act

            Guid notValidUserId = Guid.NewGuid();

            while (notValidUserId == newUserId)
            {
                notValidUserId = Guid.NewGuid();
            }


            this._userService.UpdateUserInfo(notValidUserId, updateData);
        }
Example #10
0
        public void We_Can_Update_Initially_Created_User()
        {
            // arrange
            var newUserStsId = "https://boongaloocompanysts/identity3025f46b-3070-4f75-809d-44b7ae5b8e6a";

            var newUserRequest = new NewUserRequestDto()
            {
                About         = "About",
                Email         = "*****@*****.**",
                FirstName     = "Stecho",
                LastName      = "Stefchev",
                Gender        = GenderEnum.Male,
                IdsrvUniqueId = newUserStsId,
                PhoneNumber   = "+359886585549",
                LanguageIds   = new List <Guid>()
                {
                    Guid.Parse("e9260fb3-5183-4c3e-9bd2-c606d03b7bcb")
                }
            };

            // act
            var newUserId = this._userService.InsertNewUser(newUserRequest);

            // assert
            var newUser = this._userService.GetUserById(newUserId);

            Assert.IsNotNull(newUser);
            Assert.AreEqual(newUser.IdsrvUniqueId, newUserStsId);
            Assert.IsNotNull(newUser.AutomaticSubscriptionSettings);
            Assert.IsNotNull(newUser.BirthDate);
            Assert.AreEqual(newUser.BirthDate, DateTime.Parse(this.InitialDateString));

            // arrange
            var updatedBirthDate = DateTime.UtcNow;
            var updatedAbout     = "UpdatedAbout";
            var updatedEmail     = "*****@*****.**";
            var firstNameUpdated = "UpdatedStecho";
            var lastNameUpdated  = "UpdatedStefchev";
            var firstLanguageId  = Guid.Parse("e9260fb3-5183-4c3e-9bd2-c606d03b7bcb");
            var secondLanguageId = Guid.Parse("05872235-365b-41f8-ab50-3913ffe9c601");

            var updateData = new UpdateUserInfoRequestDto()
            {
                About       = updatedAbout,
                BirthDate   = updatedBirthDate,
                Email       = updatedEmail,
                FirstName   = firstNameUpdated,
                Gender      = GenderEnum.Female,
                LastName    = lastNameUpdated,
                LanguageIds = new List <Guid>()
                {
                    firstLanguageId,
                    secondLanguageId
                },
                PhoneNumber = "Updated+359886585549",
                AutomaticSubscriptionSettings = new AutomaticSubscriptionSettingsDto()
                {
                    AutomaticallySubscribeToAllGroups        = true,
                    AutomaticallySubscribeToAllGroupsWithTag = false,
                    SubscribedTagIds = new List <Guid>()
                }
            };

            // act
            this._userService.UpdateUserInfo(newUserId, updateData);

            // assert
            newUser = this._userService.GetUserById(newUserId);

            Assert.IsNotNull(newUser);
            Assert.AreEqual(newUser.IdsrvUniqueId, newUserStsId);
            Assert.AreEqual(newUser.BirthDate, updatedBirthDate);
            Assert.AreEqual(newUser.About, updatedAbout);
            Assert.AreEqual(newUser.Email, updatedEmail);
            Assert.AreEqual(newUser.FirstName, firstNameUpdated);
            Assert.AreEqual(newUser.LastName, lastNameUpdated);
            Assert.AreEqual(newUser.Languages.Count(), 2);
            Assert.IsTrue(newUser.Languages.Select(l => l.Id).Contains(firstLanguageId));
            Assert.IsTrue(newUser.Languages.Select(l => l.Id).Contains(secondLanguageId));
        }