public async Task <IActionResult> Add(PlaceDto model)
{
try
{
if (ModelState.IsValid)
{
var dbPlaceModel = Mapper.Map <Place>(model);
await _dbContext.Places.AddAsync(dbPlaceModel);
var dbRatingModel = new Rating
{
UserId = model.UserId,
PlaceId = dbPlaceModel.Id,
IsAddedByThisUser = true
};
await _dbContext.Ratings.AddAsync(dbRatingModel);
await _dbContext.SaveChangesAsync();
model.Id = dbPlaceModel.Id;
return(Ok());
}
return(BadRequest(ModelState));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void UpdateCachedPlace(PlaceDto place)
{
var entity = Mapper.Map <Place>(place);
//TODO investigate Update specific fields
_placesRepository.Replace(entity);
}
public async Task <IActionResult> Edit(PlaceDto model)
{
try
{
if (ModelState.IsValid)
{
var dbPlaceModel = await _dbContext.Places.Where(p => p.Id == model.Id).FirstOrDefaultAsync();
if (dbPlaceModel == null)
{
return(NotFound());
}
dbPlaceModel.Description = model.Description;
dbPlaceModel.Name = model.Label;
dbPlaceModel.Latitude = model.Position.Lat;
dbPlaceModel.Longitude = model.Position.Lng;
dbPlaceModel.IsPublic = model.IsPublic;
dbPlaceModel.FullAddress = model.FullAddress;
dbPlaceModel.CategoryId = model.Category.Id;
await _dbContext.SaveChangesAsync();
return(Ok());
}
return(BadRequest(ModelState));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Edit(PlaceDto placeDto)
{
var place = Mapper.Map <Place>(placeDto);
Database.Places.Update(place);
Database.Save();
}
private void FillPlace(PlaceDto place)
{
TxtName.Text = place.Name;
TxtAddress.Text = place.Address;
TxtPhone.Text = place.PhoneNumber.ToString();
TxtWebsite.Text = place.Website;
}
public async Task <PlaceDto> CreateAsync(PlaceDto place)
{
var placeModel = place.ToModel();
await _unitOfWork.PlacesRepository.InsertAsync(placeModel).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(placeModel.ToDto());
}
private async Task <PlaceDto> GetPlaceAsync()
{
var place = new PlaceDto
{
Name = TxtName.Text,
Address = TxtAddress.Text,
PhoneNumber = int.Parse(TxtPhone.Text),
Website = TxtWebsite.Text
};
return(place);
}
/// <summary>
/// Convert Dto to Model
/// </summary>
public static PlaceModel ToModel(this PlaceDto place)
{
return(place == null ? null : new PlaceModel
{
Id = place.Id,
Name = place.Name,
Address = place.Address,
PhoneNumber = place.PhoneNumber,
Website = place.Website,
Classification = place.Classification
});
}
public async Task UpdateAsync(PlaceDto place)
{
var currentPlace = await _unitOfWork.PlacesRepository.FindAsync(place.Id).ConfigureAwait(false);
currentPlace.Name = place.Name;
currentPlace.Address = place.Address;
currentPlace.PhoneNumber = place.PhoneNumber;
currentPlace.Website = place.Website;
_unitOfWork.PlacesRepository.Update(currentPlace);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <double> CalculateAverageClassification(PlaceDto place)
{
double classification = 0;
double average = 0;
foreach (var item in place.Reviews)
{
classification += item.Classification;
}
average = classification / place.Reviews.Count;
return(average);
}
public void Execute(PlaceDto request)
{
var place = _context.Places.Find(request.Id);
if (place == null)
{
throw new EntityNotFoundException(request.Id, typeof(Place));
}
_validator.ValidateAndThrow(request);
_mapper.Map(request, place);
_context.SaveChanges();
}
public override VisionDto GetCurrentVision(Owner owner)
{
var area = Ecs.SystemManager.GetSystem <Area>();
var result = new PlaceDto[area.Size.X, area.Size.Y];
var visibility = GetVisibility(owner);
foreach (var v in area.Size.Range())
{
result[v.X, v.Y] = visibility[v.X, v.Y] ? area.GetPlaceDto(v) : null;
}
return(new VisionDto
{
Visibility = visibility,
Grid = result,
});
}
public async Task <bool> UpdateTrip(Trip trip, PlaceDto from = null, PlaceDto to = null)
{
try
{
_dataContext.Update(trip);
_dataContext.SaveChanges();
if (from != null)
{
var queryfrom = string.Format(System.IO.File.ReadAllText("UpdateFromQuery.txt"));
List <NpgsqlParameter> sqlParameters = new List <NpgsqlParameter>();
sqlParameters.Add(new NpgsqlParameter("lon", from.Longitude));
sqlParameters.Add(new NpgsqlParameter("lat", from.Latitude));
sqlParameters.Add(new NpgsqlParameter("CustomerId", trip.CustomerId));
await _dataContext.Database.ExecuteSqlCommandAsync(queryfrom, sqlParameters);
}
if (to != null)
{
var queryto = string.Format(System.IO.File.ReadAllText("UpdateToQuery.txt"));
List <NpgsqlParameter> sqlParameters = new List <NpgsqlParameter>();
sqlParameters.Add(new NpgsqlParameter("lon", to.Longitude));
sqlParameters.Add(new NpgsqlParameter("lat", to.Latitude));
sqlParameters.Add(new NpgsqlParameter("CustomerId", trip.CustomerId));
await _dataContext.Database.ExecuteSqlCommandAsync(queryto, sqlParameters);
}
_dataContext.Entry(trip).Reload();
}
catch (Exception e)
{
return(false);
}
return(true);
}
public static void SetBuilding(PlaceDto dto, Vector position)
{
var building = PlacingSystem.Current.Area[position].First();
building.name = dto.BuildingName + (dto.Temperature < 0 ? " (Snowy)" : "");
var sprites = building.GetComponent <BuildingSprites>();
foreach (var renderer in sprites.AllRenderers)
{
renderer.color = Color.white;
}
sprites.BuildingWeather.sprite = Sprites.GetBuildingWeatherSprite(dto.Temperature, dto.BuildingName, dto.TerrainName);
sprites.Building.sprite = Sprites.GetBuildingSprite(dto.BuildingName, dto.TerrainName);
sprites.TerrainWeather.sprite = Sprites.GetTerrainWeatherSprite(dto.Temperature, dto.TerrainName);
sprites.Terrain.sprite = Sprites.GetTerrainSprite(dto.TerrainName);
sprites.Squad.sprite = Sprites.GetSquadSprite(dto.SquadName);
}
public async Task <IActionResult> ParkVechicle([FromBody] PlaceDto place, string number, string moniker)
{
var parking = _repo.GetParkingByMoniker(moniker);
var lot = _repo.GetPlaceForParking(place.Row, place.Column, parking.Id);
_repo.GetCreateVechicle(number).Wait();
if (lot.Booked || lot.Occupied)
{
return(BadRequest("Place is busy or booked, choose another one!"));
}
lot.Occupied = true;
_repo.Update(lot);
if (await _repo.SaveAsync())
{
_logger.LogInformation($"Parking lot {place.Row},{place.Column} for {moniker} occupied by vechicle {number}");
}
return(Ok());
}
public static PlaceDto ToPlaceDto(this Place model)
{
if (model == null)
{
return(null);
}
var dto = new PlaceDto
{
Id = model.Id,
City = model.City,
Country = model.Country,
Floor = model.Floor,
PostalCode = model.PostalCode,
Region = model.Region,
StreetName = model.StreetName,
StreetNumber = model.StreetNumber
};
if (model.Rooms != null)
{
var rooms = new List <RoomBasicDto>();
foreach (var item in model.Rooms)
{
var room = new RoomBasicDto()
{
Id = item.Id,
Name = item.Name
};
rooms.Add(room);
}
dto.Rooms = rooms;
}
return(dto);
}
public async Task <BaseResponse <PlaceDto> > UpdatePlace(PlaceDto placeDto)
{
try
{
HttpResponseMessage result = await HttpClientService.PutAsync($"{hostApi}api/Places/{placeDto.Id}", placeDto);
if (result.IsSuccessStatusCode)
{
var serializedResponse = await JsonService.GetSerializedResponse <PlaceDto>(result);
var response = new BaseResponse <PlaceDto>()
{
Response = serializedResponse
};
response.HttpResponse = result;
return(response);
}
else
{
return(new BaseResponse <PlaceDto>()
{
HttpResponse = result
});
}
}
catch (Exception ex)
{
return(new BaseResponse <PlaceDto>()
{
HttpResponse = new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.BadRequest
}
});
}
}
public async Task <PlaceDto[]> SearchAsync(string text)
{
var retVal = new PlaceDto[0];
text = text.Clean();
if (text != null && Regex.IsMatch(text, @"\b[A-Z]{1,2}[0-9][A-Z0-9]? [0-9][ABD-HJLNP-UW-Z]{2}\b", RegexOptions.IgnoreCase))
{
using (var message = await RetryPolicy.ExecuteAsync(async() =>
{
return(await _osApiClient.GetAsync($"search/places/v1/postcode?postcode={text}&key={_apiKey}&output_srs=WGS84&dataset=DPA,LPI"));
}))
{
if (!message.IsSuccessStatusCode)
{
return(new PlaceDto[0]);
}
var response = await ParseHttpResponseMessageAsync <OSPlacesResponse>(message);
var addresses = response.Results?.Where(x => x.OSAddress != null &&
(x.OSAddress.PostalAddressCode == "D" || x.OSAddress.PostalAddressCode == "L")) // POSTAL_ADDRESS_CODE_DESCRIPTION: D = "A record which is linked to PAF", L="A record which is identified as postal based on Local Authority information"
.Select(x => x.OSAddress)
.GroupBy(x => x.Uprn)
.Select(x => x.FirstOrDefault(u => u.Address.Length == x.Max(y => y.Address.Length)))
.OrderBy(x => x.Address);
if (addresses != null)
{
return(addresses.Select(x => new PlaceDto(x.Address, LatLon.Create(x.Lat, x.Lng))).ToArray());
}
}
}
return(retVal);
}
public IActionResult Put(int id, [FromBody] PlaceDto dto, [FromServices] IEditPlaceCommand command)
{
dto.Id = id;
_executor.ExecuteCommand(command, dto);
return(NoContent());
}
private void FillPlace(PlaceDto place)
{
TxtId.Text = place.Id.ToString();
TxtName.Text = place.Name;
TxtAddress.Text = place.Address;
}
public async Task <IActionResult> Get([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequest req, ILogger log)
{
string lat = req.Query["lat"];
string lng = req.Query["lng"];
int.TryParse(req.Query["distance"], out int distance);
if (distance == 0)
{
distance = 5000;
}
var location = new Point(double.Parse(lng), double.Parse(lat))
{
SRID = 4326
};
var requestPto = new GetShitRequestPto
{
Requested = DateTime.Now,
Location = location,
Distance = distance,
ClientIpAddress = req.HttpContext.Connection.RemoteIpAddress.ToString()
};
_context.GetShitRequests.Add(requestPto);
_context.SaveChanges();
IQueryable <PlacePto> ptos = _context.Places.Where(x => x.Location.Distance(location) <= distance &&
(x.FoodHygieneRating.RatingValue == "0" ||
x.FoodHygieneRating.RatingValue == "1" ||
x.FoodHygieneRating.RatingValue == "2" ||
(x.GooglePlaces.Rating > 0 &&
x.GooglePlaces.Rating < 3.5) ||
(x.TripAdvisorLocation.Rating > 0 &&
x.TripAdvisorLocation.Rating < 3.5)))
.OrderBy(x => x.Location.Distance(location))
.Take(50);
if (ptos.Count() == 0)
{
return(new NotFoundResult());
}
var places = new List <PlaceDto>();
foreach (PlacePto pto in ptos)
{
string cachedPlace = await _cache.GetStringAsync(pto.Id.ToString());
if (cachedPlace != null)
{
places.Add(JsonConvert.DeserializeObject <PlaceDto>(cachedPlace));
}
else
{
var placeDto = new PlaceDto
{
Id = pto.Id,
Lat = pto.Location.Y,
Lng = pto.Location.X,
Name = pto.Name
};
FoodHygieneRatingPto foodHygieneRatingPto = _context.FoodHygieneRatings.Where(x => x.PlaceId == pto.Id).SingleOrDefault();
if (foodHygieneRatingPto != null)
{
placeDto.FoodHygieneRating = foodHygieneRatingPto.RatingValue;
placeDto.FoodHygieneRatingId = foodHygieneRatingPto.FHRSID;
}
GooglePlacesPto googlePlacesPto = _context.GooglePlaces.Where(x => x.PlaceId == pto.Id).SingleOrDefault();
if (googlePlacesPto != null)
{
placeDto.GooglePlacesId = googlePlacesPto.Id;
placeDto.GooglePlacesRating = googlePlacesPto.Rating;
placeDto.GooglePlacesRatings = googlePlacesPto.UserRatingsTotal;
}
TripAdvisorPto tripAdvisorLocation = _context.TripAdvisorLocations.Where(x => x.PlaceId == pto.Id).SingleOrDefault();
if (tripAdvisorLocation != null)
{
placeDto.TripAdvisorUrl = $"https://www.tripadvisor.co.uk{tripAdvisorLocation.SummaryObject.detailPageUrl}";
placeDto.TripAdvisorRating = tripAdvisorLocation.SummaryObject.averageRating;
placeDto.TripAdvisorRatings = tripAdvisorLocation.SummaryObject.userReviewCount;
}
if (placeDto.FoodHygieneRatingId != null || placeDto.GooglePlacesId != null)
{
await _cache.SetStringAsync(pto.Id.ToString(), JsonConvert.SerializeObject(placeDto));
places.Add(placeDto);
}
}
}
return(new OkObjectResult(places));
}
public IActionResult UpdateCachedPlace([FromBody] PlaceDto place)
{
_placesService.UpdateCachedPlace(place);
return(Ok());
}
