public async Task <IServiceResult <Game> > CreateGame(string name) { try { var serviceResult = new ServiceResult <Game>(); var existingGame = await _unitOfWork.Games.GetGameByName(name); if (existingGame != null) { serviceResult.AddMessage($"There's already a Game with this name. 'Name: {name}'"); } if (!serviceResult.Success) { return(serviceResult); } var newGame = await _unitOfWork.Games.Create(new Game(name)); await _unitOfWork.Commit(); serviceResult.SetResult(newGame); return(serviceResult); } catch (Exception ex) { throw ex; } }
public FornecedorViewModel Adicionar(FornecedorViewModel obj) { UoW.BeginTransaction(); var dominio = Servico.Adicionar(Mapper.Map <FornecedorViewModel, Fornecedor>(obj)); UoW.Commit(dominio.ListaErros); return(Mapper.Map <Fornecedor, FornecedorViewModel>(dominio)); }
public ClienteViewModel Adicionar(ClienteViewModel obj) { UoW.BeginTransaction(); var dominio = Servico.Adicionar(Mapper.Map <ClienteViewModel, Cliente>(obj)); UoW.Commit(dominio.ListaErros); return(Mapper.Map <Cliente, ClienteViewModel>(dominio)); }
public void RegistraAdmin(AdminRegistroDto adminRegistroDto) { var admin = _mapper.Map <Usuario>(adminRegistroDto); admin.Senha = _authService.GeneratePasswordHash(adminRegistroDto.Senha); _usuarioRepository.Create(admin); _unityOfWork.Commit(); }
public async Task <ActionResult> Post([FromBody] CategoriaDTO categoriaDto) { var categoria = _mapper.Map <Categoria>(categoriaDto); _uof.CategoriaRepository.Add(categoria); await _uof.Commit(); var categoriaDTO = _mapper.Map <CategoriaDTO>(categoria); return(new CreatedAtRouteResult("ObterCategoria", new { id = categoria.CategoriaId }, categoriaDTO)); }
public async Task <ActionResult> Post([FromBody] ProdutoDTO produtoDto) { var produto = _mapper.Map <Produto>(produtoDto); _uof.ProdutoRepository.Add(produto); await _uof.Commit(); var produtoDTO = _mapper.Map <ProdutoDTO>(produto); return(new CreatedAtRouteResult("ObterProduto", new { id = produto.ProdutoId }, produtoDTO)); }
public IHttpActionResult Post([FromBody] Review review, int bookId) { review.Book.Id = bookId; var newReview = _unity.Reviews.AddReview(review); _unity.Commit(); var url = Url.Link("DefaultApi", new { controller = "Reviews", id = newReview.Id }); return(Created(url, newReview)); }
public ResponseObject <OccupationForGetDto> Create(OccupationForCreateDto occupationForCreateDto) { var occupation = _mapper.Map <Occupation>(occupationForCreateDto); _occupationRepository.Create(occupation); var commit = _unityOfWork.Commit(); return(commit ? new ResponseObject <OccupationForGetDto>(true, obj: _mapper.Map <OccupationForGetDto>(occupation)) : new ResponseObject <OccupationForGetDto>(false)); }
public IActionResult PutProduct(int id, Product product) { if (id != product.Id) { return(BadRequest()); } _uof.ProductRepository.Update(product); _uof.Commit(); return(Ok()); }
public IActionResult PutCategory(int id, Category category) { if (id != category.Id) { return(BadRequest()); } _uof.CategoryRepository.Update(category); _uof.Commit(); return(Ok()); }
public void CreateBrand(BrandViewModel brandViewModel) { Brand brand = new Brand() { BrandID = brandViewModel.BrandID, BrandTitle = brandViewModel.BrandTitle, BrandName = brandViewModel.BrandName, BrandDescription = brandViewModel.BrandDescription, BrandImage = brandViewModel.BrandImage }; BrandRepository.Add(brand); UnityOfWork.Commit(); }
public void Post(TEntity obj) { ServiceHelper.ValidateParams(new object[] { obj }); //Verificando se existe if (GetById(obj.Id) != null) { throw new ArgumentException("object already exists"); } _unitOfWork.Begin(); _entityRepository.Insert(obj); _unitOfWork.Commit(); }
public async Task <IActionResult> Store([FromBody] AgendaDto agenda) { var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value); agenda.UserId = userId; await _repo.Add(agenda); if (await _uof.Commit()) { return(StatusCode(201, new { message = "Atividade criada com sucesso!" })); } throw new Exception("Houve um erro interno ao salvar uma atividade"); }
public virtual async Task <Guid> Post(TWorkModel model) { Validate(model, _validator); var entity = _mapper.Map <TRepositoryModel>(model); _repository.Insert(entity); await _uow.Commit().ConfigureAwait(false); Logger.LogInformation( $"It was created the entity = {entity}"); return(entity.Id); }
public void createNew() { _uniytOfWork.TesteRepository.Add(new Teste { TesteName = "1 - teste", }); _uniytOfWork.Commit(); }
public void AddBuyer(Buyer buyer) { if (buyer == null) { throw new ArgumentNullException(nameof(buyer)); } var currentBuyer = _buyerRepository.GetById(buyer.Id); if (currentBuyer != null) { throw new Exception("Buyer already exist."); } currentBuyer.Name = "joao"; buyer.AddContact(new Contact() { Description = "michel" }); _buyerRepository.Add(buyer); _unityOfWork.Commit(); }
public Order Post( [FromServices] ICustomerRepository customerRepository, [FromServices] IOrderRepository orderRepository, [FromServices] IUnityOfWork uow ) { try { var customer = new Customer { Name = "Victor" }; var order = new Order { Number = "123", Customer = customer }; customerRepository.Save(customer); orderRepository.Save(order); uow.Commit(); return(order); } catch (System.Exception) { uow.Rollback(); throw; } }
public async Task <ActionResult> AddPatient([FromBody] AddPatientRequest request) { _unityOfWork.BeginTransaction(); try { var result = await _mediator.Send(request, CancellationToken.None); _unityOfWork.Commit(); return(Created("", new { result })); } catch (Exception e) { _unityOfWork.Rollback(); return(Conflict(e.Message)); } }
public async Task <Response> Handle(RemoveAcademicRequest request, CancellationToken cancellationToken) { //Verifica se a requisição é nula if (request == null) { AddNotification("Resquest", "A requisição não pode ser nula!"); return(new Response(this)); } //Verifica se o acadêmico existe if (!_academicRepository.Exists(request.Id)) { AddNotification("Acadêmico inválido", "O acadêmico informado não foi encontrado!"); return(new Response(this)); } //Valida a requisição if (IsInvalid()) { return(new Response(this)); } //Remove o acadêmico do banco _unityOfWork.BeginTransaction(); _academicRepository.Remove(request.Id); _unityOfWork.Commit(); //Cria o objeto da resposta var result = new { request.Id }; var response = new Response(this, result); //Retorna a resposta return(await Task.FromResult(response)); }
public void InicializaDb() { var senha = _criptService.Encrypt("senhaDeTeste"); var user = new Usuarios { Idusuario = 1, Ativo = true, Email = "*****@*****.**", Excluido = false, Idcliente = 1, Login = "******", Nome = "Cassiano", Senha = senha }; var user2 = new Usuarios { Idusuario = 2, Ativo = true, Email = "*****@*****.**", Excluido = false, Idcliente = 1, Login = "******", Nome = "Cassiano", Senha = senha }; _unityOfWork.UserRepository.Create(user); _unityOfWork.UserRepository.Create(user2); _unityOfWork.Commit(); }
protected async Task <ValidationResult> PersistData(IUnityOfWork uow) { if (!await uow.Commit()) { AddError("Houve um erro ao persistir os dados"); } return(ValidationResult); }
public async Task <IActionResult> Store([FromBody] UserCreateDto newUser) { var user = await _repo.GetUserByEmail(newUser.Email); if (user != null) { return(BadRequest(new { message = "Este email já está em uso!" })); } await _repo.Add(newUser); if (await _uof.Commit()) { return(StatusCode(201, new { message = "Usuário criado com sucesso!" })); } throw new Exception("Houve um erro ao salvar um novo usuário"); }
protected async Task <ValidationResult> PersistToBase(IUnityOfWork uow) { if (!await uow.Commit()) { AddErrors("There was an error persisting the data"); } return(ValidationResult); }
public async Task <ActionResult> AddDrinks([FromBody] DrinkDto drinkdto) { try { _uof.DrinkRepository.Add(_mapper.Map <Drink>(drinkdto)); await _uof.Commit(); var drink = _mapper.Map <DrinkDto>(drinkdto); return(new CreatedAtRouteResult("GetDrink", new { id = drink.DrinkId }, drink));//return StatusCode(201); } catch (Exception) { return(StatusCode(400, String.Format("There is no {0} item", drinkdto.Name) )); } }
public bool Commit() { if (_notifications.HasNotifications()) { return(false); } _unitOfWork.Commit(); return(true); }
public async Task <IServiceResult <User> > CreateUser(string name, string password, int userTypeId) { try { var serviceResult = new ServiceResult <User>(); var type = await _unitOfWork.UserTypes.GetById(userTypeId); if (type == null) { serviceResult.AddMessage($"User Type Not Found. 'UserTypeId: {userTypeId}'"); } var existingUser = await _unitOfWork.Users.GetUserByName(name); if (existingUser != null) { serviceResult.AddMessage($"There's already a user with this name. 'Name: {name}'"); } if (!serviceResult.Success) { return(serviceResult); } var user = new User(name, type, _passwordService.HashPassword(password)); if (type.TypeId == (int)UserTypeEnum.Friend) { user = new Friend(user); } var newUser = await _unitOfWork.Users.Create(user); await _unitOfWork.Commit(); serviceResult.SetResult(newUser); return(serviceResult); } catch (Exception ex) { throw ex; } }
public void VotoRating(RatingFilme ratingFilme) { var usuarioId = int.Parse(_httpContext.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value); var filme = _filmeRepository.GetById(ratingFilme.IdFilme); if (filme is null) { throw new CoreException(Resources.FilmeInexistente); } var voto = new Voto { IdFilme = filme.Id, IdUsuario = usuarioId, Rating = ratingFilme.Rating }; _votoRepository.CriaVoto(voto); _unityOfWork.Commit(); AtualizaRatingFilme(filme); }
protected bool Commit() { var commandResponse = _unityOfWork.Commit(); if (commandResponse.Success) { return(true); } Console.WriteLine("Ocorreu um erro ao salvar os dados no banco"); return(false); }
public override void OnResultExecuted(ResultExecutedContext context) { if (context.Exception == null) { _uow.Commit(); } else { _uow.Rollback(); } base.OnResultExecuted(context); }
public bool Commit(Notifiable entity) { if (entity.IsNotification()) { _uow.Commit(); return(true); } else { _uow.Rollback(); return(false); } }