Example #1
0
        public void GetAllLocationNamesShould_ReturnAllNames()
        {
            var options = new DbContextOptionsBuilder <CarRentalDbContext>()
                          .UseInMemoryDatabase(databaseName: "CarRental_Database_AllLocationNames")
                          .Options;
            var dbContext = new CarRentalDbContext(options);

            var locationsService = new LocationsService(dbContext);

            var locationList = new List <Location>()
            {
                new Location
                {
                    Name = locationNameOne
                },
                new Location
                {
                    Name = locationNameTwo
                },
                new Location
                {
                    Name = locationNameThree
                },
            };

            dbContext.Locations.AddRange(locationList);
            dbContext.SaveChanges();

            var expected = new List <string> {
                locationNameOne, locationNameTwo, locationNameThree
            };
            var result = locationsService.GetAllLocationNames().ToList();

            Assert.Equal(expected, result);
        }
Example #2
0
        public LocationsServiceTest()
        {
            vehiclesRepository  = Substitute.For <IVehiclesRepository>();
            locationsRepository = Substitute.For <ILocationsRepository>();

            locationsService = new LocationsService(vehiclesRepository, locationsRepository);
        }
Example #3
0
        public void DeleteLocationShould_ReturnFalseIfTheLocationIsReturnPlaceForOrder()
        {
            var options = new DbContextOptionsBuilder <CarRentalDbContext>()
                          .UseInMemoryDatabase(databaseName: "CarRental_Database_DeleteLocationWithOrders")
                          .Options;
            var dbContext = new CarRentalDbContext(options);

            var locationsService = new LocationsService(dbContext);

            var location = new Location
            {
                Name = locationNameOne
            };

            locationsService.CreateLocation(location);

            var order = new Order
            {
                CarId             = 1,
                ApplicationUserId = Guid.NewGuid().ToString(),
                PickUpLocationId  = 1,
                ReturnLocationId  = 1,
                Price             = 100,
                RentStart         = DateTime.UtcNow.Date,
                RentEnd           = DateTime.UtcNow.Date.AddDays(2)
            };

            dbContext.Orders.Add(order);

            var result = locationsService.DeleteLocation(locationNameTwo).GetAwaiter().GetResult();

            Assert.False(result);
        }
        private static List <LocationHolder> GetAllLocations()
        {
            List <LocationHolder> locationHolders = new List <LocationHolder>();

            LocationsService locations = ServiceLocator.Instance.GetService <LocationsService>();
            var items = locations.Items;

            foreach (var item in items)
            {
                if (item.Location.LatitudeLongitude == null)
                {
                    continue;
                }

                var lh = new LocationHolder
                {
                    Location     = item.Location.LatitudeLongitude.Location,
                    FilmName     = item.Location.Name,
                    FilmSiteLink = $"{item.ImageFolder}/index.html"
                };
                locationHolders.Add(lh);
            }

            return(locationHolders);
        }
