public async Task <IResult> Handle(AnimalTransactionalOperationCommand request, CancellationToken cancellationToken)
{
var isAnimalExits = await _animalRepository.GetAsync(u => u.AnimalName == request.AnimalName);
if (isAnimalExits != null)
{
return(new ErrorResult(Messages.NameAlreadyExist));
}
var animal = new Animal
{
AnimalName = request.AnimalName
};
_animalRepository.Add(animal);
await _animalRepository.SaveChangesAsync();
var animalUpdate = await _animalRepository.GetAsync(a => a.AnimalId == 12);
animalUpdate.AnimalName = "Catx";
_animalRepository.Update(animalUpdate);
await _animalRepository.SaveChangesAsync();
return(new SuccessResult(Messages.Added));
}
public IActionResult Create(Animal animal)
{
if (ModelState.IsValid)
{
Animal newAnimal = _animalRepository.Add(animal);
return(RedirectToAction("details", new { id = newAnimal.Id }));
}
return(View());
}
public void AnimalsEdit()
{
Animal animal = new Animal();
animal.Name = "Jeroen";
animal.Price = 100;
animal.Category = "Boerderij";
AnimalRepo.Add(animal);
animal.Name = "Chris";
var result = animalsController.Edit(animal) as RedirectToRouteResult;
Assert.AreEqual("Chris", AnimalRepo.FindById(animal.Id).Name);
Assert.AreEqual("Index", result.RouteValues["Action"]);
Assert.IsNotNull(result.ToString());
AnimalRepo.Remove(animal.Id);
}
public async Task <Result> Execute(CreateAnimalInput input)
{
var animals = await _animalRepository.Add(new Domain.Animals.Animal {
Ege = input.Ege,
Name = input.Name,
NumberLegs = input.NumberLegs
});
return(this.BuildOutput(animals));
}
/// <summary>
/// Adds an animal. Age is automatically calculated if a birthday is added.
/// If not, the estimated age becomes the actual age.
/// </summary>
/// <param name="animal">The animal object.</param>
public void Add(Animal animal)
{
try
{
animal.Age = CalculateAge(animal);
if (animal.Age == -1)
{
throw new InvalidOperationException("Age can't be less then 0");
}
_animalRepository.Add(animal);
} catch (InvalidOperationException e)
{
throw e;
}
}
public IActionResult Create([FromBody] AnimalViewModel animal)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Animal _newAnimal = Mapper.Map <AnimalViewModel, Animal>(animal);
_animalRepository.Add(_newAnimal);
_animalRepository.Commit();
animal = Mapper.Map <Animal, AnimalViewModel>(_newAnimal);
CreatedAtRouteResult result = CreatedAtRoute("GetAnimal", new { controller = "Animals", id = animal.Id }, animal);
return(result);
}
public async Task <IActionResult> Post(Animal model)
{
try
{
var animal = _mapper.Map <Animal>(model);
_repository.Add(animal);
if (await _repository.SaveChangesAsync())
{
return(Created($"/api/marfrig/{model.Id}", _mapper.Map <AnimalDto>(animal)));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Banco de dados falhou {ex.Message}"));
}
return(BadRequest());
}
public OperationResult Add(AnimalContract animal)
{
try
{
if (animal == null)
{
return(new OperationResult(false, "Null contract."));
}
animal.ID = Guid.NewGuid();
animal.CreatedOn = DateTime.Now;
_animalRepository.Add(animal);
return(new OperationResult(true, "Animal added."));
}
catch (Exception e)
{
return(new OperationResult(false, e.Message));
}
}
public async Task <AnimalModel> AddOrUpdate(AnimalModel AnimalModel)
{
var AnimalInDb = await repository.GetAsync(AnimalModel.Id);
Animal @new;
if (AnimalInDb == null)
{
var Animal = mapper.Map <Animal>(AnimalModel);
@new = repository.Add(Animal);
}
else
{
@new = mapper.Map <AnimalModel, Animal>(AnimalModel, AnimalInDb);
repository.Update(AnimalInDb);
}
repository.UnitOfWork.SaveChangesAsync();
return(mapper.Map <AnimalModel>(@new));
}
public ActionResult Create([Bind(Include = "Id,Name,Price,Category,Image")] Animal animal)
{
if (ModelState.IsValid)
{
if (CheckCategory(animal.Category))
{
string path = "~/Images/kuiken.png";
animal.Image = path;
dbAnimal.Add(animal);
return(RedirectToAction("Index"));
}
else
{
ViewBag.ErrorMessage = "Categorie moet: Boerderij of Woestijn of Jungle of Sneeuw zijn.";
return(View());
}
}
return(View(animal));
}
public async Task <ActionResult <Animal> > PostAnimal(Animal animal)
{
try
{
_repository.Add(animal);
}
catch (DbUpdateException)
{
if (AnimalExists(animal.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <IResult> Handle(CreateAnimalCommand request, CancellationToken cancellationToken)
{
var isAnimalExits = _animalRepository.Query().Any(u => u.AnimalName == request.AnimalName);
if (isAnimalExits)
{
return(new ErrorResult(Messages.NameAlreadyExist));
}
var animal = new Animal
{
//classın özellikleri buraya yazılır.
AnimalName = request.AnimalName
};
_animalRepository.Add(animal);
await _animalRepository.SaveChangesAsync();
return(new SuccessResult(Messages.Added));
}
public void IsRepositoryAddsAnimal()
{
var count = AnimalRepo.GetAnimals().Count() + 1;
Animal animal = new Animal();
{
animal.Name = "Salt";
animal.Category = "Jungle";
animal.Price = 15;
animal.Image = "~/Images/kuiken.png";
}
AnimalRepo.Add(animal);
var result = AnimalRepo.GetAnimals();
var numberOfRecords = result.ToList().Count;
Assert.AreEqual(count, numberOfRecords);
AnimalRepo.Remove(animal.Id);
}
public async Task <IActionResult> Post(Dog dog)
{
var response = await _repository.Add(dog);
return(Created(string.Empty, response));
}
public IActionResult Post(Animal animal)
{
_animalRepository.Add(animal);
return(CreatedAtAction("Get", new { id = animal.Id }, animal));
}
public void Insert(Animal a)
{
_animalRepository.Add(a);
}
public ServiceResult <string> AddAnimal(AnimalServiceModel animal)
{
var addResult = animalRepository.Add(animal.ConvertToModel());
return(addResult.IsSuccess ? ServiceResult <string> .Success("success - add", "") : ServiceResult <string> .Failed(string.Empty, ""));
}
public void Add(AnimalViewModel obj)
{
var animalEntt = Mapper.Map <AnimalViewModel, Animal>(obj);
_animalRepository.Add(animalEntt);
}
public async Task <IActionResult> Post(Cat cat)
{
var response = await _repository.Add(cat);
return(StatusCode(201, response));
}
public Animal Add(Animal animal)
{
_animalRepo.Add(animal);
return(animal);
}