public void AddRestaurant(RestaurantRequestDto requestDto)
{
RestaurantEntity toAdd = new RestaurantEntity
{
Name = requestDto.Name,
Address = requestDto.Address,
FamilyFriendly = requestDto.FamilyFriendly,
VeganOptions = requestDto.VeganOptions,
Rating = requestDto.Rating
};
_restaurantRepository.Add(toAdd);
foreach (int id in requestDto.CuisineTagIds)
{
_restaurantRepository.AddCuisineTag(new RestaurantCuisineEntity
{
CuisineId = id,
RestaurantId = toAdd.Id
});
}
if (!_restaurantRepository.Save())
{
throw new Exception("Creating a item failed on save.");
}
}
public Restaurant Add(Restaurant obj)
{
BeginTransaction();
obj = _restaurantRepository.Add(obj);
Commit();
return(obj);
}
public async Task <Entities.Models.Restaurant> Add(Entities.Models.Restaurant model)
{
var entity = _restaurantRepository.Add(model);
await _restaurantRepository.SaveChangeAsync();
return(model);
}
public Task <Unit> Handle(RegisterNewRestaurantCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Unit.Task);
}
var restaurant = new Restaurant(Guid.NewGuid(), message.Name, message.Description, message.IsActive, message.ExpertiseId, message.Address);
if (_restaurantRepository.GetByAddress(restaurant.Address.Street, restaurant.Address.Number).Result != null)
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "Já existe um restaurant com este endereço."));
return(Unit.Task);
}
_restaurantRepository.Add(restaurant);
if (Commit())
{
Bus.RaiseEvent(new RestaurantRegisteredEvent(restaurant.Id, restaurant.Name, restaurant.Description, restaurant.IsActive, restaurant.ExpertiseId, restaurant.Address));
}
return(Unit.Task);
}
public async Task <IActionResult> Create(RestaurantCreateViewModel model)
{
if (ModelState.IsValid)
{
var restaurant = new Restaurant
{
Name = model.Name,
Phone = model.Phone,
Email = model.Email,
Description = model.Description,
Postcode = model.Postcode,
Unit = model.Unit,
Street = model.Street,
Town = model.Town,
StateCode = model.StateCode,
DateUpdated = DateTime.Now
};
repository.Add(restaurant);
await unitOfWork.CompleteAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <ActionResult <CustomerModel> > PostCustomer(CustomerModel model)
{
try
{
var customer = _mapper.Map <Customer>(model);
_context.Add(customer);
var location =
_linkGenerator.GetPathByAction("GetCustomer",
"Customers",
new { id = customer.CustomerId });
if (await _context.SaveChangesAsync())
{
return(Created(location, customer));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Error while executing request: {ex}"));
}
return(BadRequest());
}
public Restaurant Add(Restaurant restaurant)
{
if (!restaurant.IsValidated())
{
return(restaurant);
}
return(!restaurant.ValidationResult.IsValid ? restaurant : _restaurantRepository.Add(restaurant));
}
public RestaurantViewModel Insert(RestaurantViewModel restaurantViewModel)
{
var restaurant = _mapper.Map <Restaurant>(restaurantViewModel);
_restaurantRepository.Add(restaurant);
_restaurantRepository.SaveChanges();
return(_mapper.Map <RestaurantViewModel>(restaurant));
}
// POST: api/Restaurants
public IHttpActionResult Post(Restaurant restaurant)
{
if (ModelState.IsValid)
{
var createdRestaurant = _restaurantRepository.Add(restaurant);
return(CreatedAtRoute("DefaultApi", new { controller = "Restaurants", id = createdRestaurant.Id }, createdRestaurant));
}
return(BadRequest());
}
public ActionResult Create([Bind(Include = "Id,Name,City,Country")] Restaurant restaurant)
{
if (ModelState.IsValid)
{
_repository.Add(restaurant);
return(RedirectToAction(nameof(Index)));
}
return(View(restaurant));
}
public async Task <IActionResult> Create([Bind("RestaurantId,RestaurantName,Street,Phone,Website,Hours,CategoryId,ImageUrl,CarouselImage1,CarouselImage2,CarouselImage3")] Restaurant restaurant)
{
if (ModelState.IsValid)
{
_restaurantRepository.Add(restaurant);
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryId"] = new SelectList(_categoryRepository.Category, "CategoryId", "CategoryId", restaurant.CategoryId);
return(View(restaurant));
}
public Restaurant AddRestaurant(Restaurant restaurant)
{
Condition.WithExceptionOnFailure <InvalidParameterException>()
.Requires(restaurant, "restaurant")
.IsNotNull();
var resultAdd = _restaurantRepository.Add(restaurant);
_restaurantRepository.Save();
return(restaurant);
}
// POST: api/restaurants
public IHttpActionResult Post([FromBody] Restaurant restaurant)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var createdRestaurant = _restaurantRepository.Add(restaurant);
var restaurantUrl = Url.Link("DefaultApi", new { controller = "Restaurants", id = createdRestaurant.Id });
return(Created(restaurantUrl, createdRestaurant));
}
public async Task <RestaurantResponse> CreateAsync(Restaurant Restaurant)
{
try
{
_restaurantRepository.Add(Restaurant);
await _unitOfWork.CompleteAsync();
return(new RestaurantResponse(Restaurant));
}
catch (Exception ex)
{
return(new RestaurantResponse($"There was an error creating the client: {ex.Message}"));
}
}
public IActionResult Create(RestaurantEditModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var restaurant = new Restaurant
{
Name = model.Name,
Cuisine = model.Cuisine
};
_repository.Add(restaurant);
_repository.CommitChanges();
return(RedirectToAction(nameof(Details), new { id = restaurant.Id }));
}
public IActionResult Create(RestaurantDto restaurant)
{
if (ModelState.IsValid)
{
var newRestaurant = new Restaurant();
newRestaurant.Name = restaurant.Name;
newRestaurant.Cuisine = restaurant.Cuisine;
newRestaurant = _restaurantRepository.Add(newRestaurant);
return(RedirectToAction(nameof(Details), new { id = newRestaurant.Id }));
}
else
{
return(View());
}
}
public ActionResult <RestaurantDTO> Create(RestaurantDTO restaurantDTO)
{
try
{
if (restaurantDTO == null)
{
return(BadRequest("Empty object."));
}
restaurantDTO.Id = Guid.NewGuid();
var restaurant = mapper.Map <Restaurant>(restaurantDTO);
repository.Add(restaurant);
return(CreatedAtAction(nameof(Create), restaurant));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(BadRequest(ex.Message));
}
}
public IActionResult OnPost()
{
GetCuisines();
if (!ModelState.IsValid)
{
return(Page());
}
if (Restaurant.Id > 0)
{
_restaurantData.Update(Restaurant);
}
else
{
_restaurantData.Add(Restaurant);
}
_restaurantData.Commit();
TempData["Message"] = $"{Restaurant.Name} saved!";
return(RedirectToPage("./List"));
}
public void CreateRestaurant(Restaurant restaurant)
{
_restaurantRepository.Add(restaurant);
}
public void CreateRestaurant(Restaurant Restaurant)
{
RestaurantRepository.Add(Restaurant);
unitOfWork.Commit();
}
public void CreateRestarurantAccount(RestarurantAccount resacc)
{
restarurantaccount.Add(resacc);
}
public void Add(IRestaurantModel restaurantModel)
{
//throw new NotImplementedException();
_restaurantRepository.Add(restaurantModel);
}
public void Add(Restaurant restaurant)
{
_restaurantRepository.Add(restaurant);
}
public void Insert(Restaurant entity)
{
_restaurantRepository.Add(entity);
}
public async Task <int> Add(string name)
{
int restaurantId = await restaurantRepository.Add(name);
return(restaurantId);
}