Example #5
0
        static void Main(string[] args)
        {
            SearchLocationsRequest request = CreateSearchLocationsRequest();
            //
            LocationsService service = new LocationsService();

            if (usePropertyFile())
            {
                service.Url = getProperty("endpoint");
            }
            //
            try
            {
                // Call the Locations web service passing in a SearchLocationsRequest and returning a SearchLocationsReply
                SearchLocationsReply reply = service.searchLocations(request);
                if (reply.HighestSeverity == NotificationSeverityType.SUCCESS || reply.HighestSeverity == NotificationSeverityType.NOTE || reply.HighestSeverity == NotificationSeverityType.WARNING)
                {
                    ShowSearchLocationsReply(reply);
                }
                ShowNotifications(reply);
            }
            catch (SoapException e)
            {
                Console.WriteLine(e.Detail.InnerText);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            Console.WriteLine("Press any key to quit!");
            Console.ReadKey();
        }
        public void GetAllLocationsAsKeyValuePairShouldReturnCorrectNumber()
        {
            var list = new List <Location>()
            {
                new Location
                {
                    Id   = 1,
                    Name = "Plovdiv/Bulgaria",
                },
                new Location
                {
                    Id   = 2,
                    Name = "Sofia/Bulgaria",
                },
                new Location
                {
                    Id   = 3,
                    Name = "Stara Zagora/Bulgaria",
                },
            };

            var repository = new Mock <IRepository <Location> >();

            repository.Setup(r => r.AllAsNoTracking()).Returns(() => list.AsQueryable());
            var service = new LocationsService(repository.Object);

            var locations = service.GetAllLocationsAsKeyValuePair();

            Assert.Equal(3, locations.Count());
            repository.Verify(x => x.AllAsNoTracking(), Times.Once);
        }
        public void AddLocationTest()
        {
            Mock <IImagesService> imagesServiceMock = new Mock <IImagesService>();

            imagesServiceMock
            .Setup(ls => ls.UploadImageAsync(new StreamMock()))
            .Returns(Task.FromResult("url"));

            using (ApplicationDbContext dbContext = serviceProvider.GetService <ApplicationDbContext>())
            {
                LocationsService locationsService = new LocationsService(dbContext,
                                                                         serviceProvider.GetService <IMapper>(),
                                                                         serviceProvider.GetService <IConfiguration>(),
                                                                         imagesServiceMock.Object);

                AddLocationViewModel locationViewModel = new AddLocationViewModel
                {
                    Title       = "LocationTitle",
                    Description = "LocationDescription",
                    TownId      = 1,
                };

                locationsService.AddAsync(locationViewModel).GetAwaiter().GetResult();

                Location location = dbContext.Locations.First();

                Assert.Equal(locationViewModel.Title, location.Title);
            }
        }
Example #8
0
 public LibrariesController(LibrariesService librariesService, IMapper mapper, LocationsService locationsService, RolesService rolesService)
 {
     Locations = locationsService;
     Libraries = librariesService;
     Roles     = rolesService;
     Mapper    = mapper;
 }
        public IEnumerable <Location> Get([FromBody] GridModel model)
        {
            var locations = new List <Location>();

            if (model.SearchingColumns.Count > 0 && !string.IsNullOrEmpty(model.SearchingText))
            {
                locations = LocationsService.GetLocations()
                            .Where(location =>
                                   location.Description.ToLower().Contains(model.SearchingText.ToLower()) ||
                                   location.Name.ToLower().Contains(model.SearchingText.ToLower()))
                            .ToList();
            }
            else if (model.ParentId == null)
            {
                locations = LocationsService.GetLocations()
                            .Where(location => location.ParentId == model.ParentId)
                            .ToList();
            }
            else
            {
                locations = LocationsService.GetLocations();
            }

            return(locations);
        }
        private static string ListAllLocations()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append("<br/>");
            sb.Append("<br/>");

            LocationsService locations = ServiceLocator.Instance.GetService <LocationsService>();
            var items = locations.Items;

            foreach (var item in items)
            {
                string name    = item.Name;
                string address = item.Location?.Address;

                string html = $"<a href='{item.ImageFolder}/index.html' >{name}</a>";
                sb.Append($"<h4> {html}</h4>");
                sb.Append($"<p> {address}</p>");

                sb.Append("<br/>");
                sb.Append("<br/>");
            }

            return(sb.ToString());
        }
Example #11
0
        public void EditLocation_Should_ThrowException_If_LocationExists()
        {
            Location existingLocation = new Location()
            {
                ID     = 1,
                Name   = "Location1",
                Active = true,
                AdditionalInformation = "Original additional info"
            };

            Location edittedLocation = new Location()
            {
                ID     = 1,
                Name   = "Location2",
                Active = true,
                AdditionalInformation = "Editted additional info"
            };

            mockLocationRepository.Setup(m => m.GetLocationByName(edittedLocation.Name)).Returns(edittedLocation);
            mockLocationRepository.Setup(m => m.UpdateLocation(edittedLocation));

            LocationsService locationService = new LocationsService(logger.Object, mockLocationRepository.Object, mockBookingRepository.Object, mockDirectoryRepository.Object, mockEmailHelper.Object);

            Assert.Throws <LocationExistsException>(() => locationService.EditLocation(existingLocation, edittedLocation));

            mockLocationRepository.Verify(m => m.UpdateLocation(edittedLocation), Times.Never);
        }
