public IActionResult GetBackground()
{
string path = System.IO.Path.Combine(_hostingEnvironment.WebRootPath, @"GeoIPDB/GeoLite2-City.mmdb");
CityResponse city = new CityResponse()
{
};
using (var reader = new DatabaseReader(path))
{
var ip = _accessor.ActionContext.HttpContext.Connection.RemoteIpAddress.ToString();
city = reader.City(ip);
}
//Assign API KEY which received from OPENWEATHERMAP.ORG
string appId = "51484507182468c91ba33387b57568d8";
//API path with CITY parameter and other parameters.
string url = "http://api.openweathermap.org/data/2.5/weather?q=" + city.City + "&units=metric&cnt=1&APPID=" + appId;
Background background = new Background()
{
};
using (WebClient client = new WebClient())
{
string json = client.DownloadString(url);
WeatherAPIViewModel weatherInfo = (new JavaScriptSerializer()).Deserialize <WeatherAPIViewModel>(json);
background.ChooseBackground(weatherInfo.weather[0].main);
}
if (city.City == null)
{
return(Json(new { success = false, BackgroundImageUrl = background.GetBackground() }));
}
return(Json(new { success = true, backgroundImageUrl = background.GetBackground() }));
}
public CityResponse Create(CityViewModel city)
{
CityResponse response = new CityResponse();
using (SqliteConnection db = new SqliteConnection(SQLiteHelper.SqLiteTableName))
{
db.Open();
SqliteCommand insertCommand = db.CreateCommand();
insertCommand.CommandText = SqlCommandInsertPart;
try
{
insertCommand = AddCreateParameters(insertCommand, city);
insertCommand.ExecuteNonQuery();
}
catch (SqliteException error)
{
MainWindow.ErrorMessage = error.Message;
response.Success = false;
response.Message = error.Message;
return(response);
}
db.Close();
response.Success = true;
return(response);
}
}
public async Task CreateCityAsync_Should_Return_CreatedAtRouteResult_With_CityResponse()
{
var createCityRequest = new CreateCityRequest {
Name = "Name", PolishName = "PolishName"
};
var createCityCommand = new CreateCityCommand(Guid.NewGuid(), createCityRequest.Name,
createCityRequest.PolishName, Guid.NewGuid());
var cityOutputQuery = new CityOutputQuery(createCityCommand.CityId, Array.Empty <byte>(), createCityCommand.Name,
createCityCommand.PolishName, createCityCommand.StateId);
var cityResponse = new CityResponse(cityOutputQuery.Id, cityOutputQuery.RowVersion, cityOutputQuery.Name,
cityOutputQuery.PolishName, cityOutputQuery.StateId);
_mapperMock.Setup(x => x.Map <CreateCityRequest, CreateCityCommand>(It.IsAny <CreateCityRequest>())).Returns(createCityCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <CreateCityCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getCityQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cityOutputQuery);
_mapperMock.Setup(x => x.Map <CityOutputQuery, CityResponse>(It.IsAny <CityOutputQuery>())).Returns(cityResponse);
var result = await _controller.CreateCityAsync(createCityRequest);
var createdAtRouteResult = result.As <CreatedAtRouteResult>();
createdAtRouteResult.Value.Should().BeEquivalentTo(cityResponse);
createdAtRouteResult.RouteName.Should().BeEquivalentTo("GetCity");
createdAtRouteResult.RouteValues.Should().BeEquivalentTo(new RouteValueDictionary(new { id = cityResponse.Id }));
}
public async Task UpdateCityAsync_Should_Return_OkObjectResult_With_CityResponse()
{
var rowVersion = new byte[] { 1, 2, 4, 8, 16, 32, 64 };
var cityId = Guid.NewGuid();
var updateCityRequest = new UpdateCityRequest
{
Id = cityId,
Name = "Name",
PolishName = "PolishName",
StateId = Guid.NewGuid()
};
var updateCityCommand = new UpdateCityCommand(updateCityRequest.Id, rowVersion, updateCityRequest.Name,
updateCityRequest.PolishName, updateCityRequest.StateId);
var cityOutputQuery = new CityOutputQuery(updateCityCommand.CityId, new byte[] { 1, 2, 4, 8, 16, 32, 128 },
updateCityCommand.Name, updateCityCommand.PolishName, updateCityCommand.StateId);
var cityResponse = new CityResponse(cityOutputQuery.Id, cityOutputQuery.RowVersion,
cityOutputQuery.Name, cityOutputQuery.PolishName, cityOutputQuery.StateId);
_mapperMock.Setup(x => x.Map <UpdateCityRequest, UpdateCityCommand>(It.IsAny <UpdateCityRequest>()))
.Returns(updateCityCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <UpdateCityCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getCityQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cityOutputQuery);
_mapperMock.Setup(x => x.Map <CityOutputQuery, CityResponse>(It.IsAny <CityOutputQuery>())).Returns(cityResponse);
var result = await _controller.UpdateCityAsync(cityId, updateCityRequest, rowVersion);
var okObjectResult = result.As <OkObjectResult>();
okObjectResult.Value.Should().BeEquivalentTo(cityResponse);
}
public void GetCurrentWeatherByCity_When_Has_OK_Returns_Success()
{
var request = new ParameterRequest();
request.City = "Mauá";
request.State = "SP";
var response = new CityResponse()
{
StatusCode = HttpStatusCode.OK,
Detail = "Falha de comunicação.",
Id = 3954,
Name = "Nublado",
State = "SP",
Country = "Brasil",
};
_service.GetCurrentWeatherByCity(request).Returns(response);
var controller = new WeatherController(_service);
var result = controller.GetCurrentWeatherByCity(request);
result.Should().BeEquivalentTo(new OkObjectResult(response));
}
public Location(CityResponse cityResponse)
{
CityName = cityResponse.City.Name;
CountryName = cityResponse.Country.Name;
CountryCode = cityResponse.Country.IsoCode;
ContinentName = cityResponse.Continent.Name;
SubdivisionName = cityResponse.MostSpecificSubdivision.Name;
}
public static CityResponse CityEntityToResponse(CityEntity cityEntity)
{
CityResponse cityResponse = new CityResponse()
{
Name = cityEntity.Name
};
return(cityResponse);
}
public static CityEntity CityResponseToEntity(CityResponse cityResponse)
{
CityEntity cityEntity = new CityEntity()
{
Name = cityResponse.Name
};
return(cityEntity);
}
public static (AsnResponse, CityResponse) GetAsnCityValueTuple(string ipAddress)
{
var asn = new AsnResponse();
var city = new CityResponse();
Task.WaitAll(
Task.Run(() => asn = GetAsnResponse(ipAddress)),
Task.Run(() => city = GetCityResponse(ipAddress)));
return(asn, city);
}
public MainResponse GetAllCities(int StateId)
{
var cities = _cityRepository.GetAll(x => x.StateId == StateId && x.IsDeleted == false && x.IsActive == true).OrderBy(x => x.Name);
var cityResponse = _mapper.Map <List <City> >(cities);
CityResponse city = new CityResponse();
city.City = cityResponse;
_mainResponse.CityResponse = city;
_mainResponse.Success = true;
return(_mainResponse);
}
public ActionResult <CityResponse> GetCity(int id)
{
CityResponse cityResponse = cityServices.GetCity(id);
if (cityResponse == null)
{
return(NotFound());
}
return(cityResponse);
}
public CityResponse GetCityInfos(CityRequest cityRequest)
{
if (cityRequest.provinceId <= 0)
{
cityRequest.provinceId = 0;
}
CityResponse response = new CityResponse();
response.CityInfos = BaseBLL <CityBLL> .Instance.GetCityInfos(cityRequest.provinceId);
return(response);
}
public async Task <IActionResult> GetCities()
{
var model = await _cityService.GetAllCitiesAsync();
var response = new CityResponse
{
Code = "success",
Message = "cities.get.success",
Data = model,
};
return(Ok(response));
}
public void GetCurrentWeatherByCity_When_Success_Returns_CityResponse()
{
var request = new ParameterRequest()
{
City = "Mauá", State = "SP"
};
var baseM = _fixture.Build <BaseListModel>()
.With(x => x.Id, 1234)
.With(x => x.Name, "Mauá")
.With(x => x.State, "SP")
.With(x => x.Country, "BR")
.CreateMany(1);
var response = new CityResponse()
{
StatusCode = HttpStatusCode.OK,
Detail = "Falha de comunicação.",
Id = 1234,
Name = "Nublado",
State = "SP",
Country = "Brasil",
};
var cityID = 1234;
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK);
var jsonfile = JsonConvert.SerializeObject(baseM);
httpResponseMessage.Content = new StringContent(jsonfile);
httpResponseMessage.Content.Headers.ContentType.MediaType = "application/json";
_client.GetAsync($"{_host}/locale/city?name={request.City}&state={request.State}&{_token}").Returns(httpResponseMessage);
var httpResponse = new HttpResponseMessage(HttpStatusCode.OK);
var httpRequest = new HttpRequestMessage();
httpRequest.Content = new StringContent($"localeId[]={cityID}");
httpRequest.Content.Headers.ContentType.MediaType = "application/x-www-form-urlencoded";
_client.PutAsync("http://apiadvisor.climatempo.com.br/api-manager/user-token/f444ae97bad0cadc04e972d4566220f1/locales", httpRequest.Content).ReturnsForAnyArgs(httpResponse);
var httpResponseMessageResult = new HttpResponseMessage(HttpStatusCode.OK);
jsonfile = JsonConvert.SerializeObject(response);
httpResponseMessageResult.Content = new StringContent(jsonfile);
httpResponseMessageResult.Content.Headers.ContentType.MediaType = "application/json";
_client.GetAsync($"{_host}/weather/locale/1234/current?{_token}").Returns(httpResponseMessageResult);
var result = _service.GetCurrentWeatherByCity(request);
result.Should().BeEquivalentTo(response);
}
private static string PrepareExpectedResponse(CityEntity cityEntity)
{
var cityResponse = new CityResponse(cityEntity.Id, cityEntity.RowVersion, cityEntity.Name,
cityEntity.PolishName, cityEntity.StateId);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
return(JsonConvert.SerializeObject(cityResponse, settings));
}
public void GetCurrentWeatherByCity_When_IsNull_Returns_Null(string city, string state, bool hasInstance)
{
var request = !hasInstance ? null : new ParameterRequest()
{
City = city, State = state
};
var result = _service.GetCurrentWeatherByCity(request);
var response = new CityResponse()
{
Detail = "Parâmetros Inválidos",
StatusCode = HttpStatusCode.BadRequest
};
result.Should().BeEquivalentTo(response);
}
public async void suggestions_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
{
if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput && sender.Text.Length > 1)
{
sugg.Clear();
string data = await Requests.makeRequestAsync(
Requests.CITY_URL + sender.Text,
new Dictionary <string, string>());
response = Factory.Instance.getCityResponse(data);
foreach (City c in response.Cities)
{
sugg.Add(c);
}
}
}
public ActionResult <CityResponse> PostCity(CityEntity cityEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
CityResponse cityResponse = cityServices.SaveCity(cityEntity);
if (cityResponse == null)
{
return(BadRequest());
}
return(CreatedAtAction("GetCity", new { id = cityEntity.Id }, cityResponse));
}
public CityResponse Create(CityViewModel cityViewModel)
{
CityResponse response = new CityResponse();
try
{
response = WpfApiHandler.SendToApi <CityViewModel, CityResponse>(cityViewModel, "Create");
}
catch (Exception ex)
{
response.City = new CityViewModel();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public CityResponse GetCity(Guid identifier)
{
CityResponse response = new CityResponse();
CityViewModel City = new CityViewModel();
using (SqliteConnection db = new SqliteConnection("Filename=SirmiumERPGFC.db"))
{
db.Open();
try
{
SqliteCommand selectCommand = new SqliteCommand(
SqlCommandSelectPart +
"FROM Cities " +
"WHERE Identifier = @Identifier;", db);
selectCommand.Parameters.AddWithValue("@Identifier", identifier);
SqliteDataReader query = selectCommand.ExecuteReader();
if (query.Read())
{
int counter = 0;
CityViewModel dbEntry = new CityViewModel();
dbEntry.Id = SQLiteHelper.GetInt(query, ref counter);
dbEntry.Identifier = SQLiteHelper.GetGuid(query, ref counter);
dbEntry.Code = SQLiteHelper.GetString(query, ref counter);
dbEntry.Name = SQLiteHelper.GetString(query, ref counter);
dbEntry.IsSynced = SQLiteHelper.GetBoolean(query, ref counter);
dbEntry.UpdatedAt = SQLiteHelper.GetDateTime(query, ref counter);
dbEntry.CreatedBy = SQLiteHelper.GetCreatedBy(query, ref counter);
dbEntry.Company = SQLiteHelper.GetCompany(query, ref counter);
City = dbEntry;
}
}
catch (SqliteException error)
{
MainWindow.ErrorMessage = error.Message;
response.Success = false;
response.Message = error.Message;
response.City = new CityViewModel();
return(response);
}
db.Close();
}
response.Success = true;
response.City = City;
return(response);
}
private static async Task <string> PrepareExpectedResponseAsync(RivaAdministrativeDivisionsDbContext context, string cityName)
{
var cityEntity = await context.Cities.SingleOrDefaultAsync(x => x.Name.Equals(cityName));
var cityResponse = new CityResponse(cityEntity.Id, cityEntity.RowVersion, cityEntity.Name,
cityEntity.PolishName, cityEntity.StateId);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
return(JsonConvert.SerializeObject(cityResponse, settings));
}
public CityResponse SaveCity(CityEntity cityEntity)
{
db.Cities.Add(cityEntity);
try
{
db.SaveChanges();
}
catch (DbEntityValidationException)
{
return(null);
}
CityResponse cityResponse = Converter.CityEntityToResponse(cityEntity);
return(cityResponse);
}
public void GetCurrentWeatherByCity_When_ThrowsException_Returns_ErrorResponse()
{
var request = new ParameterRequest()
{
City = "Mauá", State = "SP"
};
_client.GetAsync($"{_host}/locale/city?name={request.City}&state={request.State}&{_token}").Throws(new Exception());
var result = _service.GetCurrentWeatherByCity(request);
var errorMessage = new CityResponse {
StatusCode = HttpStatusCode.BadGateway, Detail = "Falha de comunicação."
};
result.Should().BeEquivalentTo(errorMessage);
}
public async Task <IActionResult> GetCity([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var city = await _context.Cities.Include(a => a.Events)
.FirstOrDefaultAsync(a => a.Id == id);
var response = new CityResponse
{
Id = city.Id,
Name = city.Name,
Description = city.Description,
Slung = city.Slung,
Events = city.Events.Select(p => new EventResponse
{
Id = p.Id,
Name = p.Name,
Duration = p.Duration,
EventDate = p.EventDate,
People = p.People,
Description = p.Description,
}).ToList(),
};
if (city == null)
{
return(NotFound());
}
return(Ok(response));
/*
* var city = await _context.Cities.FindAsync(id);
*
* if (city == null)
* {
* return NotFound();
* }
*
* return Ok(city);
*/
}
public dynamic GetActiveCitiesByCountry(int idCountry)
{
try
{
CityRepository cityRepository = new CityRepository();
var citiesList = cityRepository.GetActiveCitiesByCountry(idCountry);
if (citiesList != null)
{
Logger.Instance.WriteInLog(LogType.INFO, "Cities successfully obtained");
CityResponse cityResponse = new CityResponse();
cityResponse.cities = new List <City>();
foreach (var cityTemp in citiesList)
{
City city = new City();
city.city = cityTemp.City;
city.id = cityTemp.Id;
city.active = cityTemp.Active;
cityResponse.cities.Add(city);
}
return(JObject.Parse(JsonConvert.SerializeObject(cityResponse)));
}
else
{
Logger.Instance.WriteInLog(LogType.WARNING, "Something wrong ocurred while getting the cities");
return(JObject.Parse(JsonConvert.SerializeObject(new CityResponse
{
cities = new List <City>(),
errors = "Could not get the cities"
})));
}
}
catch (Exception ex)
{
Logger.Instance.WriteInLog(LogType.ERROR, "An error ocurred while getting the cities", null, ex.Message);
return(JObject.Parse(JsonConvert.SerializeObject(new CityResponse
{
cities = new List <City>(),
errors = ex.Message.ToString()
})));
}
}
public MainPageViewModel()
{
city = GetCity.GetCurrentCity();
CurrentCity = city.LocalizedName;
Region = city.AdministrativeArea.LocalizedName;
weather = GetCondition.GetCurrentCondition(city.Key);
Temperature = weather.Temperature.Metric.Value + "°";
WeatherText = weather.WeatherText;
if (weather.HasPrecipitation)
{
PrecipitationType = weather.PrecipitationType;
}
else
{
PrecipitationType = "Без осадков";
}
}
public async Task GetCityAsync_Should_Return_OkObjectResult_With_CityResponse()
{
var cityOutputQuery = new CityOutputQuery(Guid.NewGuid(), Array.Empty <byte>(), "Name", "PolishName",
Guid.NewGuid());
var cityResponse = new CityResponse(cityOutputQuery.Id, cityOutputQuery.RowVersion, cityOutputQuery.Name,
cityOutputQuery.PolishName, cityOutputQuery.StateId);
_getCityQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(cityOutputQuery);
_mapperMock.Setup(x => x.Map <CityOutputQuery, CityResponse>(It.IsAny <CityOutputQuery>())).Returns(cityResponse);
var result = await _controller.GetCityAsync(cityOutputQuery.Id);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(cityResponse);
}
public CityResponse Create(CityViewModel cityViewModel)
{
CityResponse response = new CityResponse();
try
{
City addedCity = unitOfWork.GetCityRepository().Create(cityViewModel.ConvertToCity());
unitOfWork.Save();
response.City = addedCity.ConvertToCityViewModel();
response.Success = true;
}
catch (Exception ex)
{
response.City = new CityViewModel();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async void SearchSubmit(object sender, EventArgs e)
{
SearchBar searchBar = sender as SearchBar;
viewModel.IsNewLoading = true;
CityResponse res = await DataStore.requestMaker(searchBar.Text);
if (!res.name.Equals("404"))
{
//Application.Current.Properties.Add(searchBar.Text, searchBar.Text);
viewModel.FoundCity.Add(res);
viewModel.IsNewLoading = false;
}
else
{
viewModel.IsNewLoading = false;
Notifier.ShortAlert("Не найдено");
}
}
public CityResponse Delete(Guid identifier)
{
CityResponse response = new CityResponse();
try
{
CityViewModel re = new CityViewModel();
re.Identifier = identifier;
response = WpfApiHandler.SendToApi <CityViewModel, CityResponse>(re, "Delete");
}
catch (Exception ex)
{
response.City = new CityViewModel();
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
