/// <summary>
/// 获取省份信息
/// </summary>
/// <returns></returns>
public JsonResult GetAllProvinces()
{
JsonResult json = new JsonResult();
json.Data = CityServices.QueryAllProvinces();
return(json);
}
public ContactsDiaryController(ContactsDiaryServices contactsDiaryServices, PropertiesServices propertyManager, CityServices cityManager, AgentServices agentServices)
{
_contactsDiaryServices = contactsDiaryServices;
_propertyManager = propertyManager;
_cityManager = cityManager;
_agentServices = agentServices;
}
public string Search_Company()
{
String str = Request.Params["str"];
// List<BaseCompany> companys = CompanyServices.QueryCompanyAndSubordinateCompany(GetCurrentUserCompanyId);
List <BaseCompany> companys = CompanyServices.QueryAllCompanyByName(GetCurrentUserCompanyId, str);
BaseCompany currCompany = companys.FirstOrDefault(p => p.CPID == GetCurrentUserCompanyId);
if (currCompany == null)
{
return(string.Empty);
}
List <BaseCity> citys = CityServices.QueryAllCitys();
StringBuilder strTree = new StringBuilder();
strTree.Append("{\"rows\":[{");
strTree.AppendFormat("\"CPID\":\"{0}\"", currCompany.CPID);
strTree.AppendFormat(",\"CPName\":\"{0}\"", currCompany.CPName);
strTree.AppendFormat(",\"Address\":\"{0}\"", currCompany.Address);
strTree.AppendFormat(",\"LinkMan\":\"{0}\"", currCompany.LinkMan);
strTree.AppendFormat(",\"Mobile\":\"{0}\"", currCompany.Mobile);
strTree.AppendFormat(",\"MasterID\":\"{0}\"", currCompany.MasterID);
strTree.AppendFormat(",\"CityID\":\"{0}\"", currCompany.CityID);
strTree.AppendFormat(",\"ProvinceID\":\"{0}\"", "0");
strTree.Append(",\"iconCls\":\"my-company-icon\"}");
GetSubordinateCompany(companys, citys, currCompany.CPID, strTree);
strTree.Append("]}");
return(strTree.ToString());
}
public async Task ThrowsException_WhenCityAlreadyExists()
{
var cityFactoryMock = new Mock <ICityFactory>();
var cityName = "Name";
var city = new City
{
Name = cityName
};
cityFactoryMock
.Setup(f => f.Create(cityName))
.Returns(city);
var options = TestUtilities.GetOptions(nameof(ThrowsException_WhenCityAlreadyExists));
using (var arrangeContext = new CocktailMagicianDb(options))
{
arrangeContext.Cities.Add(city);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CocktailMagicianDb(options))
{
var sut = new CityServices(assertContext, cityFactoryMock.Object);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.AddAsync(cityName));
}
}
public ActionResult DeleteCity(long id)
{
var gVal = new GenericValidator();
try
{
if (id < 1)
{
gVal.Code = -1;
gVal.Error = message_Feedback.Invalid_Selection;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
var k = new CityServices().DeleteCity(id);
if (k)
{
gVal.Code = 5;
gVal.Error = message_Feedback.Delete_Success;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
gVal.Code = -1;
gVal.Error = message_Feedback.Delete_Failure;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
catch
{
gVal.Code = 5;
gVal.Error = message_Feedback.Process_Failed;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
}
public async Task AddCityToDatabase()
{
var cityFactoryMock = new Mock <ICityFactory>();
var cityName = "Name";
var city = new City
{
Name = cityName
};
cityFactoryMock
.Setup(f => f.Create(cityName))
.Returns(city);
var options = TestUtilities.GetOptions(nameof(AddCityToDatabase));
using (var assertContext = new CocktailMagicianDb(options))
{
var sut = new CityServices(assertContext, cityFactoryMock.Object);
var cityInDB = await sut.AddAsync(cityName);
Assert.IsTrue(await assertContext.Cities.AnyAsync(i => i.Name == cityName));
Assert.AreEqual(1, assertContext.Cities.Count());
Assert.IsTrue(cityInDB.Name == cityName);
}
}
public void ReturnCollectionOfGenreNames_WhenTheyExist()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <AlphaCinemaContext>()
.UseInMemoryDatabase(databaseName: "ReturnCollectionOfGenreNames_WhenTheyExist")
.Options;
using (var actContext = new AlphaCinemaContext(contextOptions))
{
actContext.Cities.Add(testCity);
actContext.MoviesGenres.Add(testMovieGenre);
actContext.Movies.Add(testMovie);
actContext.Genres.Add(testGenre);
actContext.Projections.Add(testProjection);
actContext.SaveChanges();
}
//Act and Assert
using (var assertContext = new AlphaCinemaContext(contextOptions))
{
var unitOfWork = new UnitOfWork(assertContext);
var cityService = new CityServices(unitOfWork);
var result = cityService.GetGenreNames(testCityId);
Assert.IsTrue(result.Count == 1);
Assert.AreEqual(result.First(), testGenreName);
}
}
public void GetAllCities_Should_NotBeCalled_IfItIsNeverCalled()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
mockedRepository.Verify(rep => rep.All(), Times.Never);
}
/// <summary>
/// 根据省份获取下面市区
/// </summary>
/// <param name="provinceId"></param>
/// <returns></returns>
public JsonResult GetCitys(int provinceId)
{
JsonResult json = new JsonResult();
json.Data = CityServices.QueryCitysByProvinceId(provinceId);
return(json);
}
public StopoverPointsController(StopoverPointServices stopoverPointServices,
CityServices cityServices,
IMapper mapper, IToastNotification toastNotification) : base(toastNotification)
{
_stopoverPointsServices = stopoverPointServices;
_cityServices = cityServices;
_mapper = mapper;
}
public void Constructor_Should_CreateCityServices_IfParamsAreValid()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
Assert.That(cityService, Is.InstanceOf <CityServices>());
}
public void GetById_Should_NotBeCalled_IfNotCalledYolo()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
mockedRepository.Verify(rep => rep.GetById(1), Times.Never);
}
public PropertySearchesController(PropertySearchServices propertySearchServices, PropertiesServices propertyManager, CityServices cityManager, UserServices userServices, ReviewServices reviewsManager)
{
_propertySearchServices = propertySearchServices;
_propertyManager = propertyManager;
_cityManager = cityManager;
_userServices = userServices;
_reviewsManager = reviewsManager;
}
public RentalInfoesController(RentalInfoServices rentalInfoServices, ExtraServices extraServices, CityServices cityManager, PropertiesServices propertyManager, ClientServices clientsManager, UserServices userServices)
{
_rentalInfoManager = rentalInfoServices;
_extrasManager = extraServices;
_cityManager = cityManager;
_propertyManager = propertyManager;
_clientsManager = clientsManager;
_userServices = userServices;
}
public void GetById_ShouldThrowNullReferenceException_IfCityIsNull()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
Mock <City> cityWithIdNull = null;
Assert.Throws <NullReferenceException>(() => cityService.GetById(cityWithIdNull.Object.Id));
}
public void GetAllCities_Should_BeCalledOnce_IfParamsAreValid()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
cityService.GetAllCities();
mockedRepository.Verify(rep => rep.All(), Times.Once);
}
public void GetById_Should_NotReturnCity_IfThereIsNoCityYolo()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
mockedRepository.Setup(rep => rep.GetById(0)).Returns(() => null);
Assert.IsNull(cityService.GetById(0));
}
public ActionResult EditCity(CityObject city)
{
var gVal = new GenericValidator();
try
{
if (ModelState.IsValid)
{
var valStatus = ValidateCity(city);
if (valStatus.Code < 1)
{
gVal.Code = 0;
gVal.Error = valStatus.Error;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
if (Session["_city"] == null)
{
gVal.Code = -1;
gVal.Error = message_Feedback.Session_Time_Out;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
var oldCity = Session["_city"] as CityObject;
if (oldCity == null || oldCity.CityId < 1)
{
gVal.Code = -5;
gVal.Error = message_Feedback.Session_Time_Out;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
oldCity.Name = city.Name.Trim();
oldCity.StateId = city.StateId;
var k = new CityServices().UpdateCity(oldCity);
if (k < 1)
{
gVal.Error = k == -3 ? message_Feedback.Item_Duplicate : message_Feedback.Update_Failure;
gVal.Code = 0;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
gVal.Code = 5;
gVal.Error = message_Feedback.Update_Success;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
gVal.Code = -5;
gVal.Error = message_Feedback.Process_Failed;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
catch
{
gVal.Code = -1;
gVal.Error = message_Feedback.Process_Failed;
return(Json(gVal, JsonRequestBehavior.AllowGet));
}
}
public void ThrowEntityDoesntExistException_WhenCityDoesNotExist()
{
//Arrange
unitOfWork.Setup(x => x.Cities).Returns(cityRepoMock.Object);
//Act and Assert
var command = new CityServices(unitOfWork.Object);
Assert.ThrowsException <EntityDoesntExistException>(() => command.DeleteCity(testCityName));
}
public void GetAllCities_Should_ThrowArgumentNullException_IfPassedAdvertsAreNull()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
IEnumerable <City> expectedCitiesResult = null;
mockedRepository.Setup(rep => rep.All()).Returns(() => expectedCitiesResult.AsQueryable());
Assert.Throws <ArgumentNullException>(() => cityService.GetAllCities());
}
public void GetById_Should_Work_IfCalledWithValidParams()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
var cityWithId = new Mock <City>();
mockedRepository.Setup(rep => rep.GetById(cityWithId.Object.Id)).Returns(() => cityWithId.Object);
Assert.AreEqual(cityService.GetById(cityWithId.Object.Id), cityWithId.Object);
}
public void GetById_Should_ReturnTheProperCityWithId_IfCalled()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
var cityWithId = new Mock <City>();
mockedRepository.Setup(rep => rep.GetById(cityWithId.Object.Id)).Returns(() => cityWithId.Object);
Assert.IsInstanceOf <City>(cityService.GetById(cityWithId.Object.Id));
}
public void ThrowArgumentException_WhenCityNameLengthIsNotInRange()
{
//Arrange
int maxCityNameLength = 50;
var longCityName = new string('c', maxCityNameLength + 1);
var cityService = new CityServices(unitOfWork.Object);
//Act and Assert
Assert.ThrowsException <ArgumentException>(() => cityService.AddNewCity(longCityName));
}
public void ThrowEntityDoesNotExistException_WhenCityDoesNotExist()
{
//Act
var cityService = new CityServices(unitOfWork.Object);
unitOfWork.Setup(x => x.Cities).Returns(cityRepoMock.Object);
cityRepoMock.Setup(repo => repo.AllAndDeleted()).Returns(resultFromCityRepo.AsQueryable());
//Assert
Assert.ThrowsException <EntityDoesntExistException>(() => cityService.GetID("NonExistingCity"));
}
public void GetAllCities_Should_ReturnEmptyCollection_IfThereAreNoCitiesAdded()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
IEnumerable <City> expectedCitiesResult = new List <City>();
mockedRepository.Setup(rep => rep.All()).Returns(() => expectedCitiesResult.AsQueryable());
Assert.IsEmpty(cityService.GetAllCities());
}
public void ThrowEntityAlreadyExistsException_WhenCityExist()
{
//Arrange
unitOfWork.Setup(x => x.Cities).Returns(cityRepoMock.Object);
cityRepoMock.Setup(repo => repo.AllAndDeleted()).Returns(predifinedListOfCities.AsQueryable());
//Act and Assert
var addCityCommand = new CityServices(unitOfWork.Object);
Assert.ThrowsException <EntityAlreadyExistsException>(() => addCityCommand.AddNewCity(testCityName));
}
public ReportsController(WebPlatformServices webPlatformsManager
, PromotionMediaServices promotionMediaServices, PartnerServices partnerServices
, ReportServices reportServices, OwnerServices ownersManager, CityServices cityServices)
{
_webPlatformsManager = webPlatformsManager;
_promotionMediaServices = promotionMediaServices;
_partnerServices = partnerServices;
_reportServices = reportServices;
_ownersManager = ownersManager;
_cityServices = cityServices;
}
public void TestGoogleApiCitySearchSequence()
{
CityServices hc = new CityServices();
//nearbyplaces result = hc.SearchCity("Lyon").Result;
//Assert.IsInstanceOfType(result, typeof(JsonResult));
//JsonResult routeResult = result as JsonResult;
//Assert.IsTrue(result != null );
//Assert.IsTrue(result.geonames.Count >0);
}
public AddressController(bookstoreContext context,
CityServices cityServices,
UserAddressService userAddressService,
UserServices userServices,
IMapper mapper)
{
_context = context;
_cityServices = cityServices;
_userAddressService = userAddressService;
_userServices = userServices;
_mapper = mapper;
}
public void GetById_Should_ReturnTheCorrectCity_IfCalled()
{
var mockedRepository = new Mock <IRepository <City> >();
var cityService = new CityServices(mockedRepository.Object);
var city = new Mock <City>();
var secondCity = new Mock <City>();
mockedRepository.Setup(rep => rep.GetById(city.Object.Id)).Returns(() => city.Object);
Assert.AreNotEqual(cityService.GetById(city.Object.Id), secondCity.Object);
}