Example #12
0
        public void AddLocationWithoutName()
        {
            Mock <IImagesService> imagesServiceMock = new Mock <IImagesService>();

            imagesServiceMock
            .Setup(ls => ls.UploadImageAsync(new StreamMock()))
            .Returns(Task.FromResult("url"));

            using (ApplicationDbContext dbContext = serviceProvider.GetService <ApplicationDbContext>())
            {
                IConfiguration configuration = serviceProvider.GetService <IConfiguration>();

                LocationsService locationsService = new LocationsService(dbContext,
                                                                         serviceProvider.GetService <IMapper>(),
                                                                         configuration,
                                                                         imagesServiceMock.Object);

                AddLocationViewModel locationViewModel = new AddLocationViewModel
                {
                    Description = "LocationDescription",
                    TownId      = 1,
                };

                locationsService.AddAsync(locationViewModel).GetAwaiter().GetResult();

                int      locations           = dbContext.Locations.CountAsync().GetAwaiter().GetResult();
                Location locationWithoutName = dbContext.Locations.FirstAsync().GetAwaiter().GetResult();

                Assert.Equal(configuration["DefaultLocationName"], locationWithoutName.Title);

                Assert.True(locations == 1);
            }
        }
Example #13
0
        public IActionResult UpdateStorageArea(Guid siteId, Guid areaId, [FromBody] StorageAreaUpdateRequest storageAreaUpdateRequest)
        {
            if (siteId == null || areaId == null || storageAreaUpdateRequest == null ||
                string.IsNullOrWhiteSpace(storageAreaUpdateRequest.Name))
            {
                return(HandleBadRequest("A valid storage site ID, area ID and name have to be supplied."));
            }

            try
            {
                StorageArea area = LocationsService.UpdateStorageArea(siteId, areaId, storageAreaUpdateRequest.Name);
                return(Ok(area));
            }
            catch (StorageSiteNotFoundException exception)
            {
                return(HandleResourceNotFoundException(exception));
            }
            catch (StorageAreaNotFoundException exception)
            {
                return(HandleResourceNotFoundException(exception));
            }
            catch (Exception exception)
            {
                return(HandleUnexpectedException(exception));
            }
        }
