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);
}
}
