public void Compare_ReturnsCorrectData_Equals()
{
// arrange
var zipCode = new ZipCodeModel
{
Latitude = 1,
Longitude = 1
};
var zipCode1 = new ZipCodeModel
{
Latitude = 2,
Longitude = 2
};
var zipCode2 = new ZipCodeModel
{
Latitude = 3,
Longitude = 3
};
var locationServiceMock = new Mock <ILocationService>(MockBehavior.Loose);
var comparer = new ZipCodeComparer(
locationServiceMock.Object,
zipCode
);
// act
var result = comparer.Compare(zipCode1, zipCode2);
// assert
Assert.AreEqual(0, result);
}
public void GetById_ReturnsCorrectData()
{
// arrange
var model = new ZipCodeModel
{
Id = 1,
Zip = 1
};
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
dataStoreMock.Setup(mock => mock.GetById <ZipCodeModel, int>(It.IsAny <int>()))
.Returns(model);
var locationServiceMock = new Mock <ILocationService>(MockBehavior.Loose);
var repository = new ZipCodesRepository(
dataStoreMock.Object,
locationServiceMock.Object
);
// act
var item = repository.GetById(1);
// assert
Assert.AreEqual(1, item.Id);
}
public void GetById_CallsDataStore()
{
// arrange
var model = new ZipCodeModel
{
Id = 1,
Zip = 1
};
var dataStoreMock = new Mock <IDataStore>(MockBehavior.Loose);
dataStoreMock.Setup(mock => mock.GetById <ZipCodeModel, int>(It.IsAny <int>()))
.Returns(model);
var locationServiceMock = new Mock <ILocationService>(MockBehavior.Loose);
var repository = new ZipCodesRepository(
dataStoreMock.Object,
locationServiceMock.Object
);
// act
repository.GetById(1);
// assert
dataStoreMock.Verify(mock => mock.GetById <ZipCodeModel, int>(It.Is <int>(item => item == 1)), Times.Once());
}
public HttpResponseMessage DataByZipCode(ZipCodeModel zipCode)
{
IRequestModel tmp = zipCode;
GenerateURL urlobj = new GenerateURL(Endpoints.ByZipCode, tmp.Get());
return(new HttpResponseMessage()
{
Content = new StringContent(Test.CreateObject(urlobj.GeneratedURL))
});
}
public IActionResult Check([FromForm] ZipCodeModel model)
{
var zipCode = _zipCodeRepository.Check(model.ZipCode);
if (zipCode)
{
return(Ok("Bu posta kodu ile işlem yapılabilir."));
}
throw new ApiException("Bu Posta Kodu ile hizmet veremiyoruz.");
}
public static ZipCodeItemViewModel Create(ZipCodeModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
return(new ZipCodeItemViewModel
{
Model = model
});
}
public async Task SelectCommand_NavigatesToCorrectViewModelWithCorrectData()
{
// arrange
var zipCode = new ZipCodeModel
{
Id = 3,
CityId = 2,
Zip = 123,
Latitude = 10,
Longitude = 20
};
var city = new CityModel
{
Id = 2,
Name = "test"
};
var navigationsServiceMock = new Mock <IMvxNavigationService>(MockBehavior.Loose);
var alertServiceMock = MockHelpers.CreateAlertService();
var zipCodesRepositoryMock = new Mock <IZipCodesRepository>(MockBehavior.Loose);
zipCodesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(zipCode);
zipCodesRepositoryMock.Setup(mock => mock.GetNearby(It.IsAny <int>(), It.IsAny <int>()))
.Returns(new[] { zipCode });
var citiesRepositoryMock = new Mock <ICitiesRepository>(MockBehavior.Loose);
citiesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(city);
var viewModel = new ZipCodeViewModel(
navigationsServiceMock.Object,
alertServiceMock.Object,
zipCodesRepositoryMock.Object,
citiesRepositoryMock.Object
);
// act
await viewModel.LoadCommand.ExecuteAsync();
await viewModel.SelectCommand.ExecuteAsync(viewModel.Nearby.First());
// assert
navigationsServiceMock.Verify(mock => mock.Navigate <ZipCodeViewModel, ZipCodeViewModel.Parameter>(
It.Is <ZipCodeViewModel.Parameter>(item => item.ZipCodeId == 3),
It.IsAny <IMvxBundle>()
), Times.Once());
}
public async Task LoadCommand_CallsZipCodesRepository_LoadNearbyData()
{
// arrange
var zipCode = new ZipCodeModel
{
Id = 3,
CityId = 2,
Zip = 123,
Latitude = 10,
Longitude = 20
};
var city = new CityModel
{
Id = 2,
Name = "test"
};
var navigationsServiceMock = new Mock <IMvxNavigationService>(MockBehavior.Loose);
var alertServiceMock = MockHelpers.CreateAlertService();
var zipCodesRepositoryMock = new Mock <IZipCodesRepository>(MockBehavior.Loose);
zipCodesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(zipCode);
zipCodesRepositoryMock.Setup(mock => mock.GetNearby(It.IsAny <int>(), It.IsAny <int>()))
.Returns(new[] { zipCode });
var citiesRepositoryMock = new Mock <ICitiesRepository>(MockBehavior.Loose);
citiesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(city);
var viewModel = new ZipCodeViewModel(
navigationsServiceMock.Object,
alertServiceMock.Object,
zipCodesRepositoryMock.Object,
citiesRepositoryMock.Object
);
// act
await viewModel.Initialize(new ZipCodeViewModel.Parameter(3));
await viewModel.LoadCommand.ExecuteAsync();
// assert
zipCodesRepositoryMock.Verify(mock => mock.GetNearby(
It.Is <int>(item => item == 3),
It.Is <int>(item => item == Configuration.NearbyZipCodesCount)
), Times.Once());
}
public void Creator_SetsZipCorrectly()
{
// arrange
var model = new ZipCodeModel
{
Id = 2,
Zip = 1234
};
// act
var viewModel = ZipCodeItemViewModel.Create(model);
// assert
Assert.AreEqual(model.Zip, viewModel.Zip);
}
public async Task LoadCommand_CallsCityRepository_SetCityData()
{
// arrange
var zipCode = new ZipCodeModel
{
Id = 3,
CityId = 2,
Zip = 123,
Latitude = 10,
Longitude = 20
};
var city = new CityModel
{
Id = 2,
Name = "test"
};
var navigationsServiceMock = new Mock <IMvxNavigationService>(MockBehavior.Loose);
var alertServiceMock = MockHelpers.CreateAlertService();
var zipCodesRepositoryMock = new Mock <IZipCodesRepository>(MockBehavior.Loose);
zipCodesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(zipCode);
var citiesRepositoryMock = new Mock <ICitiesRepository>(MockBehavior.Loose);
citiesRepositoryMock.Setup(mock => mock.GetById(It.IsAny <int>()))
.Returns(city);
var viewModel = new ZipCodeViewModel(
navigationsServiceMock.Object,
alertServiceMock.Object,
zipCodesRepositoryMock.Object,
citiesRepositoryMock.Object
);
// act
await viewModel.Initialize(new ZipCodeViewModel.Parameter(3));
await viewModel.LoadCommand.ExecuteAsync();
// assert
Assert.AreEqual(city.Name, viewModel.City);
}
public void Compare_ReturnsCorrectData_Less()
{
// arrange
var zipCode = new ZipCodeModel
{
Latitude = 1,
Longitude = 1
};
var zipCode1 = new ZipCodeModel
{
Latitude = 2,
Longitude = 2
};
var zipCode2 = new ZipCodeModel
{
Latitude = 3,
Longitude = 3
};
var locationServiceMock = new Mock <ILocationService>(MockBehavior.Loose);
locationServiceMock.Setup(mock => mock.GetDistance(
It.Is <LocationModel>(item => item.Latitude == 1 && item.Longitude == 1),
It.Is <LocationModel>(item => item.Latitude == 2 && item.Longitude == 2)
)).Returns(5);
locationServiceMock.Setup(mock => mock.GetDistance(
It.Is <LocationModel>(item => item.Latitude == 1 && item.Longitude == 1),
It.Is <LocationModel>(item => item.Latitude == 3 && item.Longitude == 3)
)).Returns(10);
var comparer = new ZipCodeComparer(
locationServiceMock.Object,
zipCode
);
// act
var result = comparer.Compare(zipCode1, zipCode2);
// assert
Assert.Greater(0, result);
}
public void Compare_CallsLocationService()
{
// arrange
var zipCode = new ZipCodeModel
{
Latitude = 1,
Longitude = 1
};
var zipCode1 = new ZipCodeModel
{
Latitude = 2,
Longitude = 2
};
var zipCode2 = new ZipCodeModel
{
Latitude = 3,
Longitude = 3
};
var locationServiceMock = new Mock <ILocationService>(MockBehavior.Loose);
var comparer = new ZipCodeComparer(
locationServiceMock.Object,
zipCode
);
// act
var result = comparer.Compare(zipCode1, zipCode2);
// assert
locationServiceMock.Verify(mock => mock.GetDistance(
It.Is <LocationModel>(item => item.Latitude == 1 && item.Longitude == 1),
It.Is <LocationModel>(item => item.Latitude == 2 && item.Longitude == 2)
), Times.Once());
locationServiceMock.Verify(mock => mock.GetDistance(
It.Is <LocationModel>(item => item.Latitude == 1 && item.Longitude == 1),
It.Is <LocationModel>(item => item.Latitude == 3 && item.Longitude == 3)
), Times.Once());
}
public async Task <IActionResult> UpdateZipCode([FromBody] ZipCodeModel model)
{
var pd = await _personalDataService.GetAsync(_requestContext.ClientId);
var kycStatusValid = await _kycStatusValidator.ValidatePersonalDataUpdateForFieldAsync(pd.Zip);
if (!kycStatusValid)
{
throw LykkeApiErrorException.BadRequest(LykkeApiErrorCodes.Service.KycRequired);
}
var changes = new KycPersonalDataChanges {
Changer = Startup.ComponentName, Items = new Dictionary <string, JToken>()
};
changes.Items.Add(nameof(model.Zip), model.Zip);
await _kycProfileService.UpdatePersonalDataAsync(_requestContext.ClientId, changes);
return(Ok());
}
public async Task <ZipCodeModel> CreateAsync(
ZipCodeModel model,
CancellationToken cancellationToken)
{
var included = new Func <IIncludable <City>, IIncludable>(x => x.Include(i => i.State).Include(i => i.Country));
var existingCity = await _cityService.GetFirstOrDefaultAsync(
x => x.Id == model.CityId, included, cancellationToken : cancellationToken);
if (existingCity == default)
{
throw new BadRequestException($"Invalid {nameof(model.CityId)}");
}
model.CountryId = existingCity.CountryId;
model.Country = existingCity.Country;
model.StateId = existingCity.StateId;
model.State = existingCity.State;
model.City = existingCity;
var created = await _zipCodeService.CreateSingleAsync(model, cancellationToken);
return(created);
}
static void Main(string[] args)
{
List <string> userIds = new List <string>();
var laywerList = new List <LaywerModel>();
var str = File.ReadAllText(@"C:\IIS\test\data\zeekbeek\data.txt");
var finalstr = JsonConvert.SerializeObject(userIds);
File.WriteAllText(@"C:\IIS\test\data\all.txt", finalstr);
return;
Municiplity();
// return;
var str = "480353652";
if (str.Length > 5)
{
str = str.Substring(0, 5);
}
// return;
var countyZip = new CountyZipModel();
var countyCode = ConfigurationManager.AppSettings.Get("countyCode").ToString();
countyZip.CountyCode = countyCode;
countyZip.County = ConfigurationManager.AppSettings.Get("county").ToString().ToUpper();
countyZip.ZipCodeList = new List <ZipCodeModel>();
var url = string.Format("http://www.bestplaces.net/find/zip.aspx?st=mi&county={0}", countyCode);
var web = new HtmlWeb();
HtmlDocument doc = web.Load(url);
HtmlNodeCollection nodes = doc.DocumentNode.SelectNodes("//a[contains(@href,'/zip-code/michigan/')]");
foreach (HtmlNode node in nodes)
{
var zipCodeEntry = new ZipCodeModel();
var zipCode = node.InnerText;
zipCode = zipCode.Remove(zipCode.IndexOf("(")).Trim();
zipCodeEntry.ZipCode = zipCode;
countyZip.ZipCodeList.Add(zipCodeEntry);
}
countyZip.UseCounty = true;
var fileName = ConfigurationManager.AppSettings.Get("CountyZipFile").ToString();
var json = File.ReadAllText(fileName);
var oldList = JsonConvert.DeserializeObject <List <CountyZipModel> >(json);
if (oldList == null)
{
oldList = new List <CountyZipModel>();
oldList.Add(countyZip);
}
var firstItem = oldList.FirstOrDefault(x => x.CountyCode == countyZip.CountyCode);
if (firstItem == null)
{
oldList.Add(countyZip);
}
string nweJson = JsonConvert.SerializeObject(oldList);
System.IO.File.WriteAllText(fileName, nweJson);
}
public void ItIsPossibleToMapTheModelsZipCode()
{
var model = new ZipCodeModel
{
Id = Guid.NewGuid(),
ZipCode = Faker.RandomNumber.Next(1, 10000).ToString(),
PublicPlace = Faker.Address.StreetName().ToString(),
Number = Faker.RandomNumber.Next(1, 1000).ToString(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
CountyId = Guid.NewGuid()
};
var listZipCodeEntity = new List <ZipCodeEntity>();
for (int i = 0; i < 5; i++)
{
var itemZipCodeEntity = new ZipCodeEntity
{
Id = Guid.NewGuid(),
ZipCode = Faker.RandomNumber.Next(1, 10000).ToString(),
PublicPlace = Faker.Address.StreetName(),
Number = Faker.RandomNumber.Next(1, 10000).ToString(),
CountyId = Guid.NewGuid(),
CreateAt = DateTime.Now,
UpdateAt = DateTime.Now,
County = new CountyEntity
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
CodeIbge = Faker.RandomNumber.Next(1, 10000),
FederalUnitId = Guid.NewGuid(),
FederalUnit = new FederalUnitEntity
{
Id = Guid.NewGuid(),
Name = Faker.Address.UsState(),
Initials = Faker.Address.UsState().Substring(1, 3)
}
}
};
listZipCodeEntity.Add(itemZipCodeEntity);
}
#region Model => Entity
//Model => Entity
var zipCodeEntity = Mapper.Map <ZipCodeEntity>(model);
Assert.Equal(zipCodeEntity.Id, model.Id);
Assert.Equal(zipCodeEntity.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeEntity.Number, model.Number);
Assert.Equal(zipCodeEntity.CreateAt, model.CreateAt);
Assert.Equal(zipCodeEntity.UpdateAt, model.UpdateAt);
#endregion
#region Entity => Dto
//Entity => Dto
var zipCodeDto = Mapper.Map <ZipCodeDto>(zipCodeEntity);
Assert.Equal(zipCodeDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeDto.Number, zipCodeEntity.Number);
Assert.Equal(zipCodeDto.ZipCode, zipCodeEntity.ZipCode);
#endregion
#region CompleteDto => Entity
// CompleteDto => Entity
var zipCodeCompleteDto = Mapper.Map <ZipCodeDto>(listZipCodeEntity.FirstOrDefault());
Assert.Equal(zipCodeCompleteDto.Id, listZipCodeEntity.FirstOrDefault().Id);
Assert.Equal(zipCodeCompleteDto.PublicPlace, listZipCodeEntity.FirstOrDefault().PublicPlace);
Assert.Equal(zipCodeCompleteDto.Number, listZipCodeEntity.FirstOrDefault().Number);
Assert.NotNull(zipCodeCompleteDto.County);
Assert.NotNull(zipCodeCompleteDto.County.FederalUnitId);
#endregion
#region List ZipCodeDto => List ZipCodeEntity
//List ZipCodeDto => List ZipCodeEntity
var listZipCodeDto = Mapper.Map <List <ZipCodeDto> >(listZipCodeEntity);
Assert.True(listZipCodeDto.Count() == listZipCodeEntity.Count());
for (int i = 0; i < listZipCodeDto.Count(); i++)
{
Assert.Equal(listZipCodeDto[i].Id, listZipCodeEntity[i].Id);
Assert.Equal(listZipCodeDto[i].ZipCode, listZipCodeEntity[i].ZipCode);
Assert.Equal(listZipCodeDto[i].PublicPlace, listZipCodeEntity[i].PublicPlace);
Assert.Equal(listZipCodeDto[i].Number, listZipCodeEntity[i].Number);
}
#endregion
#region ZipCode Entity => ZipCode Create Result Dto
// ZipCode Entity => ZipCode Create Result Dto
var zipCodeCreateResultDto = Mapper.Map <ZipCodeCreateResultDto>(zipCodeEntity);
Assert.Equal(zipCodeCreateResultDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeCreateResultDto.ZipCode, zipCodeEntity.ZipCode);
Assert.Equal(zipCodeCreateResultDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeCreateResultDto.Number, zipCodeEntity.Number);
#endregion
#region ZipCode Entity => ZipCode Update Result Dto
// ZipCode Entity => ZipCode Update Result Dto
var zipCodeUpdateResultDto = Mapper.Map <ZipCodeUpdateResultDto>(zipCodeEntity);
Assert.Equal(zipCodeUpdateResultDto.Id, zipCodeEntity.Id);
Assert.Equal(zipCodeUpdateResultDto.ZipCode, zipCodeEntity.ZipCode);
Assert.Equal(zipCodeUpdateResultDto.PublicPlace, zipCodeEntity.PublicPlace);
Assert.Equal(zipCodeUpdateResultDto.Number, zipCodeEntity.Number);
#endregion
#region Dto => Model
// Dto => Model
zipCodeDto.Number = "";
var zipCodemodel = Mapper.Map <ZipCodeModel>(zipCodeDto);
Assert.Equal(zipCodemodel.Id, zipCodeDto.Id);
Assert.Equal(zipCodemodel.ZipCode, zipCodeDto.ZipCode);
Assert.Equal(zipCodemodel.PublicPlace, zipCodeDto.PublicPlace);
Assert.Equal("S/N", zipCodeDto.Number);
#endregion
#region Model => Create Dto
//Model => Create Dto
var zipCodeCreateDto = Mapper.Map <ZipCodeCreateDto>(model);
Assert.Equal(zipCodeCreateDto.ZipCode, model.ZipCode);
Assert.Equal(zipCodeCreateDto.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeCreateDto.Number, model.Number);
#endregion
#region Model => Update Dto
//Model => Update Dto
var zipCodeUpdateDto = Mapper.Map <ZipCodeUpdateDto>(model);
Assert.Equal(zipCodeUpdateDto.Id, model.Id);
Assert.Equal(zipCodeUpdateDto.ZipCode, model.ZipCode);
Assert.Equal(zipCodeUpdateDto.PublicPlace, model.PublicPlace);
Assert.Equal(zipCodeUpdateDto.Number, model.Number);
#endregion
}
