public City GetCity()
{
var citiesRepo = new CitiesRepository();
var city = citiesRepo.GetCity();
return(city);
}
public void Get_Cities_By_Country_Name_All_Capitals()
{
var repo = new CitiesRepository();
var city = repo.GetCitiesByCountryName("AUSTRALIA");
Assert.IsNotNull(city);
}
public async Task UpdateAsync(CancellationToken cancellationToken)
{
Mvx.TaggedTrace(Tag, "Update requested");
if (!Outdated)
{
Mvx.TaggedTrace(Tag, "All data is up to date, update not required");
return;
}
ClearData();
var zipCodesGroupping = await LoadZipCodesGroupsAsync(cancellationToken);
var cities = GetCities(zipCodesGroupping);
CitiesRepository.AddAll(cities);
var zipCodes = GetZipCodes(zipCodesGroupping, cities);
ZipCodesRepository.AddAll(zipCodes);
UpdateRepository.Updated = DateTime.UtcNow;
Mvx.TaggedTrace(Tag, "Update completed");
}
public void Get_City_By_Id()
{
var repo = new CitiesRepository();
var city = repo.GetCity(1);
Assert.IsNotNull(city);
}
public ActionResult FillCities(int State)
{
IRepositoryBase <City> citiesRepo = new CitiesRepository(new DataContext());
var cities = citiesRepo.GetAll().ToList().Where(s => s.StateID == State);
return(Json(cities, JsonRequestBehavior.AllowGet));
}
public void TestListCities()
{
CitiesRepository citiesRepository = new CitiesRepository();
var listCities = citiesRepository.listarCities();
Assert.IsTrue(listCities.Count > 0);
}
private TicketService CreateSearchService()
{
var options = new DbContextOptionsBuilder <BookMyTicketDBContext>()
.UseInMemoryDatabase(nameof(SearchServiceTest), new InMemoryDatabaseRoot())
.ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning))
.Options;
var dbContext = new BookMyTicketDBContext(options);
var cityRepository = new CitiesRepository(dbContext);
var movieRepository = new MoviesRepository(dbContext);
var cinemaRepository = new CinemasRepository(dbContext);
var showsRepository = new ShowsRepository(dbContext);
var cinemaSeatingRepository = new CinemaSeatingRepository(dbContext);
var ticketsRepository = new TicketsRepository(dbContext);
var reservationsRepository = new ReservationsRepository(dbContext);
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
var clientContext = new ClientContext()
{
UserInfo = new Models.UserProfile()
{
ID = 1
}
};
var mapper = new Mapper(configuration);
MockDB(dbContext);
var searchService = new SearchService(cityRepository, movieRepository, cinemaRepository, showsRepository, cinemaSeatingRepository, ticketsRepository, reservationsRepository, mapper);
return(new TicketService(showsRepository, ticketsRepository, reservationsRepository, clientContext, searchService, mapper, dbContext));
}
public void Get_Cities_By_Country_Name()
{
var repo = new CitiesRepository();
var city = repo.GetCitiesByCountryName("australia");
Assert.IsNotNull(city);
}
public List <City> GetAllCities()
{
var citiesRepo = new CitiesRepository();
var cities = citiesRepo.GetAllCities();
return(cities);
}
public PathComponent get(int id)
{
EITDBEntities ctx = new EITDBEntities();
var entity = ctx.PathComponents.FirstOrDefault(x => x.Id == id);
if (entity == null)
{
return(null);
}
var citiesRepository = new CitiesRepository();
PathComponent obj = new PathComponent();
obj.Id = entity.Id;
obj.ArrivedAt = entity.ArrivedAt;
obj.City = citiesRepository.get(entity.City);
if (entity.NextDestination == null)
{
return(obj);
}
obj.NextDestination = get(entity.NextDestination.Value);
return(obj);
}
public CityController(CitiesRepository cities)
{
_cities = cities;
// Create a new CityItem if collection is empty,
// which means you can't delete all TodoItems.
_cities.Add(new City("Item1", "Bone"));
}
public void TestListCities()
{
ICitiesRepository citiesRepository = new CitiesRepository();
CitiesDomainService citiesDomainService = new CitiesDomainService(citiesRepository);
var lista = citiesDomainService.listarCities();
Assert.IsTrue(lista.Count > 0);
}
// GET: SendParcel
public ActionResult Index()
{
var vm = new SendParcelViewModel();
var cr = new CitiesRepository();
var ptr = new ParcelTypesRepository();
vm.Cities = cr.getAll();
vm.ParcelTypes = ptr.getAll();
return(View(vm));
}
public async Task <IActionResult> AddCity(string cityName)
{
if (cityName.IsNullOrWhiteSpaces())
{
return(BadRequest("Invalid City Name"));
}
var createdCity = await CitiesRepository.CreateCity(cityName);
return(Ok(createdCity));
}
private Edge mapFromEntity(Edges entity)
{
var citiesRepository = new CitiesRepository();
Edge obj = new Edge();
obj.Id = entity.Id;
obj.Source = citiesRepository.get(entity.Source);
obj.Destination = citiesRepository.get(entity.Destination);
obj.Segments = entity.Segments;
return(obj);
}
private void Form1_Load(object sender, EventArgs e)
{
CitiesRepository r = new CitiesRepository(new MyAppDbContext("TestDatabase"));
bool bOk = r.AddItem(new Library.Entities.City {
Id = Guid.NewGuid(), Name = "Dnipro"
});
if (bOk)
{
return;
}
}
public static void AddCity(DTO.City city)
{
try
{
CitiesRepository.AddCity(city);
}
catch (Exception ex)
{
// Log it
throw;
}
}
public IActionResult Get(int ctno)
{
var c = CitiesRepository.Get(ctno);
if (c != null)
{
return(Ok(c));
}
else
{
return(NotFound("No Such City"));
}
}
public void Clear_CallsDataStore()
{
// arrange
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
var repository = new CitiesRepository(
dataStoreMock.Object
);
// act
repository.Clear();
// assert
dataStoreMock.Verify(mock => mock.ClearAll <CityModel>(), Times.Once());
}
public async Task <IActionResult> GetCity(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("Invalid City Id"));
}
var city = await CitiesRepository.GetCity(id);
if (city == null)
{
return(NotFound("City not found"));
}
return(Ok(city));
}
public async Task <IActionResult> AddCityByCep(int cep)
{
if (cep < 10000000)
{
return(BadRequest("Invalid Cep"));
}
var city = await CepServices.GetCityByCep(cep);
if (city == null)
{
return(BadRequest("City does not exists in this zip code"));
}
var createdCity = await CitiesRepository.CreateCity(city.Name);
return(Ok(createdCity));
}
public static string GetLogisticCentername()
{
IEnumerable <DTO.City> cities = GetCities();
DTO.City logisticCenter = cities.FirstOrDefault(c => c.IsLogisticCenter == true);
IEnumerable <DTO.Road> roads = RoadsManager.GetRoads();
IEnumerable <DTO.Road> connectedRoadsTmp = null;
DTO.Road furthestRoad = new DTO.Road();
int newLogisticCenterId = 0;
foreach (DTO.City city in cities)
{
connectedRoadsTmp = roads.Where(r => r.SideCityOneId == city.Id || r.SideCityTwoId == city.Id);
if (connectedRoadsTmp != null && connectedRoadsTmp.Count() > 0)
{
DTO.Road closestRoadTmp = connectedRoadsTmp.OrderBy(r => r.Length).First();
if (closestRoadTmp.Length > furthestRoad.Length)
{
furthestRoad = closestRoadTmp;
// Get logistic center city id which is opposite side of the furthest city
newLogisticCenterId = city.Id == furthestRoad.SideCityOneId ? furthestRoad.SideCityTwoId : furthestRoad.SideCityOneId;
}
}
}
if (logisticCenter != null && logisticCenter.Id == newLogisticCenterId)
{
throw new CustomException("Logistic center hasn't changed.");
}
else if (newLogisticCenterId == 0)
{
throw new CustomException("Logistic center doesn't exist.");
}
else
{
logisticCenter = cities.First(c => c.Id == newLogisticCenterId);
CitiesRepository.SetLogisticCenter(logisticCenter);
}
return(logisticCenter.Name);
}
public UnitOfWork(DataContext context)
{
_context = context;
Users = new UsersRepository(_context);
Photos = new PhotosRepository(_context);
Groups = new GroupsRepository(_context);
Memberships = new MembershipsRepository(_context);
Auths = new AuthRepository(_context);
Comments = new CommentsRepository(_context);
Achievements = new AchievementsRepository(_context);
Cities = new CitiesRepository(_context);
Countries = new CountriesRepository(_context);
Locations = new LocationsRepository(_context);
Matchdays = new MatchdaysRepository(_context);
MatchStatuses = new MatchStatusesRepository(_context);
Friends = new FriendsRepository(_context);
Messages = new MessagesRepository(_context);
Chats = new ChatsRepository(_context);
}
public ActionResult GetCitiesByCountryId(string countryId)
{
if (!Request.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
else
{
if (!string.IsNullOrWhiteSpace(countryId))
{
var repo = new CitiesRepository();
IEnumerable <SelectListItem> cities = repo.GetCities(countryId);
return(Json(cities, JsonRequestBehavior.AllowGet));
}
else
{
return(null);
}
}
}
private SearchService CreateSearchService()
{
var options = new DbContextOptionsBuilder <BookMyTicketDBContext>()
.UseInMemoryDatabase(nameof(SearchServiceTest), new InMemoryDatabaseRoot())
.Options;
var dbContext = new BookMyTicketDBContext(options);
var cityRepository = new CitiesRepository(dbContext);
var movieRepository = new MoviesRepository(dbContext);
var cinemaRepository = new CinemasRepository(dbContext);
var showsRepository = new ShowsRepository(dbContext);
var cinemaSeatingRepository = new CinemaSeatingRepository(dbContext);
var ticketsRepository = new TicketsRepository(dbContext);
var reservationsRepository = new ReservationsRepository(dbContext);
var productProfile = new MappingProfile();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(productProfile));
var mapper = new Mapper(configuration);
MockDB(dbContext);
return(new SearchService(cityRepository, movieRepository, cinemaRepository, showsRepository, cinemaSeatingRepository, ticketsRepository, reservationsRepository, mapper));
}
public void GetAll_ReturnsCorrectData()
{
// arrange
var models = new[]
{
new CityModel
{
Id = 1,
Name = "1"
},
new CityModel
{
Id = 3,
Name = "3"
},
new CityModel
{
Id = 2,
Name = "2"
}
};
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
dataStoreMock.Setup(mock => mock.GetAll <CityModel>())
.Returns(models.AsQueryable());
var repository = new CitiesRepository(
dataStoreMock.Object
);
// act
var items = repository.GetAll().ToList();
// assert
Assert.AreEqual(3, items.Count);
Assert.AreEqual(1, items[0].Id);
Assert.AreEqual(2, items[1].Id);
Assert.AreEqual(3, items[2].Id);
}
public void AddAll_CallsDataStore()
{
// arrange
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
var repository = new CitiesRepository(
dataStoreMock.Object
);
// act
repository.AddAll(new[]
{
new CityModel
{
Id = 1,
Name = "1"
}
});
// assert
dataStoreMock.Verify(mock => mock.InsertAll(It.Is <IEnumerable <CityModel> >(item => item.First().Id == 1)), Times.Once());
}
public void GetAll_CallsDataStore()
{
// arrange
var models = new[]
{
new CityModel
{
Id = 1,
Name = "1"
},
new CityModel
{
Id = 3,
Name = "3"
},
new CityModel
{
Id = 2,
Name = "2"
}
};
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
dataStoreMock.Setup(mock => mock.GetAll <CityModel>())
.Returns(models.AsQueryable());
var repository = new CitiesRepository(
dataStoreMock.Object
);
// act
var items = repository.GetAll().ToList();
// assert
dataStoreMock.Verify(mock => mock.GetAll <CityModel>(), Times.Once());
}
public EmployeeUser()
{
DesignationsRepository _designationRep = new DesignationsRepository();
Designations = _designationRep.Get();
DesignationList = Designations.ToDesignationSelectListItems(DesignationID);
DepartmentRepository _departmentRep = new DepartmentRepository();
Departments = _departmentRep.Get();
DepartmentList = Departments.ToDepartmentSelectListItems(DepartmentCode);
CitiesRepository _citiesRep = new CitiesRepository();
Cities = _citiesRep.Get();
CityList = Cities.ToCitySelectListItems(CityID);
ProcedureNameHandling.GetSP = "GetCountry";
Countries = _basicRep.Get();
CountriesList = Countries.ToCountrySelectListItems(Nationality);
ProcedureNameHandling.GetSP = "GetGender";
Genders = _basicRep.Get();
GenderList = Genders.ToGenderSelectListItems(GenderID);
ProcedureNameHandling.GetSP = "GetEducation";
Educations = _basicRep.Get();
EducationList = Educations.ToEducationSelectListItems(EducationID);
ProcedureNameHandling.GetSP = "GetReligion";
Religion = _basicRep.Get();
ReligionList = Religion.ToReligionSelectListItems(ReligionID);
ProcedureNameHandling.GetSP = "GetMaritalStatus";
MaritalStatusCode = _basicRep.Get();
MaritalStatusList = MaritalStatusCode.ToMaritalStatusSelectListItems(MaritalStatusID);
}
public void GetById_ReturnsCorrectData()
{
// arrange
var model = new CityModel
{
Id = 1,
Name = "1"
};
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
dataStoreMock.Setup(mock => mock.GetById <CityModel, int>(It.IsAny <int>()))
.Returns(model);
var repository = new CitiesRepository(
dataStoreMock.Object
);
// act
var item = repository.GetById(1);
// assert
Assert.AreEqual(1, item.Id);
}
