public IActionResult CrearEditarPais(PaisViewModel viewModel)
{
try
{
var existePais = PaisService.ConsultarPais(viewModel);
if (viewModel.Id != 0)
{
if (existePais != null && existePais.Id != viewModel.Id)
{
return(Json(new { success = false }));
}
var nuevoPais = PaisMap.Update(viewModel);
}
else
{
if (existePais != null)
{
return(Json(new { success = false }));
}
var nuevoPais = PaisMap.Create(viewModel);
}
return(Json(new { success = true }));
}
catch (Exception ex)
{
AltivaLog.Log.Insertar(ex.ToString(), "Error");
return(BadRequest());
}
}
public JsonResult SalvarPais(PaisViewModel model)
{
var resultado = "OK";
var mensagens = new List <string>();
var idSalvo = string.Empty;
if (!ModelState.IsValid)
{
resultado = "AVISO";
mensagens = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage).ToList();
}
else
{
try
{
var vm = Mapper.Map <PaisModel>(model);
var id = vm.Salvar();
if (id > 0)
{
idSalvo = id.ToString();
}
else
{
resultado = "ERRO";
}
}
catch (Exception ex)
{
resultado = "ERRO";
}
}
return(Json(new { Resultado = resultado, Mensagens = mensagens, IdSalvo = idSalvo }));
}
public ActionResult Edit(int id, PaisViewModel collection)
{
try
{
TbSePais pais;
TbSeMensaje msj = new TbSeMensaje("Edito un Pais");
if (!ModelState.IsValid)
{
return(View());
}
// Email("Se Edito un Pais", msj);
pais = PaisMap.Update(collection);
if (pais != null)
{
var ids = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value;
this.IBitacoraMap.CrearBitacora(Convert.ToInt32(ids), "Edito los datos de un pais", pais.Id, "Pais");
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task <ActionResult <int> > Post([FromBody] PaisViewModel paisViewModel)
{
var paisEntity = _mapper.Map <PaisEntity>(paisViewModel);
var id = await _paisService.AddAsync(paisEntity);
return(Ok(id));
}
public IActionResult AddEditPais(long?id, PaisViewModel model)
{
try
{
if (ModelState.IsValid)
{
bool isNew = !id.HasValue;
Pais pais = isNew ? new Pais
{
} : context.Set <Pais>().SingleOrDefault(s => s.Id == id.Value);
pais.Descricao = model.Descricao;
if (isNew)
{
context.Add(pais);
}
context.SaveChanges();
}
}
catch (Exception ex)
{
throw ex;
}
return(RedirectToAction("Index"));
}
public IActionResult EditPais([FromRoute] int id, [FromBody] PaisViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != model.Pais.Id)
{
return(BadRequest());
}
var pais = _paisService.GetPais(model.Pais.Id);
if (pais == null)
{
return(NotFound());
}
pais.Name = model.Pais.Name;
pais.Continente = model.Pais.Continente;
_paisService.Edit(pais);
return(NoContent());
}
// GET: Correction
public ActionResult Index()
{
ViewBag.Lenguages = IdiomaViewModel.ListFakeIdioma();
ViewBag.Paises = PaisViewModel.ListFakePaises();
return(View());
}
// GET: PaisViewModels/Details/5
public ActionResult Details(Guid?id)
{
PaisViewModel paisViewModel = null;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
paisViewModel = Mapper.Map <PaisViewModel>(uow.PaisRepositorio.Get(pais => pais.Id == id));
return(View(paisViewModel));
}
catch (Exception ex)
{
if (paisViewModel == null)
{
return(HttpNotFound());
}
ModelState.AddModelError("", string.Format("Ocorreu um Erro na Busca do Pais com Id = {0}\n Erro: {1}", id, ex.Message));
return(View(paisViewModel));
}
finally
{
uow.Dispose();
}
}
public ActionResult Create([Bind(Include = "Id,Codigo,Nome")] PaisViewModel paisViewModel)
{
if (ModelState.IsValid)
{
try
{
paisViewModel.Id = Guid.NewGuid();
Pais pais = new Pais();
pais = Mapper.Map <Pais>(paisViewModel);
pais.TimesTamp = DateTime.Now;
uow.PaisRepositorio.Adcionar(pais);
uow.Commit();
TempData["mensagem"] = string.Format("{0} : Foi Incluido com Sucesso", pais.Nome);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("Erro ao Cadastrar Pais:\n {0}", ex.Message));
IEnumerable <PaisViewModel> lista = Mapper.Map <IEnumerable <PaisViewModel> >(uow.PaisRepositorio.GetTudo());
ViewBag.ListaPais = lista;
return(View());
}
finally
{
uow.Dispose();
}
}
return(View(paisViewModel));
}
public IActionResult Detail(int?id)
{
var paisVM = new PaisViewModel();
try
{
if (id == null)
{
return(View("Error"));
}
var paisDB = _paisService.GetProvinciaByPais(id);
paisVM = new PaisViewModel
{
Pais = paisDB
};
}
catch (Exception)
{
return(View("Error"));
}
return(View(paisVM));
}
public IActionResult Edit(int?id)
{
var paisVM = new PaisViewModel();
try
{
if (id == null)
{
return(View("Error"));
}
var paisDB = _paisService.GetPais(id);
if (paisDB == null)
{
return(View("Error"));
}
paisVM = new PaisViewModel
{
Pais = paisDB
};
}
catch (Exception)
{
throw;
}
return(View(paisVM));
}
public IActionResult Edit(int id, PaisViewModel model)
{
if (id != model.Pais.Id)
{
return(View("Error"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var paisDB = _paisService.GetPais(id);
if (paisDB == null)
{
return(View("Error"));
}
paisDB.Name = model.Pais.Name;
paisDB.Continente = model.Pais.Continente;
_paisService.Edit(paisDB);
return(RedirectToAction(nameof(Index)));
}
public PaisView()
{
InitializeComponent();
vm = new PaisViewModel();
BindingContext = vm;
}
public ActionResult Edit(int id, PaisViewModel paisViewModel)
{
paisViewModel.PaisId = id;
var paisEntidade = Mapper.Map <PaisViewModel, Pais>(paisViewModel);
_paisAppServico.Atualizar(paisEntidade);
return(RedirectToAction("Index"));
}
public JsonResult ObtenerPaises(PaisViewModel f)
{
using (var client = new IntranetEntities())
{
var res = client.spObtenerPaises(f.Activo, f.Nombre, f.Codigo, f.PaisID).ToList();
return(Json(res, JsonRequestBehavior.AllowGet));
}
}
public ActionResult CrearPais()
{
var pais = new PaisViewModel
{
Inactivo = false
};
return(View("CrearEditarPais", pais));
}
public async Task <IActionResult> Create(PaisViewModel paisViewModel)
{
Pais NewPais = new Pais(paisViewModel.Nome);
_context.Add(NewPais);
await _context.SaveChangesAsync();
return(Ok());
}
public void Destroy(PaisViewModel obj)
{
var entity = entities.Paises.FirstOrDefault(c => c.Id == obj.Id);
if (entity != null)
{
entities.Delete(entity);
entities.SaveChanges();
}
}
public async Task <IActionResult> PutPaises(int id, [FromBody] PaisViewModel paisViewModel)
{
var entity = await this.context.Set <Paises>().FindAsync(id);
entity.NombrePais = paisViewModel.NombrePais;
this.context.Entry(entity).State = EntityState.Modified;
await this.context.SaveChangesAsync();
return(Ok(entity));
}
public PaisPresenter(IPaisView view, IPaisDao paisDao)
{
m_view = view;
m_paisDao = paisDao;
PaisDataEntity paisDataEntity = m_paisDao.crearPaisDataEntity();
PaisViewModel paisViewModel = new PaisViewModel(paisDataEntity);
m_viewModel = paisViewModel;
m_view.ShowPais(paisViewModel);
}
public void Update(PaisViewModel obj)
{
var entity = entities.Paises.FirstOrDefault(c => c.Id == obj.Id);
if (entity != null)
{
entity.Nombre = obj.Nombre;
entity.Codigo = obj.Codigo;
entities.SaveChanges();
}
}
public ActionResult Create(PaisViewModel paisViewModel)
{
if (ModelState.IsValid)
{
var paisEntidade = Mapper.Map <PaisViewModel, Pais>(paisViewModel);
_paisAppServico.Adicionar(paisEntidade);
return(RedirectToAction("Index"));
}
return(View(paisViewModel));
}
public async Task <int> AddAsync(PaisViewModel paisViewModel)
{
var response = await _httpClient.PostAsJsonAsync(string.Empty, paisViewModel);
response.EnsureSuccessStatusCode();
var paisesJsonDeserialized = await response.Content.ReadAsStringAsync();
var id = int.Parse(paisesJsonDeserialized);
return(id);
}
public ActionResult Edit(PaisViewModel pais)
{
if (ModelState.IsValid)
{
var paisDomain = Mapper.Map <PaisViewModel, Pais>(pais);
_paisApp.Update(paisDomain);
return(RedirectToAction("Index"));
}
return(View(pais));
}
public void Create(PaisViewModel obj)
{
var entity = new Paise();
entity.Nombre = obj.Nombre;
entity.Fechacreacion = DateTime.Now;
entity.Codigo = obj.Codigo;
entities.Add(entity);
entities.SaveChanges();
obj.Id = entity.Id;
}
public TbSePais ViewModelToDomain(PaisViewModel officeViewModel)
{
return(new TbSePais
{
Id = officeViewModel.Id,
NombreEs = officeViewModel.NombreEs,
NombreEn = officeViewModel.NombreEn,
Inactivo = officeViewModel.Inactivo,
GentilicioEs = officeViewModel.GentilicioEs,
GentilicioEn = officeViewModel.GentilicioEn,
Iniciales = officeViewModel.Iniciales
}); //paisService.GetPaisById(officeViewModel.Id);
}
public JsonResult AgregarPais(PaisViewModel f)
{
var Pais = f.MapToModel(f);
Pais.UsuarioID = ((UsuarioWeb)Session["UsuarioWeb"]).Usuario.UsuarioID;
using (var client = new IntranetEntities())
{
var res = client.spAgregarPais(Pais.Nombre, Pais.Codigo, Pais.Moneda, Pais.CodMoneda, Pais.UsuarioID);
return(Json(res, JsonRequestBehavior.AllowGet));
}
}
public TbSePais ViewModelToDomain(PaisViewModel officeViewModel)
{
var domain = paisService.GetPaisById(officeViewModel.Id);
domain.NombreEs = officeViewModel.NombreEs;
domain.NombreEn = officeViewModel.NombreEn;
domain.Inactivo = officeViewModel.Inactivo;
domain.GentilicioEs = officeViewModel.GentilicioEs;
domain.GentilicioEn = officeViewModel.GentilicioEn;
domain.Iniciales = officeViewModel.Iniciales;
return(domain);
}
// GET: PaisViewModels/Edit/5
public ActionResult Edit(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PaisViewModel paisViewModel = Mapper.Map <PaisViewModel>(uow.PaisRepositorio.Get(pais => pais.Id == id));
if (paisViewModel == null)
{
return(HttpNotFound());
}
return(View(paisViewModel));
}
private void RemoveFileFromStream(PaisViewModel paisViewModel)
{
if (paisViewModel.ImageUri != null)
{
string pastaFotos = Path.Combine(_webHostEnvironment.WebRootPath, "Assets", "Imagens");
string caminhoArquivo = Path.Combine(pastaFotos, paisViewModel.ImageUri);
if (System.IO.File.Exists(caminhoArquivo))
{
System.IO.File.Delete(caminhoArquivo);
}
}
}