Example #14
0
        public void EditLocation_Should_Edit()
        {
            Location existingLocation = new Location()
            {
                ID     = 1,
                Name   = "Location1",
                Active = true,
                AdditionalInformation = "Original additional info"
            };

            Location edittedLocation = new Location()
            {
                ID     = 1,
                Name   = "Location1",
                Active = true,
                AdditionalInformation = "Editted additional info"
            };

            mockLocationRepository.Setup(m => m.UpdateLocation(edittedLocation));

            LocationsService locationService = new LocationsService(logger.Object, mockLocationRepository.Object, mockBookingRepository.Object, mockDirectoryRepository.Object, mockEmailHelper.Object);

            locationService.EditLocation(existingLocation, edittedLocation);

            mockLocationRepository.Verify(m => m.UpdateLocation(edittedLocation), Times.Once);
        }
        public static void Build(IModelEvent pageDetails)
        {
            pageDetails.ExtraIncludes.Add(eWolfBootstrap.Enums.BootstrapOptions.GALLERY);

            pageDetails.CopyLayoutsToKeywords();

            Console.WriteLine(pageDetails.Name);

            List <string> images = ImageHelper.GetAllImages(pageDetails.ImagesPath);

            AddImageToLayouts(pageDetails, images);

            // create folders
            Directory.CreateDirectory(Constants.RootPath + "\\" + Constants.ModelEvents);
            Directory.CreateDirectory(Constants.RootPath + "\\" + Constants.ModelEvents + "\\" + pageDetails.ImageFolder);
            Directory.CreateDirectory(Constants.RootPath + "\\" + Constants.ModelEvents + "\\" + pageDetails.ImageFolder + @"\images");

            string htmlpath  = Constants.RootPath + "\\" + Constants.ModelEvents + "\\" + pageDetails.ImageFolder + "\\";
            string imagePath = Constants.RootPath + "\\" + Constants.ModelEvents + "\\" + pageDetails.ImageFolder + @"\images";

            eWolfBootstrap.Interfaces.IPageBuilder pageBuilder = new PageBuilder("index.html", htmlpath, pageDetails, "../../");

            pageBuilder.Append(NavBarHelper.NavBar("../../"));
            pageBuilder.Append("<div class='container mt-4'>");

            pageBuilder.Append(Jumbotron(pageDetails));

            LocationsService ls = ServiceLocator.Instance.GetService <LocationsService>();

            ls.AddLocation(pageDetails);

            AddImagesByLayout(images, pageDetails, htmlpath, imagePath, pageBuilder);

            pageBuilder.Output();
        }
Example #16
0
 public IActionResult GetStorageSites(
     [FromQuery] bool getAll         = false,
     [FromQuery] int page            = 1,
     [FromQuery] int elementsPerPage = 10,
     [FromQuery] string search       = null)
 {
     try
     {
         IEnumerable <StorageSite> sites = null;
         if (string.IsNullOrWhiteSpace(search))
         {
             sites = LocationsService.GetAllStorageSites();
         }
         else
         {
             sites = LocationsService.SearchStorageSitesByName(search);
         }
         IEnumerable <StorageSite> paginatedSites = sites;
         if (!getAll)
         {
             paginatedSites = sites.Skip((page - 1) * elementsPerPage).Take(elementsPerPage);
         }
         return(Ok(new PaginatedResponse(paginatedSites, sites.Count())));
     }
     catch (Exception exception)
     {
         return(HandleUnexpectedException(exception));
     }
 }
Example #17
0
 /// <summary>
 /// Initializes a new instance of the <see cref="InventoryController"/> class.
 /// </summary>
 /// <param name="loggerFactory">A factory to create loggers from.</param>
 /// <param name="inventoryService">The service providing inventory functionality.</param>
 /// <param name="materialsService">A service providing material data.</param>
 /// <param name="locationsService">A service providing locations data.</param>
 public InventoryController(ILoggerFactory loggerFactory,
                            InventoryService inventoryService,
                            MaterialsService materialsService,
                            LocationsService locationsService)
 {
     Logger           = loggerFactory.CreateLogger <InventoryController>();
     InventoryService = inventoryService;
     MaterialsService = materialsService;
     LocationsService = locationsService;
 }
Example #18
0
        public LocationsController(IBookingRepository bookingRepository, ILocationRepository locationRepository, IDirectoryService directoryService, EmailHelper emailHelper)
        {
            _logger = NLog.LogManager.GetCurrentClassLogger();

            _directoryService = directoryService;
            _locationService  = new LocationsService(_logger, locationRepository, bookingRepository, directoryService, emailHelper);

            _locationRepository = locationRepository;
            _bookingRepository  = bookingRepository;

            _logger.Trace(LoggerHelper.InitializeClassMessage());
        }
Example #19
0
        public IActionResult CreateStorageSite([FromBody] StorageSiteCreationRequest storageSiteCreationRequest)
        {
            if (storageSiteCreationRequest == null ||
                string.IsNullOrWhiteSpace(storageSiteCreationRequest.Name))
            {
                return(HandleBadRequest("A valid storage site name has to be supplied."));
            }

            StorageSite site = LocationsService.CreateStorageSite(storageSiteCreationRequest.Name);

            return(Created(GetNewResourceUri(site.Id), site));
        }
