public RestaurantDto AddNewRestaurant(RestaurantDto restaurantDto)
{
var restaurant = Mapper.Map <RestaurantDto, Restaurant>(restaurantDto);
var savedRestaurant = _restaurantDataProvider.AddNewRestaurant(restaurant);
return(Mapper.Map <Restaurant, RestaurantDto>(savedRestaurant));
}
public async Task Create_AddRestaurant_AddedRestaurantReturned()
{
// Arrange
var newRestaurant = new RestaurantDto()
{
Name = Common.RestaurantName
};
var resultRestaurant = new RestaurantDto()
{
Id = 1, Name = Common.RestaurantName
};
var mock = new Mock <IRestaurantManagementService>();
mock.Setup(rmService => rmService.AddRestaurantAsync(It.IsAny <RestaurantDto>()))
.Returns(Task.FromResult(resultRestaurant));
var loggerMock = new Mock <ILogger <RestaurantsController> >();
var controller = new RestaurantsController(mock.Object, loggerMock.Object);
// Act
var result = await controller.Create(newRestaurant);
// Assert
var actionResult = Assert.IsType <CreatedAtRouteResult>(result);
Assert.Equal(resultRestaurant, actionResult?.Value);
}
public async Task AddRestaurantAsync_AddRestaurant_AddedRestaurantReturned()
{
// Arrange
var newRestaurantDto =
new RestaurantDto()
{
Name = Common.RestaurantName, CityId = Common.CityId
};
var resultRestaurantDto =
new RestaurantDto()
{
Id = 1, Name = Common.RestaurantName, CityId = Common.CityId
};
var resultRestaurant =
new Restaurant()
{
Id = 1, Name = Common.RestaurantName, CityId = Common.CityId
};
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <IRestaurantRepository>();
mockRepo.Setup(cityRepo => cityRepo.AddAsync(It.IsAny <Restaurant>()))
.Returns(Task.FromResult(resultRestaurant));
mockUow.Setup(rmService => rmService.Restaurants)
.Returns(mockRepo.Object);
var svc = new RestaurantManagementService(mockUow.Object);
// Act
var result = await svc.AddRestaurantAsync(newRestaurantDto);
// Assert
Assert.Equal(resultRestaurantDto, result);
}
public ActionResult <RestaurantDto> PutRestaurant([FromBody] RestaurantDto restaurant)
{
try
{
UpdateRestaurantCommand updateRestaurantCommand = CommandFactory.CreateUpdateRestaurantCommand(restaurant);
updateRestaurantCommand.Execute();
RestaurantDto updatedRestaurant = updateRestaurantCommand.GetResult();
_logger?.LogInformation($"Restaurante con ID {updatedRestaurant.Id} actualizado correctamente");
return(updatedRestaurant);
}
catch (RestaurantNotFoundExeption e)
{
_logger?.LogWarning($"Restaurant con ID {restaurant.Id} no conseguido");
return(NotFound(new ErrorMessage(e.Message)));
}
catch (InvalidAttributeException e)
{
_logger?.LogError(e, "Error en campos de la entidad restaurante");
return(BadRequest(new ErrorMessage(e.Message)));
}catch (DatabaseException ex)
{
_logger?.LogError(ex, "Database exception when trying to update a restaurant");
return(StatusCode(500, ex.Message));
}
}
private void SaveGallery(List <GalleryDto> galleries, RestaurantDto restaurant)
{
var galleryList = new List <Gallery>();
foreach (var gallery in galleries)
{
var galleryModel = Mapper <GalleryDto, Gallery> .Map(gallery, new Gallery());
galleryList.Add(galleryModel);
}
_unitOfWork.Repository <Gallery>().InsertMultiple(galleryList);
_unitOfWork.Save();
List <RestaurantGallery> restaurantGallery = new List <RestaurantGallery>();
foreach (var gallery in galleryList)
{
restaurantGallery.Add(new RestaurantGallery
{
GalleryId = gallery.Id,
RestaurantId = restaurant.Id
});
}
_unitOfWork.Repository <RestaurantGallery>().InsertMultiple(restaurantGallery);
_unitOfWork.Save();
}
public async Task <IActionResult> Create([FromBody] RestaurantDto restaurant)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByNameAsync(User?.Identity?.Name);
if (!(user is null))
{
var map = new MapperConfiguration(cfg =>
{
cfg.CreateMap <RestaurantDto, Restaurant>()
.ForMember(m => m.Id, opt => opt.Ignore())
.ForMember(m => m.User, opt => opt.MapFrom((s, d) => d.User = user));
cfg.CreateMap <LocationDto, Location>();
}).CreateMapper();
var model = map.Map <Restaurant>(restaurant);
await restaurantSerivce.CreateAsync(model);
return(Created(string.Empty, model));
}
else
{
return(Unauthorized());
}
}
public RestaurantDto UpdateRestaurant(RestaurantDto restaurantDto)
{
var restaurant = Mapper.Map <RestaurantDto, Restaurant>(restaurantDto);
var updatedRestaurantDto = _restaurantDataProvider.UpdateRestaurant(restaurant);
return(Mapper.Map <Restaurant, RestaurantDto>(updatedRestaurantDto));
}
public void Setup()
{
_restaurantDto = new RestaurantDto();
_restaurantDto.Name = "Yosemite";
_restaurantDto.Capacity = 200;
_restaurantDto.IsActive = true;
_restaurantDto.Qualify = 4;
_restaurantDto.Specialty = "Tsingy";
_restaurantDto.Price = 21;
_restaurantDto.BusinessName = "Wadsdworth Longfellow";
_restaurantDto.Picture = "A great picture of the Dead Sea could be here, you know?";
_restaurantDto.Description =
"Listen, strange women lying in ponds distributing swords is no basis for a system of government… You can’t expect to wield supreme power just ‘cause some watery tart threw a sword at you!";
_restaurantDto.Phone = "021221546352";
_restaurantDto.Location = 1;
_restaurantDto.Address = "As it turns out, Mount Kilimanjaro is not wi-fi enabled, so I had to spend two weeks in Tanzania talking to the people on my trip.";
_restaurantMapper = MapperFactory.CreateRestaurantMapper();
_restaurantDtoList = new List <RestaurantDto>();
_restaurantDtoList.Add(_restaurantDto);
_restaurant = EntityFactory.CreateRestaurant(0, "Yosemite", 200, true, 4, "Tsingy",
21, "Wadsdworth Longfellow", "A great picture of the Dead Sea could be here, you know?",
"Listen, strange women lying in ponds distributing swords is no basis for a system of government… You can’t expect to wield supreme power just ‘cause some watery tart threw a sword at you!",
"021221546352", 1,
"As it turns out, Mount Kilimanjaro is not wi-fi enabled, so I had to spend two weeks in Tanzania talking to the people on my trip.");
_restaurantList = new List <Restaurant>();
_restaurantList.Add(_restaurant);
}
public async Task <IStatusCodeActionResult> Create(RestaurantDto restaurantDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
//TODO better create a model for response and create contract test
return(Ok("{\"restaurantId\": \""
+ await _restaurantRepository.UpsertAsync(restaurantDto)
+ "\""));
return(BadRequest());
}
catch (ArgumentException exception)
{
return(BadRequest(exception.Message));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void UpdateRestaurant()
{
// Arrange
var restaurantDto = new RestaurantDto
{
Address = "1 Avely Rd.",
City = "Girard",
Country = "USA",
EmailAddress = "*****@*****.**",
Name = "New Restaurant",
Phone = "(330) 454-4543",
PostalCode = "44420",
State = "OH",
WebsiteUrl = "http://www.NewRestaurant.com"
};
var restaurant = _mapper.Map <Restaurant>(restaurantDto);
Mock.Get(_repositoryWrapper.Restaurant).Setup(x => x.UpdateRestaurant(restaurant, restaurant));
Mock.Get(_repositoryWrapper.Restaurant).Setup(x => x.GetRestaurantById(restaurant.Id)).ReturnsAsync(restaurant);
var controller = new RestaurantController(_loggerManager, _mapper, _repositoryWrapper);
// Act
var actionResult = controller.UpdateRestaurant(restaurant.Id, restaurantDto).Result;
// Assert
var noContentResult = actionResult as NoContentResult;
Assert.IsNotNull(noContentResult);
}
public async Task <IActionResult> Create([FromBody] RestaurantDto restaurant)
{
if (!ModelState.IsValid)
{
var message = "Неверная модель в параметре";
_logger.LogError($"{nameof(Create)}:{restaurant} - {message}");
return(BadRequest(ModelState));
}
try
{
restaurant = await _restaurantManagementService.AddRestaurantAsync(restaurant);
var routeValue = new
{
restaurant.Id,
restaurant.Name,
restaurant.CityId
};
return(CreatedAtRoute(routeValue, restaurant));
}
catch (Exception ex)
{
_logger.LogError($"{nameof(Create)}: {ex.Message}");
throw;
}
}
public IHttpActionResult GetRestaurantsByOwner(int id)
{
// Create a new list to insert restaurants from database into
IEnumerable <OwnerxRestaurant> Oxrs = db.OwnerxRestaurants
.Where(oxr => oxr.OwnerID == id)
.ToList();
// Start a new list of restaurant data transfer objects
List <RestaurantDto> restaurantDtos = new List <RestaurantDto> {
};
foreach (var Oxr in Oxrs)
{
// Loop through database and insert restaurant object attributes into DTO
RestaurantDto NewRestaurant = new RestaurantDto
{
RestaurantID = Oxr.Restaurant.RestaurantID,
RestaurantName = Oxr.Restaurant.RestaurantName,
RestaurantAddress = Oxr.Restaurant.RestaurantAddress,
RestaurantPhone = Oxr.Restaurant.RestaurantPhone,
RestaurantCategory = Oxr.Restaurant.RestaurantCategory
};
// Add DTO to list then loop back
restaurantDtos.Add(NewRestaurant);
}
return(Ok(restaurantDtos));
}
public ActionResult Create(RestaurantDto NewRestaurantData)
{
Restaurant NewRestaurant = new Restaurant
{
RestaurantID = NewRestaurantData.RestaurantID,
RestaurantAddress = NewRestaurantData.RestaurantAddress,
RestaurantName = NewRestaurantData.RestaurantName,
RestaurantPhone = NewRestaurantData.RestaurantPhone,
RestaurantCategoryID = NewRestaurantData.RestaurantCategoryID
};
string url = "restaurantdata/addrestaurant";
HttpContent content = new StringContent(jss.Serialize(NewRestaurant));
Debug.WriteLine(jss.Serialize(NewRestaurantData));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage httpResponse = client.PostAsync(url, content).Result;
if (httpResponse.IsSuccessStatusCode)
{
int RestaurantID = httpResponse.Content.ReadAsAsync <int>().Result;
NewRestaurantData.RestaurantID = RestaurantID;
url = "restaurantdata/associaterestaurantowner";
content = new StringContent(jss.Serialize(NewRestaurantData));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
httpResponse = client.PostAsync(url, content).Result;
//Debug.WriteLine(httpResponse);
return(RedirectToAction("Details", new { id = RestaurantID }));
}
else
{
return(RedirectToAction("Error"));
}
}
public async Task <IActionResult> PostANewRestaurant([FromQuery] RestaurantDto restaurantDto)
{
try
{
if (restaurantDto == null)
{
_loggerManager.LogError("RestaurantDto object sent from client is null.");
return(BadRequest("RestaurantDto object is null"));
}
if (!ModelState.IsValid)
{
_loggerManager.LogError("Invalid RestaurantDto object sent from client.");
return(BadRequest("Invalid model object"));
}
var restaurant = _mapper.Map <Restaurant>(restaurantDto);
await _repositoryWrapper.Restaurant.CreateRestaurant(restaurant);
if (restaurant.IsEmptyObject())
{
_loggerManager.LogError($"Save operation failed inside PostANewRestaurant action");
return(StatusCode(500, "Internal server error while saving "));
}
var dbRestaurant = await _repositoryWrapper.Restaurant.GetRestaurantById(restaurant.Id);
return(Ok(dbRestaurant));
}
catch (Exception ex)
{
_loggerManager.LogError($"Something went wrong inside PostANewRestaurant action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> Save(RestaurantDto dto)
{
ResponseModel <RestaurantDto> result = new ResponseModel <RestaurantDto>();
if (dto.Address.CityId == -1)
{
var cityResponse = _utilityService.SaveCity(new CityDto
{
Name = dto.Address.CityName,
StateId = dto.Address.StateId
});
if (cityResponse.IsSuccess)
{
dto.Address.CityId = cityResponse.ResponseObject.Id;
}
}
if (ModelState.IsValid)
{
dto.AspNetUserId = User.Identity.Name;
result = _service.Save(dto);
result = MessageHelper <RestaurantDto> .GetResponse(result);
}
else
{
result.IsFailed = true;
result.ErrorCode = CommonConstants.ErrorCode.InvalidModel;
result = MessageHelper <RestaurantDto> .GetResponse(result);
}
return(Ok(result));
}
public async Task <IActionResult> UpdateRestaurant(Guid id, [FromQuery] RestaurantDto restaurantDto)
{
try
{
if (restaurantDto == null)
{
_loggerManager.LogError("Restaurant object sent from client is null.");
return(BadRequest("Restaurant object is null"));
}
if (!ModelState.IsValid)
{
_loggerManager.LogError("Invalid owner object sent from client.");
return(BadRequest("Invalid model object"));
}
var dbRestaurant = await _repositoryWrapper.Restaurant.GetRestaurantById(id);
if (dbRestaurant.IsEmptyObject())
{
_loggerManager.LogError($"Restaurant with id: {id}, hasn't been found in db.");
return(NotFound());
}
var restaurant = _mapper.Map <Restaurant>(restaurantDto);
await _repositoryWrapper.Restaurant.UpdateRestaurant(dbRestaurant, restaurant);
return(NoContent());
}
catch (Exception ex)
{
_loggerManager.LogError($"Something went wrong inside UpdateRestaurant action: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public IEnumerable <RestaurantDto> GetRestaurantsByCategory(int id)
{
// Create a new list to insert restaurants from database into
List <Restaurant> Restaurants = db.Restaurants
.Where(rc => rc.RestaurantCategoryID == id)
.ToList();
// Start a new list of restaurant data transfer objects
List <RestaurantDto> RestaurantDtos = new List <RestaurantDto> {
};
foreach (var Restaurant in Restaurants)
{
// Loop through database and insert restaurant object attributes into DTO
RestaurantDto NewRestaurant = new RestaurantDto
{
RestaurantID = Restaurant.RestaurantID,
RestaurantName = Restaurant.RestaurantName,
RestaurantAddress = Restaurant.RestaurantAddress,
RestaurantPhone = Restaurant.RestaurantPhone,
RestaurantCategory = Restaurant.RestaurantCategory
};
// Add DTO to list then loop back
RestaurantDtos.Add(NewRestaurant);
}
return(RestaurantDtos);
}
public ServiceResponse <bool> Insert(RestaurantDto dto)
{
var result = new ServiceResponse <bool>();
try
{
var entity = new Domain.Entities.Restaurant(dto.Name);
if (entity.Valid)
{
result.Result = result.Object = _service.Insert(entity);
if (!result.Result)
{
((Notifiable)_service).Notifications
.ToList()
.ForEach(x => result.Messages.Add(x.Message));
}
}
else
{
entity.Notifications.ToList().ForEach(x => result.Messages.Add(x.Message));
}
}
catch (Exception ex)
{
result.Messages.Add("Problems when try to insert the restaurant: " + ex.Message);
}
return(result);
}
public IActionResult CreationRestaurant(int cityId, [FromBody] RestaurantForCreationDto restaurant)
{
if (restaurant.Description == restaurant.Name)
{
ModelState.AddModelError("Description", "The provided description should be different from the name");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var city = CitiesDataStore.Current.Cities.FirstOrDefault(c => c.Id == cityId);
if (city == null)
{
return(NotFound());
}
var maxRestaurantId = CitiesDataStore.Current.Cities.SelectMany(c => c.Restaurants).Max(r => r.Id);
var finalRestaurant = new RestaurantDto
{
Id = ++maxRestaurantId,
Name = restaurant.Name,
Description = restaurant.Description
};
city.Restaurants.Add(finalRestaurant);
return(CreatedAtRoute(
"GetRestaurantById",
new { cityId, id = finalRestaurant.Id },
finalRestaurant));
}
public DishApplicationTest()
{
(_application, _restaurantApplication) = ObjectInitiliazer.CreateDishApplication();
_restaurantDto = _restaurantApplication.Add(new RestaurantDto {
Name = "Restaurant"
});
}
public void CreateRestaurant(RestaurantDto rest)
{
var d = new BsonDocument();
var r = GetBson(rest);
Console.WriteLine(r);
var o = 0;
}
public bool MarkAsChosen(RestaurantDto restaurantVoted, DateTime dateTimeChosen)
{
restaurantVoted.LastChosenDate = dateTimeChosen;
_restaurantRepository.Update(RestaurantDto.ToEntity(restaurantVoted));
return(true);
}
public bool RestaurantAlreadyChosenForWeek(RestaurantDto restaurantChosen)
{
if (restaurantChosen.LastChosenDate.HasValue)
{
return(restaurantChosen.LastChosenDate.Value.Date.AddDays(7) > DateTime.Now);
}
return(false);
}
public void Should_Satisfied_When_NameIsValid(
RestaurantDto dto,
bool expectResult
)
{
var nameIsValidSpecification = new NameIsValidSpecification <RestaurantDto>();
Assert.AreEqual(expectResult, nameIsValidSpecification.IsSatisfiedBy(dto));
}
public IActionResult Create([FromBody] RestaurantDto dto)
{
try {
var restaurant = _svc.Create(_mapper.Map <Restaurant>(dto));
return(Ok(_mapper.Map <RestaurantDto>(restaurant)));
} catch (Exception ex) {
return(BadRequest(new ErrorResponse(ex.Message)));
}
}
public void Should_Satisfied_When_CityIsValid(
RestaurantDto dto,
bool expectResult
)
{
var cityIsValidSpecification = new CityIsValidSpecification();
Assert.AreEqual(expectResult, cityIsValidSpecification.IsSatisfiedBy(dto));
}
public void Execute(RestaurantDto request)
{
_validator.ValidateAndThrow(request);
var restaurant = _mapper.Map <Restaurant>(request);
_context.Restaurants.Add(restaurant);
_context.SaveChanges();
}
public RestaurantDto GetMoreVoted()
{
var restaurants = _restaurantRepository.GetAll();
var restaurantWereVoted = restaurants.Where(x => x.Votes.Any(y => y.DateTimeVote.Date == DateTime.Now.Date));
var restaurantMoreVoted = restaurantWereVoted.OrderByDescending(x => x.Votes.Count).FirstOrDefault();
return(RestaurantDto.ToDto(restaurantMoreVoted));
}
public IActionResult RegisterRestaurant([FromBody] RestaurantDto item)
{
_mapperSession.BeginTransaction();
_restaurantRepository.Save(item.GetDataItem());
_mapperSession.Commit();
_mapperSession.CloseTransaction();
// TODO: TRY CATCH OR USING
return(StatusCode(201));
}
public IActionResult Update([FromBody] RestaurantDto dto)
{
try {
var restaurant = _svc.Update(_mapper.Map <Restaurant>(dto));
return(Ok(_mapper.Map <RestaurantDto>(restaurant)));
} catch (PleyNotFoundException) {
return(NotFound(new ErrorResponse("Restaurant not found.")));
} catch (Exception ex) {
return(BadRequest(new ErrorResponse(ex.Message)));
}
}
public EditRestaurantViewModel(RestaurantDto restaurant)
{
DisplayName = "Edit restaurant";
_restaurant = restaurant;
RestaurantName = _restaurant.Name;
}
