public async Task <TravelPlanDto> CreateAsync(TravelPlanDto travelPlanDto, Guid userId)
        {
            try
            {
                //map here

                var newTravelPlan = new Domain.Models.TravelPlan
                {
                    Name               = travelPlanDto.Name,
                    Description        = travelPlanDto.Description,
                    StartDate          = travelPlanDto.StartDate,
                    EndDate            = travelPlanDto.EndDate,
                    CreatedById        = userId,
                    TravelPlanStatusId = (int)TravelPlanStatusEnum.Created,
                    //add jxn, auto adds to UTP table
                    UserTravelPlans = new List <UserTravelPlan>
                    {
                        new UserTravelPlan
                        {
                            UserId = userId
                        }
                    }
                };

                var tp = await _travelPlanRepository.CreateAsync(newTravelPlan);

                return(new TravelPlanDto(tp));
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task SetStatus_UserIsNotCreator_ThrowsInsufficientRightsException()
        {
            var loggedInUserId = _emptyUserId;

            var tpRepo          = _mockRepo.Create <ITravelPlanRepository>();
            var userRepo        = _mockRepo.Create <IUserRepository>();
            var userTPService   = _mockRepo.Create <IUserTravelPlanService>();
            var tpStatusService = _mockRepo.Create <ITravelPlanStatusService>();

            int status = (int)TravelPlanStatusEnum.Archived;

            var tpToEdit = new Models.TravelPlan()
            {
                CreatedById = Guid.NewGuid()
            };

            //arrange
            tpRepo.Setup((tpr) => tpr.GetAsync(It.IsAny <Guid>(), false)).ReturnsAsync(tpToEdit);

            //act
            using (var context = new AppDbContext(_dbOptions))
            {
                var tpService = new TravelPlanService(tpRepo.Object, userRepo.Object, userTPService.Object, tpStatusService.Object, context);

                var result = await tpService.SetStatusAsync(loggedInUserId, _emptyUserId, status);
            }
        }
        public async Task RemoveTraveler_UserTravelPlanNotExists_ReturnsTrue()
        {
            var loggedInUserId = _emptyUserId;
            var userName       = "******";

            var tpRepo          = _mockRepo.Create <ITravelPlanRepository>();
            var userRepo        = _mockRepo.Create <IUserRepository>();
            var userTPService   = _mockRepo.Create <IUserTravelPlanService>();
            var tpStatusService = _mockRepo.Create <ITravelPlanStatusService>();

            Models.TravelPlan travelPlan = new Models.TravelPlan();
            travelPlan.UserTravelPlans = null;
            DTOs.UserDto user = new DTOs.UserDto();


            //arrange
            tpRepo.Setup((tpr) => tpr.GetAsync(_emptyTPId, true)).ReturnsAsync(travelPlan);
            userRepo.Setup((ur) => ur.GetUserAsync(userName)).ReturnsAsync(user);

            //act
            using (var context = new AppDbContext(_dbOptions))
            {
                var tpService = new TravelPlanService(tpRepo.Object, userRepo.Object, userTPService.Object, tpStatusService.Object, context);

                var result = await tpService.RemoveTraveler(loggedInUserId, userName, _emptyTPId);

                Assert.IsTrue(result);
            }
        }
        public async Task RemoveTraveler_HostRemoveThemslves_ThrowsException()
        {
            var loggedInUserId = _emptyUserId;
            var userName       = "******";

            var tpRepo          = _mockRepo.Create <ITravelPlanRepository>();
            var userRepo        = _mockRepo.Create <IUserRepository>();
            var userTPService   = _mockRepo.Create <IUserTravelPlanService>();
            var tpStatusService = _mockRepo.Create <ITravelPlanStatusService>();

            Models.TravelPlan travelPlan = new Models.TravelPlan();
            travelPlan.CreatedById = _emptyUserId;


            //user to remove is the host
            var userTPToRemove = new Models.UserTravelPlan
            {
                UserId = _emptyUserId
            };


            travelPlan.UserTravelPlans = new List <Models.UserTravelPlan>
            {
                userTPToRemove
            };

            DTOs.UserDto user = new DTOs.UserDto();
            user.Id = _emptyUserId.ToString();


            //arrange
            tpRepo.Setup((tpr) => tpr.GetAsync(_emptyTPId, true)).ReturnsAsync(travelPlan);
            userRepo.Setup((ur) => ur.GetUserAsync(userName)).ReturnsAsync(user);
            userTPService.Setup(utp => utp.Delete(It.IsAny <Models.UserTravelPlan>())).ReturnsAsync(true);

            //act
            using (var context = new AppDbContext(_dbOptions))
            {
                var tpService = new TravelPlanService(tpRepo.Object, userRepo.Object, userTPService.Object, tpStatusService.Object, context);

                var result = await tpService.RemoveTraveler(loggedInUserId, userName, _emptyTPId);
            }
        }
        public async Task RemoveTraveler_InvalidTravelPlan_ThrowsException()
        {
            var loggedInUserId = _emptyUserId;

            var tpRepo          = _mockRepo.Create <ITravelPlanRepository>();
            var userRepo        = _mockRepo.Create <IUserRepository>();
            var userTPService   = _mockRepo.Create <IUserTravelPlanService>();
            var tpStatusService = _mockRepo.Create <ITravelPlanStatusService>();

            Models.TravelPlan nullTP = null;

            //arrange
            tpRepo.Setup((tpr) => tpr.GetAsync(_emptyTPId, true)).ReturnsAsync(nullTP);

            //act
            using (var context = new AppDbContext(_dbOptions))
            {
                var tpService = new TravelPlanService(tpRepo.Object, userRepo.Object, userTPService.Object, tpStatusService.Object, context);

                var result = await tpService.RemoveTraveler(loggedInUserId, "someUsername", _emptyTPId);
            }
        }