Example #20
0
        public IActionResult CreateStorageArea(Guid siteId, [FromBody] StorageAreaCreationRequest storageAreaCreationRequest)
        {
            if (storageAreaCreationRequest == null ||
                string.IsNullOrWhiteSpace(storageAreaCreationRequest.Name))
            {
                return(HandleBadRequest("A valid storage area name has to be supplied."));
            }

            StorageArea area = LocationsService.AddAreaToStorageSite(siteId, storageAreaCreationRequest.Name);

            return(Created(GetNewResourceUri(area.Id), area));
        }
Example #21
0
        private static ItemNewViewModel ItemNewViewModel_WithMockDependencies_And_FakeRepository(out FakeLocationsRepository mockLocationsRepository)
        {
            var mockNavigationService = new Mock <INavigationService>();
            var mockDialogService     = new Mock <IDialogService>();
            var mockItemsService      = new Mock <IItemsService>();

            mockLocationsRepository = new FakeLocationsRepository();
            var mockLocationService = new LocationsService(mockLocationsRepository, new InMemoryBlobCache());

            var itemNewViewModel = new ItemNewViewModel(mockNavigationService.Object, mockDialogService.Object, mockItemsService.Object, mockLocationService);

            return(itemNewViewModel);
        }
        public async Task LoadLocationsCleansData(int locationId, string locationName, string localAuthorityName, string locationAuthorityDistrict, int expectedNumberOfLocations)
        {
            //Setup
            A.CallTo(() => fakeNationalStatisticsLocationService.GetLocationsAsync()).Returns(GetTestLocations(locationId, locationName, localAuthorityName, locationAuthorityDistrict));
            var loadLocationsService = new LocationsService(fakeLogger, fakeNationalStatisticsLocationService);

            //Act
            var result = await loadLocationsService.GetCleanLocationsAsync().ConfigureAwait(false);

            //Assert
            A.CallTo(() => fakeNationalStatisticsLocationService.GetLocationsAsync()).MustHaveHappenedOnceExactly();
            result.Count().Should().Be(expectedNumberOfLocations);
        }
Example #23
0
        public void ToggleLocationActive_Should_Update_When_False_And_HasExistingBookings()
        {
            List <Booking> existingBookings = new List <Booking>()
            {
                new Booking()
                {
                    ID = 1, PID = "1234", Owner = "Reece"
                },
                new Booking()
                {
                    ID = 2, PID = "5678", Owner = "Charlie"
                }
            };

            Location existingLocation = new Location()
            {
                ID     = 1,
                Name   = "Location1",
                Active = true,
                AdditionalInformation = "Original additional info"
            };

            mockBookingRepository.Setup(x => x.GetByDateAndLocation(It.IsAny <DateTime>().Date, existingLocation)).Returns(existingBookings);

            mockDirectoryRepository.Setup(m => m.GetUser(It.Is <Pid>(x => x.Identity == "1234"))).Returns(new User()
            {
                EmailAddress = "*****@*****.**"
            });
            mockDirectoryRepository.Setup(m => m.GetUser(It.Is <Pid>(x => x.Identity == "5678"))).Returns(new User()
            {
                EmailAddress = "*****@*****.**"
            });

            string fakeFromEmailAddress = "*****@*****.**";
            string fakeBody             = "Some Body Contents";

            mockEmailHelper.Setup(m => m.GetEmailMarkup(It.IsAny <string>(), It.IsAny <List <Booking> >())).Returns(fakeBody);
            mockEmailHelper.Setup(m => m.SendEmail(fakeFromEmailAddress, It.IsAny <string>(), It.IsAny <string>(), fakeBody, It.IsAny <bool>()));

            NameValueCollection appSettings = new NameValueCollection();

            appSettings.Add("fromEmail", fakeFromEmailAddress);

            LocationsService service = new LocationsService(logger.Object, mockLocationRepository.Object, mockBookingRepository.Object, mockDirectoryRepository.Object, mockEmailHelper.Object);

            service.ToggleLocationActive(existingLocation, false, appSettings);

            mockLocationRepository.Verify(m => m.UpdateLocation(existingLocation), Times.Once);
            mockBookingRepository.Verify(m => m.Delete(It.IsAny <List <Booking> >()), Times.Once);
            mockEmailHelper.Verify(m => m.SendEmail(fakeFromEmailAddress, It.IsAny <string>(), It.IsAny <string>(), fakeBody, It.IsAny <bool>()), Times.Exactly(existingBookings.Count));
        }
