public PlaceDTO GetPlaceById(int id)
{
var place = _unitOfWork.PlaceRepository.GetByID(id);
PlaceDTO _place = _mapper.Map <PlaceDTO>(place);
return(_place);
}
public static void Create(PlaceDTO placeDTO)
{
Place place = MapperTransform <Place, PlaceDTO> .ToEntity(placeDTO);
Database.Places.Create(place);
Database.Save();
}
public HttpResponseMessage Post(PlaceDTO dto)
{
_repo.Add(dto);
_repo.Save();
return(Request.CreateResponse(HttpStatusCode.Created));
}
public HttpResponseMessage Put(PlaceDTO dto)
{
_repo.Put(dto);
_repo.Save();
return(Request.CreateResponse(HttpStatusCode.NoContent));
}
public void Delete(int id, [FromBody] PlaceVM place)
{
PlaceDTO _place = _mapper.Map <PlaceDTO>(place);
_place.Id = id;
_placeService.Delete(_place);
}
public void Insert(PlaceDTO place)
{
Place _place = _mapper.Map <Place>(place);
_unitOfWork.PlaceRepository.Insert(_place);
_unitOfWork.Save();
}
public async Task <IActionResult> getPlace([FromRoute] Guid placeId, [FromRoute] Guid userId)
{
var place = await dbContext.Places
.Include(p => p.Image)
.FirstOrDefaultAsync(p => p.Id == placeId);
if (place == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Invalid Place Id"));
}
var PlaceDto = new PlaceDTO
{
Id = place.Id,
MainImage = place.Image.Url,
Name = place.Name,
Description = place.LongDescription,
Liked = dbContext.Favourits?.Any(f => f.PlaceId == placeId && f.UserId == userId) ?? false
};
var images = await dbContext.Reviews.Include(r => r.Image).Where(r => r.PlaceId == placeId).Select(e => e.Image.Url).ToListAsync();
PlaceDto.Images = images;
return(Json(PlaceDto));
}
public void Delete(PlaceDTO place)
{
Place _place = _mapper.Map <Place>(place);
_unitOfWork.PlaceRepository.Delete(_place);
_unitOfWork.Save();
}
public async Task <IActionResult> UpdatePlace(long id, PlaceDTO placeDTO)
{
if (id != placeDTO.Id)
{
return(BadRequest());
}
var place = await _context.Places.FindAsync(id);
if (place == null)
{
return(NotFound());
}
place.Name = placeDTO.Name;
place.IsOpen = placeDTO.IsOpen;
place.Tags = placeDTO.Tags;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!PlaceExists(id))
{
return(NotFound());
}
return(NoContent());
}
public async Task <IActionResult> Create(PlaceFormModel model)
{
if (this.ModelState.IsValid)
{
try
{
PlaceDTO placeDTO = Mapper.Map <PlaceFormModel, PlaceDTO>(model);
if (base.CurrentUser.Role != UserRole.SuperAdmin)
{
placeDTO.CompanyId = base.CurrentUser.CompanyId;
}
Result <Place> result = await _placeService.AddPlaceAsync(placeDTO);
model.FormMessage = result.FormMessage;
model.IsSuccess = result.IsSuccess;
if (model.IsSuccess)
{
model.FormMessage = "İşleminiz başarılı bir şekilde gerçekleştirildi.";
}
return(this.View((object)model));
}
catch (Exception ex)
{
LoggerExtensions.LogError(_logger, ex, "Create Error", Array.Empty <object>());
model.IsSuccess = false;
model.FormMessage = "İşleminiz gerçekleştirilemedi.";
return(this.View((object)model));
}
}
return(this.View((object)model));
}
public ActionResult PlaceInDb(PlaceViewModel place)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <PlaceViewModel, PlaceDTO>()).CreateMapper();
PlaceDTO result = mapper.Map <PlaceViewModel, PlaceDTO>(place);
var res = _placeService.IsPlaceConsist(result);
return(Ok(res));
}
public IActionResult Post(PlaceDTO place)
{
var result = _placeService.Add(place);
place.Id = result;
return(CreatedAtRoute("GetPlaceById", new { id = place.Id }, place));
}
public static Place ToPlace(this PlaceDTO place)
{
return(new Place
{
Id = place.Id,
Name = place.Name,
CreatedDate = place.CreatedDate,
ModifiedDate = place.ModifiedDate,
});
}
public void MakePlace(PlaceDTO placeDto)
{
Place place = new Place
{
Number = placeDto.Number,
CarriageId = placeDto.CarriageId
};
_Database.Places.Create(place);
_Database.Save();
}
public async Task <Result <PlaceDTO> > GetPlaceAsync(int id)
{
Result <PlaceDTO> res = new Result <PlaceDTO>();
Place place = await EntityFrameworkQueryableExtensions.FirstOrDefaultAsync <Place>(_unitOfWork.EntityRepository <Place>().GetQueryable((Place w) => w.IsDeleted == false && w.Id == id, null), default(CancellationToken));
if (place == null)
{
return(res.Fail("Place yok!"));
}
PlaceDTO dataVal = Mapper.Map <Place, PlaceDTO>(place);
return(res.Success(dataVal));
}
public IActionResult Put(PlaceDTO person)
{
var result = _placeService.Update(person);
if (result)
{
return(NoContent());
}
else
{
return(NotFound());
}
}
public ViewResult MakeOrder(int placeId)
{
PlaceDTO placeDTO = theatreService.GetPlace(placeId);
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <PlaceDTO, PlaceViewModel>()).CreateMapper();
PlaceViewModel placeVM = mapper.Map <PlaceDTO, PlaceViewModel>(placeDTO);
OrderViewModel orderVM = new OrderViewModel()
{
PlaceId = placeId, Number = placeDTO.Number
};
return(View("MakeOrder", orderVM));
}
public async Task <ActionResult <PlaceDTO> > CreatePlace(PlaceDTO placeDTO)
{
var place = new Place
{
IsOpen = placeDTO.IsOpen,
Name = placeDTO.Name,
Tags = placeDTO.Tags
};
_context.Places.Add(place);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetPlace), new { id = place.Id }, PlaceToDTO(place)));
}
public async Task <Result <Place> > AddPlaceAsync(PlaceDTO place)
{
Place place2 = Mapper.Map <PlaceDTO, Place>(place);
if (place.Latitude.HasValue && place.Longitude.HasValue)
{
place2.Location = new XYPoint(place.Latitude.Value, place.Longitude.Value);
}
Place res = await _unitOfWork.EntityRepository <Place>().CreateAsync(place2);
await _unitOfWork.SaveChangesAsync();
return(Result.Data(res));
}
public PlaceDTO Patch(int id, [FromBody] JsonPatchDocument <PlaceDTO> PlacePatch)
{
Place originplace = PlaceRepository.GetPlaceByID(id);
PlaceDTO placeDTO = _mapper.Map <PlaceDTO>(originplace);
PlacePatch.ApplyTo(placeDTO);
_mapper.Map(placeDTO, originplace);
_context.Update(originplace);
_context.SaveChanges();
return(placeDTO);
}
public bool Remove(PlaceDTO place)
{
if (place == null)
{
throw new System.ArgumentNullException(nameof(place));
}
using (_unitOfWork)
{
var result = _unitOfWork.Places.Remove(place.ToPlace());
_unitOfWork.Save();
return(result);
}
}
public ActionResult CreatePlace([FromForm] PlaceViewModel place)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <PlaceViewModel, PlaceDTO>()).CreateMapper();
PlaceDTO result = mapper.Map <PlaceViewModel, PlaceDTO>(place);
try
{
_placeService.InsertPlace(result);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(HttpStatusCode.NoContent));
}
}
public ActionResult UpdatePlace(PlaceViewModel place)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <PlaceViewModel, PlaceDTO>()).CreateMapper();
PlaceDTO result = mapper.Map <PlaceViewModel, PlaceDTO>(place);
try
{
_placeService.UpdatePlace(result);
return(Ok());
}
catch
{
return(StatusCode(HttpStatusCode.NoContent));
}
}
//----------------------------------------------------------------------------------
public ActionResult InformPlace(int id)
{
ViewBag.Page = pageInfo.setView("InformPlace").setTitle("InformPlace");
ViewBag.Method = HttpContext.Request.HttpMethod;
PlaceDTO placeDTO = PlaceService.Get(id);
if (placeDTO == null)
{
return(HttpNotFound());
}
List <PlacePhotoDTO> photo = PlacePhotoServices.GetAll().Where(x => x.PlaceId == id).ToList();
List <ReviewDTO> review = ReviewServices.GetAll().Where(x => x.PlaceId == id).OrderByDescending(x => x.Date).ToList();
//IQueryable<Rating> R = db.Ratings.Where(x => x.IdPlace == id);
int RLike = review.Count(x => x.ValueLike == 1);
int RDis = review.Count(x => x.ValueLike == 2);
int RCheck = review.Count(x => x.Checkin == 1);
int RRating = (RLike + RDis == 0) ? 0 : Convert.ToInt32(Math.Round(10.0 * Convert.ToDouble(RLike) / Convert.ToDouble(RLike + RDis)));
List <UserDTO> userDTO = UserServices.GetAll();
PlaceDTO obj = new PlaceDTO()
{
Id = placeDTO.Id,
Name = placeDTO.Name,
Longitude = placeDTO.Longitude,
Latitude = placeDTO.Latitude,
Address = placeDTO.Address,
Description = placeDTO.Description,
Phone = placeDTO.Phone,
Site = placeDTO.Site,
WorkingHour = placeDTO.WorkingHour
};
ViewBag.Album = photo;
ViewBag.Checkins = RCheck;
ViewBag.Comments = review;
ViewBag.Dislike = RDis;
ViewBag.Like = RLike;
ViewBag.Ratings = RRating;
ViewBag.Login = userDTO;
return(View(obj));
}
public static void Update(PlaceDTO placeDTO)
{
Place place = Database.Places.Get(placeDTO.Id);
place.Name = placeDTO.Name;
place.Longitude = placeDTO.Longitude;
place.Latitude = placeDTO.Latitude;
place.Tags = placeDTO.Tags;
place.WorkingHour = placeDTO.WorkingHour;
place.Description = placeDTO.Description;
place.Address = placeDTO.Address;
place.Site = placeDTO.Site;
place.Phone = placeDTO.Phone;
place.Creater = placeDTO.Creater;
place.DateCreate = placeDTO.DateCreate;
Database.Places.Update(place);
Database.Save();
}
public void PostPlaceToVisit([FromBody] PlaceDTO placeToVisit)
{
PlaceToVisit place = new PlaceToVisit
{
CityId = _context.Cities.Where(c => c.Name == placeToVisit.CityName).Select(c => c.Id).First(),
UserId = _context.Users.Where(u => u.Id == placeToVisit.UserId).Select(u => u.Id).First(),
Name = placeToVisit.Name,
About = placeToVisit.About,
ImgUrl = placeToVisit.ImgUrl,
PlaceType = placeToVisit.PlaceType,
PriceType = placeToVisit.PriceType,
Price = placeToVisit.Price,
Status = 0,
Date = DateTime.UtcNow
};
_context.Places.Add(place);
_context.SaveChanges();
}
private void AddPlaceButton(object sender, EventArgs e)
{
Place place = new Place();
Contact contact = new Contact();
PlaceDTO placeDTO = new PlaceDTO(ComboBoxDistrict.Text, ComboBoxBuildingType.Text, Int32.Parse(TextBoxCapacity.Text), Int32.Parse(TextBoxScore.Text), locationXY.X,
locationXY.Y, locationX1Y1.X, locationX1Y1.Y, TextBoxAddress.Text, TextBoxAddress.Text, TextBoxAddress.Text, TextBoxEmail.Text);
string message = "/POST/Place" + "<EOF>";
var body = JsonConvert.SerializeObject(placeDTO);
Request request = new Request(message, body);
var requestToSend = JsonConvert.SerializeObject(request);
string receivedData = client.sendData(requestToSend);
if (receivedData.Equals("201 Created"))
{
MessageBox.Show("Place 201 Created");
}
else
{
MessageBox.Show("Error");
}
}
public async Task <Result> UpdatePlaceAsync(int id, PlaceDTO place)
{
Place place2 = await _unitOfWork.EntityRepository <Place>().GetFirstAsync((Place w) => w.IsDeleted == false && w.Id == id, null);
if (place2 == null)
{
return(Result.Fail("Mekan bulunamadı!"));
}
if (place.CompanyId != 0 && place2.CompanyId != place.CompanyId)
{
return(Result.Fail("Mekan bulunamadı!"));
}
var demoMessage = "";
if (!string.IsNullOrWhiteSpace(place.Guest))
{
if ((!string.Equals("Hayir", place2.Guest, StringComparison.InvariantCultureIgnoreCase)) &&
string.Equals("Hayir", place.Guest, StringComparison.InvariantCultureIgnoreCase))
{
demoMessage = "Demo";
}
}
place2.Name = place.Name;
place2.Guest = place.Guest;
place2.Address = place.Address;
place2.Latitude = place.Latitude;
place2.Longitude = place.Longitude;
if (place.Latitude.HasValue && place.Longitude.HasValue)
{
place2.Location = new XYPoint(place.Latitude.Value, place.Longitude.Value);
}
await _unitOfWork.SaveChangesAsync();
return(Result.Success(message: demoMessage));
}
public PlaceDTO ChangeCategory(PlaceDTO place)
{
throw new NotImplementedException();
}
public PlaceDTO AddPlace(PlaceDTO place)
{
throw new NotImplementedException();
}
public PlaceDTO ChangeCategory(PlaceDTO place)
{
throw new NotImplementedException();
}
public PlaceDTO AddPlace(PlaceDTO place)
{
throw new NotImplementedException();
}
