public ActionResult Delete(CategoriaViewModel model)
{
try
{
//TODO: Validar ModelState
_unidadeTrabalho.Iniciar();
_categoriaServico.Remover(model.MapTo<Categoria>());
_unidadeTrabalho.Salvar();
return RedirectToAction("Index");
}
catch
{
return View(model);
}
}
public async Task <IActionResult> Edit(Guid id, CategoriaViewModel categoriaViewModel)
{
if (categoriaViewModel.Id != id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(categoriaViewModel));
}
var categoria = _mapper.Map <Categoria>(categoriaViewModel);
await _categoriaService.Atualizar(categoria);
if (!OperacaoValida())
{
return(View(await ObterCategoriaProdutos(id)));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
Categoria categoria = await db.Categorias.SingleOrDefaultAsync(c => c.Id == id);
if (categoria == null)
{
return(NotFound());
}
CategoriaViewModel model = new CategoriaViewModel
{
Id = categoria.Id,
Descricao = categoria.Descricao
};
return(View(model));
}
public IActionResult Detalle(int Id)
{
try
{
CategoriaDTO categoriaDTO = this._categoriaService.getCategoria((int)Id);
if (categoriaDTO != null)
{
CategoriaViewModel categoriaViewModel = this._mapper.Map <CategoriaDTO, CategoriaViewModel>(categoriaDTO);
return(View(categoriaViewModel));
}
else
{
ViewBag.error = "Ocurrio un erro al intentar obtener el registro solicitado.";
return(View("index"));
}
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("index"));
}
}
public IActionResult Edit(CategoriaViewModel Categoria)
{
Respuesta respuesta = new Respuesta();
try
{
using (Almacen_dbContext db = new Almacen_dbContext())
{
Categoria categoria = db.Categoria.Find(Categoria.IdCategoria);
categoria.NombreCategoria = Categoria.NombreCategoria;
categoria.DescripcionCategoria = Categoria.DescripcionCategoria;
db.Entry(categoria).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
respuesta.Exito = 1;
}
}
catch (Exception ex)
{
respuesta.Mensaje = ex.Message;
}
return(Ok(respuesta));
}
public IActionResult Add(CategoriaViewModel Categoria)
{
Respuesta respuesta = new Respuesta();
try
{
using (Almacen_dbContext db = new Almacen_dbContext())
{
Categoria categoria = new Categoria();
categoria.NombreCategoria = Categoria.NombreCategoria;
categoria.DescripcionCategoria = Categoria.DescripcionCategoria;
db.Categoria.Add(categoria);
db.SaveChanges();
respuesta.Exito = 1;
}
}
catch (Exception ex)
{
respuesta.Mensaje = ex.Message;
}
return(Ok(respuesta));
}
public ActionResult Editar(CategoriaViewModel categoria)
{
try
{
if (ModelState.IsValid)
{
categoria = _categoriaAppService.Atualizar(categoria);
TempData["sucesso"] = EnumMensagem.EDITADO.Description;
return(RedirectToAction("Index"));
}
else
{
TempData["erro"] = String.Join(";", ModelState.Values.SelectMany(v => v.Errors).Select(x => x.ErrorMessage));
return(View(categoria));
}
}
catch (Exception e)
{
TempData["erro"] = e.Message;
return(View(categoria));
}
}
public async Task <ActionResult> DevolverPorCodigo(string codigo)
{
try
{
ProductoViewModel productoViewModel = new ProductoViewModel();
var item = await productoServices.DevolverPorCodigo(codigo);
productoViewModel.CodigoProducto = item.Codigo;
productoViewModel.NombreProducto = item.Nombre;
productoViewModel.Descripcion = item.Descripcion;
productoViewModel.CodigoCategoria = item.Categoria.Codigo;
decimal precio = 0;
if (item.Lista_Precio != null)
{
precio = item.Lista_Precio.Precio;
}
productoViewModel.Precio = precio;
CategoriaViewModel categoria = new CategoriaViewModel();
if (item.Categoria != null)
{
categoria.CodigoCategoria = item.Categoria.Codigo;
categoria.NombreCategoria = item.Categoria.Nombre;
categoria.Descripcion = item.Categoria.Descripcion;
}
productoViewModel.Categoria = categoria;
return(Ok(productoViewModel));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> CadastrarConfirme(Categoria categoria)
{
try
{
if (ModelState.IsValid)
{
await _categoriaRepository.Cadastrar(categoria);
var CategoriaVm = new CategoriaViewModel
{
Categorias = await _categoriaRepository.GetAll(),
Mensagem = "Cadastro feito com sucesso!"
};
return(Json(CategoriaVm));
}
return(Json("Preencha os dados corretamente"));
}
catch (Exception e)
{
return(Json("error", e.Message));
}
}
public ActionResult Crear(CategoriaViewModel model)
{
if (ModelState.IsValid)
{
if (db.Categorias.Any(x => x.CategoriaName == model.CategoriaName))
{
TempData["ErrorMessage"] = "La Categoría ya se encuatra registrada";
return(View("Index", model));
}
var categoria = new Categoria();
categoria.CategoriaName = model.CategoriaName;
db.Categorias.Add(categoria);
db.SaveChanges();
TempData["SuccessMessage"] = "Categoria Creada Correctamente";
return(RedirectToAction("Index", "Categoria"));
}
var categorias = db.Categorias.OrderBy(x => x.CategoriaId).ToList();
model.Categorias = categorias;
return(View("Index", model));
}
public ActionResult Create(CategoriaViewModel categoriaViewModel)
{
//ViewBag.EstadoId = new SelectList(_estadoApp.GetAll().OrderBy(e => e.Nome), "EstadoId", "Nome", clienteEndereco.EstadoId);
//ViewBag.CidadeId = new SelectList(_cidadeApp.GetAll().OrderBy(c => c.Nome), "CidadeId", "Nome", clienteEndereco.CidadeId);
if (ModelState.IsValid)
{
var result = _categoriaApp.Add(categoriaViewModel);
if (!result.IsValid)
{
foreach (var validationAppError in result.Erros)
{
ModelState.AddModelError(string.Empty, validationAppError.Message);
}
return(View(categoriaViewModel));
}
return(RedirectToAction("Index"));
}
return(View(categoriaViewModel));
}
public async Task <IActionResult> Detalhe(int?id)
{
if (id == null)
{
return(NotFound());
}
// IEnumerable<Categoria> lista = mContext.Categoria.ToList();
CategoriaViewModel categorias = new CategoriaViewModel();
var categoria = await mContext.Categoria
.FirstOrDefaultAsync(m => m.Codigo == id);
if (id != null)
{
categorias.Codigo = categoria.Codigo;
categorias.Descricao = categoria.Descricao;
return(View(categorias));
}
else
{
return(NotFound());
}
}
public ActionResult Put(CategoriaViewModel categoria)
{
try
{
var resposta = Requisicao.Put("http://localhost:5000/api/Categoria",
categoria);
if (!resposta.IsSuccessStatusCode)
{
Response.StatusCode = 400;
Response.TrySkipIisCustomErrors = true;
return(Content("Erro ao atualizar categoria"));
}
Response.StatusCode = 200;
return(Content(""));
}
catch (Exception ex)
{
return(View("Error", ex.Message));
}
}
public ActionResult Post(CategoriaViewModel acao)
{
try
{
var resposta = Requisicao.Post("http://localhost:5000/api/Acao", acao);
if (!resposta.IsSuccessStatusCode)
{
Response.StatusCode = 400;
Response.TrySkipIisCustomErrors = true;
return(Content("Erro ao buscar dados"));
}
Response.StatusCode = 200;
Response.TrySkipIisCustomErrors = true;
return(Content(""));
}
catch (Exception ex)
{
return(View("Erro", ex.Message));
}
}
public async Task <IEnumerable <CategoriaViewModel> > GetCategorias()
{
var lista = new List <CategoriaViewModel>();
CategoriaViewModel viewModel = null;
var categorias = await _categoriaServico.GetCategorias();
if (categorias != null && categorias.Any())
{
var configuracao = new MapperConfiguration(conf => conf.CreateMap <SistemaVenda.Dominio.Entidades.Categoria, CategoriaViewModel>());
var mapeamento = configuracao.CreateMapper();
categorias.AsParallel().ForAll(categoria =>
{
viewModel = new CategoriaViewModel();
viewModel = mapeamento.Map <CategoriaViewModel>(categoria);
lista.Add(viewModel);
});
}
return(lista.OrderBy(l => l.Codigo));
}
public ActionResult Editar(int id)
{
try
{
var userSession = HttpContext.Session.GetUsuario();
if (userSession == null)
{
RedirectToAction("Index", "Login");
}
var categoriaRequest = _categoriaApplication.Get(userSession.Token, id);
if (!categoriaRequest.IsSuccessStatusCode)
{
if (categoriaRequest.StatusCode == HttpStatusCode.Unauthorized)
{
return(RedirectToAction("Index", "Login"));
}
return(Error(categoriaRequest.Content.ReadAsStringAsync().Result, "_Editar"));
}
var categoriaResponse = JsonConvert.DeserializeObject <Categoria>(categoriaRequest.Content.ReadAsStringAsync().Result);
var categoria = new CategoriaViewModel
{
CategoriaId = categoriaResponse.CategoriaId,
Nome = categoriaResponse.Nome,
Ativo = categoriaResponse.Ativo
};
return(View("_Editar", categoria));
}
catch (Exception e)
{
ModelState.AddModelError("Error", "Ocorreu um erro inesperado");
return(View("_Editar"));
}
}
public async Task <IActionResult> Update(int id, [FromBody] CategoriaViewModel categoria)
{
try
{
if (categoria == null)
{
return(BadRequest("Objeto Categoria está nulo."));
}
if (!ModelState.IsValid)
{
return(BadRequest("Objeto Categoria inválido"));
}
var entityCategoria = await _repository.Categoria.GetCategoriaByIdAsync(id);
if (entityCategoria == null)
{
return(NotFound());
}
_mapper.Map(categoria, entityCategoria);
_repository.Categoria.UpdateCategoria(entityCategoria);
if (await _repository.SaveAsync())
{
return(CreatedAtAction("Get", new { id = categoria.Id }, categoria));
}
}
catch (Exception)
{
return(StatusCode(500, "Internal server error"));
}
return(BadRequest());
}
public static IEnumerable <CategoriaViewModel> ListaCategoriaToListaCategoriaViewModel(IEnumerable <Categoria> listaCategoria)
{
IList <CategoriaViewModel> listaCategoriaViewModel = null;
if (listaCategoria != null)
{
CategoriaViewModel categoriaViewModel = null;
listaCategoriaViewModel = new List <CategoriaViewModel>();
foreach (var categoria in listaCategoria)
{
categoriaViewModel = new CategoriaViewModel();
categoriaViewModel.Id = categoria.CategoriaId;
categoriaViewModel.Descricao = categoria.Descricao;
categoriaViewModel.Nome = categoria.Nome;
categoriaViewModel.Slug = categoria.Slug;
listaCategoriaViewModel.Add(categoriaViewModel);
}
}
return(listaCategoriaViewModel);
}
public ActionResult Editar(CategoriaViewModel categoriaViewModel)
{
var categoriaModel = Mapper.Map <Categoria, CategoriaViewModel>(repositorioDeCategorias.Obter(categoriaViewModel.Id));
if (!ModelState.IsValid)
{
ViewData[CategoriasViewModel.MercadoriasCadastradas] = repositorioDeMercadorias.ObterTodos();
return(View(categoriaModel));
}
var categoria = Mapper.Map <CategoriaViewModel, Categoria>(categoriaViewModel);
bool editado = repositorioDeCategorias.Editar(categoria);
if (editado)
{
return(RedirectToAction("Detalhes", new { id = categoria.Id }));
}
ViewData[CategoriasViewModel.MercadoriasCadastradas] = repositorioDeMercadorias.ObterTodos();
ViewBag.Errou = true;
ViewBag.Mensagem = "Não foi possível editar a Categoria. Por favor informe ao administrador do sistema.";
return(View(categoriaModel));
}
public HttpResponseMessage Editar([FromBody] CategoriaViewModel categoriaViewModel)
{
var formatter = new JsonMediaTypeFormatter();
string retorno = null;
try
{
if (ModelState.IsValid)
{
var categoriaDomain = Mapper.Map <CategoriaViewModel, Categoria>(categoriaViewModel);
_categoriaAppServiceBase.Update(categoriaDomain);
retorno = "Categoria " + categoriaDomain.CatNome + "editado com sucesso.";
}
var jsonSerialize = new JsonSerialize();
jsonSerialize.SerializarJson(formatter);
}
catch (Exception ex)
{
retorno = "Houve um erro interno:" + ex;
}
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, retorno, formatter));
}
public bool Cadastrar(CategoriaViewModel categoriaViewModel)
{
bool ehCadastrado = false;
try
{
var categoria = CategoriaMapper.CategoriaViewModelToCategoria(categoriaViewModel);
_categoriaBusiness.Validar(categoria);
if (_categoriaBusiness.EhValido)
{
_categoriaRepository.Cadastrar(categoria);
}
ehCadastrado = true;
}
catch (Exception ex)
{
// log(ex.Message);
}
return(ehCadastrado);
}
// GET: Publico/Articulos/Categoria/1
public ActionResult Categoria(string categoriaUrl, int?page)//,string articuloUrl)
{
var fechaActual = DateTime.Now;
CategoriaViewModel model = new CategoriaViewModel();
var categoria = db.Categorias.FirstOrDefault(cat => cat.DescripcionSeo == categoriaUrl.ToLower());
if (categoria == null)
{
return(HttpNotFound());
}
var articulos = db.Articulos.Include(a => a.Categoria).Where(art => art.Publicado && art.FechaPublicacion <= fechaActual)
.OrderByDescending(art => art.FechaPublicacion);
var articulosFiltrados = articulos.Where(art => art.CategoriaId == categoria.CategoriaId);
if (page.HasValue)
{
model.PaginaActual = page.Value;
}
else
{
model.PaginaActual = 1;
}
double numPag = articulosFiltrados.Count() / articulosPorPagina;
model.NumPaginas = (int)Math.Truncate(numPag) + 1;
int skip = (model.PaginaActual - 1) * articulosPorPagina;
model.ArticulosRecientes = articulos.Skip(skip).Take(articulosPorPagina).ToList();
model.ArticulosBusqueda = articulosFiltrados.Skip(skip).Take(articulosPorPagina).ToList();
model.CategoriaId = categoria.CategoriaId;
model.Categoria = categoria;
return(View(model));
}
string Validar(CategoriaViewModel categoria)
{
if (string.IsNullOrEmpty(categoria.Nombre))
{
return("El nombre no debe estar vacio");
}
if (string.IsNullOrWhiteSpace(categoria.Descripcion))
{
return("La descripción no debe estar vacia");
}
if (categoria.Nombre.Length > 20)
{
return("El Nombre solo puede contener 20 caracteres como maximo");
}
if (categoria.Descripcion.Length > 80)
{
return("La Descripción solo puede contener 80 caracteres como maximo");
}
return("");
}
public async Task <IActionResult> Create(CategoriaViewModel categoriaViewModel)
{
try
{
if (ModelState.IsValid)
{
var categoria = new Categoria()
{
Descricao = categoriaViewModel.Descricao
};
_dbNoticias.Add(categoria);
await _dbNoticias.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(categoriaViewModel));
}
catch (Exception ex)
{
return(RedirectToAction("Index"));
}
}
private async void ExecuteGuardarAsync()
{
try
{
/// validacion de los campos
if (string.IsNullOrEmpty(this.nombreCategoria))
{
await Application.Current.MainPage.DisplayAlert("Alerta", "Nombre de la categoria \n Campo obligatoria", "Aceptar");
return;
}
if (CategoriaPadreSelectedItem == null)
{
await Application.Current.MainPage.DisplayAlert("Alerta", "Seleccione un categoria padre \n Campo obligatoria", "Aceptar");
return;
}
// Estados
this.IsRunning = true;
this.IsEnabled = false;
// Preparando el objeto para enviar
this.idPadreCategoria = CategoriaPadreSelectedItem.idCategoria; // CATEGORIA PADRE
this.padre = CategoriaPadreSelectedItem.nombreCategoria; // CATEGORIA PADRE
this.ordenVisualizacionProductos = OrdenVisualSelectedItem.idOrdenVisual;
this.mostrarProductosEn = MostrarEnSelectedItem.idMostrarEn;
this.numeroColumnas = (this.numeroColumnas == 0) ? 1 : this.numeroColumnas; // Numero de datos si es cero valor por defecto 1
this.orden = (this.orden == 0) ? 1 : this.orden; // Numero de orden si es 0 es 1
this.cabeceraPagina = (this.cabeceraPagina != null) ? this.cabeceraPagina : "";
this.metaTagsSeo = (this.metaTagsSeo != null) ? this.metaTagsSeo : "";
this.piePagina = (this.piePagina != null) ? this.piePagina : "";
this.tieneRegistros = (this.tieneRegistros != null) ? this.tieneRegistros : "";
this.tituloCategoriaSeo = (this.tituloCategoriaSeo != null) ? this.tituloCategoriaSeo : "";
this.urlCategoriaSeo = (this.urlCategoriaSeo != null) ? this.urlCategoriaSeo : "";
if (this.Nuevo)
{
this.afecta = true;
}
if (this.Nuevo)
{
// localhost:8080/admeli/xcore2/xcore/services.php/categorias/guardar
Response response = await webService.POST <Categoria, Response>("categorias", "guardar", (Categoria)this);
await App.Current.MainPage.DisplayAlert("Guardar", response.Message, "Aceptar");
}
else
{
// localhost:8080/admeli/xcore2/xcore/services.php/categorias/modificar
Response response = await webService.POST <Categoria, Response>("categorias", "modificar", (Categoria)this);
await App.Current.MainPage.DisplayAlert("Modificar", response.Message, "Aceptar");
}
// Refrescar y regresar a la pagina anterior
CategoriaViewModel.GetInstance().ExecuteRefresh();
await App.CategoriaItemPage.Navigation.PopAsync();
}
catch (Exception ex)
{
// Error message
await App.Current.MainPage.DisplayAlert("Error", ex.Message, "Aceptar");
}
finally
{
// Estados
this.IsRunning = false;
this.IsEnabled = true;
}
}
public void Adicionar(CategoriaViewModel categoriaViewModel)
{
_categoriaAppService.Adicionar(categoriaViewModel);
}
// PUT: api/Categoria/5
public CategoriaViewModel Put(Guid id, [FromBody] CategoriaViewModel value)
{
return(_categoriaAppService.Update(value));
}
private void Mapear(CategoriaViewModel viewModel, Categoria categoria)
{
db.Entry(categoria).CurrentValues.SetValues(viewModel);
}
public IEnumerable <DespesaViewModel> ObterDespesaPorCategoria(CategoriaViewModel categoria)
{
return(Mapper.Map <IEnumerable <Despesa>, IEnumerable <DespesaViewModel> >(_despesaService.ObterTodos().Where(x => x.Categoria.Id == categoria.Id)));
}
public async Task Atualizar(CategoriaViewModel categoriaViewModel)
{
var categoria = _mapper.Map <Categoria>(categoriaViewModel);
await _categoriaService.AtualizarAsync(categoria);
}
public CategoriaPage()
{
InitializeComponent();
BindingContext = viewModel = new CategoriaViewModel();
}
public ActionResult Edit(CategoriaViewModel model)
{
try
{
//TODO: Validar ModelState
_unidadeTrabalho.Iniciar();
_categoriaServico.Alterar(model.MapTo<Categoria>());
_unidadeTrabalho.Salvar();
return RedirectToAction("Index");
}
catch (Exception ex)
{
return View(model);
}
}