Example #24
0
        public async Task GetNameById_WithInvalidData_ShouldWorkCorrectly(int?id)
        {
            var context = WilderExperienceContextInMemoryFactory.InitializeContext();

            await this.SeedData(context);

            var repository = new EfDeletableEntityRepository <Location>(context);
            var service    = new LocationsService(repository);


            var name = service.GetNameById(id);

            Assert.Null(name);
        }
Example #25
0
        public async Task GetIdByName_WithInvalidData_ShouldWorkCorrectly(string name)
        {
            var context = WilderExperienceContextInMemoryFactory.InitializeContext();

            await this.SeedData(context);

            var repository = new EfDeletableEntityRepository <Location>(context);
            var service    = new LocationsService(repository);


            var actualId = service.GetIdByName(name);

            Assert.True(actualId == 0);
        }
        public void GetAllLocationsAsKeyValuePairShouldReturnZeroForEmptyDatabase()
        {
            var list = new List <Location>();

            var repository = new Mock <IRepository <Location> >();

            repository.Setup(r => r.AllAsNoTracking()).Returns(() => list.AsQueryable());
            var service = new LocationsService(repository.Object);

            var locations = service.GetAllLocationsAsKeyValuePair();

            Assert.Empty(locations);
            repository.Verify(x => x.AllAsNoTracking(), Times.Once);
        }
Example #27
0
 public IActionResult GetStorageSite(Guid id)
 {
     try
     {
         return(Ok(LocationsService.GetStorageSite(id)));
     }
     catch (StorageSiteNotFoundException exception)
     {
         return(HandleResourceNotFoundException(exception));
     }
     catch (Exception exception)
     {
         return(HandleUnexpectedException(exception));
     }
 }
        public IEnumerable <Location> GetTest([FromBody] GridModel model)
        {
            var locations = new List <Location>();

            if (model.ParentId == null)
            {
                locations = LocationsService.GetLocations()
                            .Where(location => location.ParentId == model.ParentId)
                            .ToList();
            }
            else
            {
                locations = LocationsService.GetLocations();
            }

            return(locations);
        }
Example #29
0
        public async Task GetNameById_ShouldWorkCorrectly()
        {
            var context = WilderExperienceContextInMemoryFactory.InitializeContext();

            await this.SeedData(context);

            var repository = new EfDeletableEntityRepository <Location>(context);
            var service    = new LocationsService(repository);

            var firstLocation = context.Locations.First();
            var expectedName  = firstLocation.Name;
            var id            = firstLocation.Id;

            var actualName = service.GetNameById(id);

            Assert.True(expectedName == actualName);
        }
Example #30
0
        public async Task Search_ShouldWorkCorrectly()
        {
            var context = WilderExperienceContextInMemoryFactory.InitializeContext();

            await this.SeedData(context);

            var repository = new EfDeletableEntityRepository <Location>(context);
            var service    = new LocationsService(repository);

            var firstLocation = context.Locations.First();
            var name          = firstLocation.Name;

            var resultLocation      = service.Search <LocationViewModel>(name);
            var firstResultLocation = resultLocation.FirstOrDefault();

            Assert.True(resultLocation.Count() == 1);
            Assert.Equal(firstLocation.Name, firstResultLocation.Name);
        }