public IActionResult Add([FromBody] AddEditProdutoViewModel vm)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
var produto = vm.ToProduto();
_produtoRepository.Add(produto);
return(Ok(produto));
}
public long Add(ProdutoAddCommand produto)
{
var _produto = Mapper.Map <ProdutoAddCommand, Produto>(produto);
var novoProduto = _repository.Add(_produto);
return(novoProduto.Id);
}
public async Task <IActionResult> AddEdit(string id, ProdutoAddEditVM model)
{
ModelState.Remove("DataHoraRegistro");
ModelState.Remove("IdUsuarioRegistro");
if (!ModelState.IsValid)
{
return(View(model));
}
var data = model.ToData();
if (String.IsNullOrEmpty(id))
{
data.IdUsuarioRegistro = Convert.ToDecimal(HttpContextHelper.GetAuthUserId(HttpContext));
data.DhRegistro = Convert.ToDecimal(DateTime.Now.ToString("yyyyMMddHHmmss"));
_produtoRepo.Add(data);
}
else
{
_produtoRepo.Update(data);
}
await _uow.CommitAsync();
return(RedirectToAction("Index"));
}
public ActionResult AddEdit(Produto produto)
{
if (ModelState.IsValid)
{
try
{
if (produto.Id == 0)
{
_produtoRep.Add(produto);
}
else
{
_produtoRep.Update(produto);
}
//throw new Exception("Erro no banco");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
ViewBag.TipoProdutos = _tipoProdRep.Get();
return(View(produto));
}
public async Task <JsonResult> Add(Produto produto)
{
try
{
produto.DataCadastro = DateTime.Now;
Notificacao resultado = await _produtoRepository.Add(produto);
if (resultado.Erro)
{
return(Json(new JsonModel()
{
Success = false, result = resultado.Resultado, Message = resultado.Msg
}));
}
return(Json(new JsonModel()
{
Success = true, result = resultado, Message = resultado.Msg
}));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> Add([FromBody] ProdutoAddEdit model)
{
var categoria = await _categoriaRepository.GetAsync(model.CategoriaId);
if (categoria == null)
{
ModelState.AddModelError("CategoriaId", "Categoria inválida");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToProduto();
_produtoRepository.Add(data);
var produto = data.ToProdutoGet();
produto.Nome = categoria.Nome;
return(CreatedAtRoute("GetProdutoById", new { produto.Id }, produto));
}
public async Task <Guid> Handle(CriarProdutoCommand request, CancellationToken cancellationToken)
{
try
{
if (!request.IsValid())
{
ValidationErrors(request);
return(await Task.FromResult(Guid.Empty));
}
var produto = new Produto
{
Id = GeradorGuidService.GetNexGuid(),
Valor = request.Valor,
Nome = request.Nome
};
_produtoRepository.Add(produto);
return(await Task.FromResult(produto.Id));
}
catch (Exception ex)
{
await Mediator.Publish(new DomainNotification(request.MessageType, $"Erro: {ex.Message}"), cancellationToken);
return(await Task.FromResult(Guid.Empty));
}
}
public async Task <IActionResult> Add([FromBody] ProdutoPost model)
{
var categoria = await _categoriaRepository.GetAsync(model.CategoriaId);
if (categoria == null)
{
ModelState.AddModelError("CategoriaId", "Categoria inválida");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToProdutoEntity();
_produtoRepository.Add(data);
var produto = data.ToProdutoGet();
produto.CategoriaNome = categoria.Nome;
//return Ok(produto);
//Retorna objeto batendo na rota GetById
return(CreatedAtRoute("GetProductById", new { data.Id }, produto));
}
public async Task <IActionResult> AddEdit(int Id, ProdutoAddEditVM model)
{
if (!ModelState.IsValid)
{
await addCategoriasToModel(model);
return(View(model));
}
var prod = model.ToData();
if (Id == 0)
{
_produtoRepository.Add(prod);
}
else
{
prod.Id = Id;
prod.DataAlteracao = DateTime.Now;
_produtoRepository.Update(prod);
}
await _uow.CommitAsync();;
return(RedirectToAction("Index"));
}
public IActionResult AddEdit(Produto produto)
{
if (!ModelState.IsValid)
{
return(View());
}
var msg = $"Produto {produto.Nome} ";
if (produto.Id == 0)
{
//_ctx.Add(produto);
_produtoRepository.Add(produto);
msg += "adicionado";
}
else
{
//_ctx.Update(produto);
_produtoRepository.Update(produto);
msg += "atualizado";
}
msg += " com sucesso!";
//_ctx.SaveChanges();
TempData["msg"] = msg;
return(RedirectToAction("Index"));
}
[Route("cadastrar")] //URL: /api/produto/cadastrar
public HttpResponseMessage Post(ProdutoCadastroViewModel viewModel)
{
//verificar se não há erros de validação na classe de modelo
if (ModelState.IsValid)
{
try
{
var produto = Mapper.Map <Produto>(viewModel);
repository.Add(produto); //gravando..
//retornar para o cliente um status de sucesso 200
return(Request.CreateResponse(HttpStatusCode.OK,
"Produto cadastrado com sucesso."));
}
catch (Exception e)
{
//retornar para o cliente um status de erro 500
return(Request.CreateResponse(HttpStatusCode.InternalServerError,
"Ocorreu um erro: " + e.Message));
}
}
else
{
//retornar para o cliente um status de erro 400
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ValidationUtil.GetErrorMessages(ModelState)));
}
}
public Produto Adicionar(Produto produto)
{
produto.ResultadoValidacao = new ProdutoAptoParaCadastroValidation(_repository).Validate(produto);
if (PossuiConformidade(produto.ResultadoValidacao))
{
_repository.Add(produto);
}
return(produto);
}
public IActionResult Create([FromBody] Produto produto)
{
if (produto == null)
{
BadRequest();
}
_repo.Add(produto);
return(CreatedAtRoute("GetProduto", new { id = produto.Id }, produto));
}
public async Task Add(Produto produto)
{
if (!ExecutarValidacao(new ProdutoValidation(), produto))
{
return;
}
await _produtoRepository.Add(produto);
}
public Int32 Create(PRODUTO item, LOG log, MOVIMENTO_ESTOQUE_PRODUTO movto)
{
using (DbContextTransaction transaction = Db.Database.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
_logRepository.Add(log);
_baseRepository.Add(item);
//_movRepository.Add(movto);
transaction.Commit();
return(0);
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
}
public void Save(Produto produto)
{
try
{
dbProduto.Add(produto);
}
catch (Exception ex)
{
throw new Exception($"Erro ao salvar produto: {ex.Message}.");
}
}
public async Task <string> Handle(CriarProdutoCommand command, CancellationToken cancellationToken)
{
Produto produto = _mapper.Map <Produto>(command);
try {
_produtoRepository.Add(produto);
return("ok");
} catch {
return("falha");
}
}
public ActionResult Create(ProdutoViewModel produto)
{
if (ModelState.IsValid)
{
var produtoDomain = Mapper.Map <ProdutoViewModel, Produto>(produto);
_produtoApp.Add(produtoDomain);
return(RedirectToAction("Index"));
}
return(View(produto));
}
public void InicializaDB()
{
this.contexto.Database.EnsureCreated();
if (produtoRepository.NenhumProduto())
{
var json = System.IO.File.ReadAllText(@"livros.json");
var livros = JsonConvert.DeserializeObject <List <Livro> >(json);
produtoRepository.Add(livros);
}
}
public async Task <IActionResult> AddProduto([FromForm] Models.Produtos.PostProduto model,
IFormFile foto
//, [FromServices] IHostingEnvironment env
)
{
// Para evitar isso, usar Mediatr (https://github.com/FanSoft-BR/agenda_medica/tree/master/src)
if (foto == null)
{
ModelState.AddModelError("", "Foto é inválida");
}
var tipo = _tipoProdutoRepository.Get(model.TipoProdutoId);
if (tipo == null)
{
ModelState.AddModelError("TipoProdutoId", "Tipo do produto inválido");
}
if (ModelState.IsValid)
{
var fileName = Guid.NewGuid().ToString("N") + foto.FileName.Substring(foto.FileName.LastIndexOf('.'));
var filePath = Path.Combine(_uploadFolder, fileName);
var produto = new Produto()
{
Nome = model.Nome,
TipoProdutoId = model.TipoProdutoId,
Preco = model.Preco,
NomeArquivo = filePath
};
_produtoRepository.Add(produto);
await _uow.CommitAsync();
// await gravarEmPasta(foto, filePath);
await gravarNoAzureAsync(foto, fileName, filePath);
return(CreatedAtRoute("GetProdutoById", new { produto.Id },
new
{
produto.Id,
produto.Nome,
produto.Preco,
Tipo = tipo.Nome
}
));
}
return(BadRequest(ModelState));
}
public void Gravar(ProdutoDto produtoDto)
{
Produto produto = Mapper.Map <ProdutoDto, Produto>(produtoDto);
if (produto != null && produto.ProdutoId > 0)
{
_produtoRepository.Update(produto);
}
else
{
_produtoRepository.Add(produto);
}
}
public async Task <Response.Produto> Add(Request.Produto entity)
{
if (!IsParameterValid(entity))
{
throw new InvalidParametersException <IProdutoAppService>();
}
var produto = await produtoRepository.Add(entity.ConvertToData());
await Salvar();
return(new Response.Produto());
}
public IActionResult OnPost()
{
if (ModelState.IsValid)
{
var count = _produtoRepository.Add(produto);
if (count > 0)
{
Message = "Novo Produto adicionado com sucesso!";
return(RedirectToPage("/Produto/Index"));
}
}
return(Page());
}
void SalvarProduto(Produto Produto)
{
// Validando
var validator = EntityValidatorFactory.CreateValidator();
if (!validator.IsValid(Produto))
{
throw new ApplicationValidationErrorsException(validator.GetInvalidMessages <Produto>(Produto));
}
_produtoRepository.Add(Produto);
_produtoRepository.Commit();
}
public ActionResult Create(Produto produto)
{
try
{
// TODO: Add insert logic here
_produtoRepository.Add(produto);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Add([FromBody] PostCommand model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var data = model.ToData();
_prodRepository.Add(data);
await _uow.CommitAsync();
return(CreatedAtRoute("GetProdutoById", new { data.Id }, data));
}
private int CriarProduto(ProdutoFornecedorDTO produtoFornecedorDto)
{
var produto = new Produto
{
Nome = produtoFornecedorDto.Nome,
Descricao = produtoFornecedorDto.Descricao,
UrlImagemDetalheSet = MapearImagensProduto(produtoFornecedorDto)
};
_produtoRepository.Add(produto);
_produtoRepository.Save();
return(produto.Codigo);
}
public async Task <ActionResult> Create(Produto produto, string TipoProduto)
{
try
{
if (ModelState.IsValid)
{
var tipoProduto = await _tipoRepository.GetTipoById(int.Parse(TipoProduto));
produto.TipoProduto = tipoProduto;
await _produtoRepository.Add(produto);
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <ResponseBase> Add(ProdutoModel poduto)
{
var response = new ResponseBase();
try
{
Produto produtoDomain = _mapper.Adapt <ProdutoModel, Produto>(poduto);
response.OperationResult.Id = await _produtoRepository.Add(produtoDomain);
response.OperationResult.Status = StatusOperation.OKRESULT;
}
catch (Exception ex)
{
response.OperationResult.Status = StatusOperation.ERRORRESULT;
response.OperationResult.Message = ex.Message;
}
return(response);
}
public IActionResult AddEdit(int Id, AddEditVM model)
{
if (!ModelState.IsValid)
{
loadCategoria();
return(View(model));
}
if (Id == 0)
{
_prodRepository.Add(model.ToProduto());
}
else
{
_prodRepository.Edit(model.ToProduto(Id));
}
return(RedirectToAction("Index"));
}
