public async Task <IActionResult> Proveedor([FromBody] ProveedorDTO proveedorDTO)
{
if (proveedorDTO != null && proveedorDTO.Id == 0)
{
var resultado = await proveedorRepositorio.AgregarProveedor(proveedorDTO);
if (resultado == null)
{
return(BadRequest(new ErrorModel()
{
Titulo = "",
ErrorMensaje = "Proveedor ya existe o no puedo crearse",
StatusCode = StatusCodes.Status400BadRequest
}));;
}
return(Ok(resultado));
}
else
{
var resultado = await proveedorRepositorio.ActualizarProveedor(proveedorDTO.Id, proveedorDTO);
if (resultado == null)
{
return(BadRequest(new ErrorModel()
{
Titulo = "",
ErrorMensaje = "Proveedor ya existe o no puedo crearse",
StatusCode = StatusCodes.Status400BadRequest
}));;
}
return(Ok(resultado));
}
}
public async Task <ProveedorDTO> BuscarProveedor(string nombre)
{
ProveedorDTO dtoResult = new ProveedorDTO();
var proveedor = await iProveedoresRepository.BuscarProveedor(nombre);
dtoResult.IdProveedor = proveedor.IdProveedor;
dtoResult.Nombre = proveedor.Nombre;
dtoResult.Direccion = proveedor.Direccion;
dtoResult.Nit = proveedor.Nit;
dtoResult.Telefono = proveedor.Telefono;
dtoResult.UrlServicio = proveedor.UrlServicio;
dtoResult.UrlServicioOrden = proveedor.UrlServicioOrden;
dtoResult.TipoApi = proveedor.TipoApi;
dtoResult.MetodoApi = proveedor.MetodoApi;
dtoResult.MetodoApiOrden = proveedor.MetodoApiOrden;
dtoResult.TransformacionProductos = proveedor.TransformacionProductos;
dtoResult.TransformacionOrdenes = proveedor.TransformacionOrdenes;
dtoResult.SOAPAction = proveedor.SOAPAction;
dtoResult.SOAPActionOrden = proveedor.SOAPActionOrden;
dtoResult.Body = proveedor.Body;
dtoResult.BodyOrden = proveedor.BodyOrden;
dtoResult.Prioridad = proveedor.Prioridad;
dtoResult.Activo = proveedor.Activo;
return(dtoResult);
}
private void btnGuardar_Click(object sender, EventArgs e)
{
//crear un nuevo proveedor
//llenarlo con los datos de las cajas (la id_proveedor puede ser solo lectura o no visible
//mandas la modificación
//vacias las cajas
//solo hacerlo si las cajas estan llenas
if (txtId.Text != "" && txtNombre.Text != "" && txtTelefono.Text != "")
{
if (_prov == null)
{
_prov = new ProveedorDTO()
{
idProveedor = Convert.ToInt32(txtId.Text),
nombreProveedor = txtNombre.Text,
telefono = txtTelefono.Text
};
if (MessageBox.Show("¿Está seguro que quiere modificar este registro?", titulo, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
_provManager.ModificarProveedor(_prov);
txtId.Clear();
txtNombre.Clear();
txtTelefono.Clear();
dgvProveedor.ClearSelection();
dgvProveedor.DataSource = _provManager.Proveedores.ToList();
btnEliminar.Visible = true;
}
}
}
}
private void btnGuardar_Click(object sender, EventArgs e)
{
try
{
if (_prov == null && txtTelefono.Text.Length == 10)
{
_prov = new ProveedorDTO()
{
nombreProveedor = txtNombre.Text,
telefono = txtTelefono.Text
};
if (_provManager.InsertarProveedor(_prov))
{
MessageBox.Show("Proveedor registrado corectamente", titulo, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Proveedor no registrado", titulo, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
txtNombre.Clear();
txtTelefono.Clear();
}
else if (txtTelefono.Text.Length > 0 || txtTelefono.Text.Length < 0)
{
MessageBox.Show("El teléfono debe contener 10 digitos", titulo, MessageBoxButtons.OK, MessageBoxIcon.Warning);
txtTelefono.Clear();
txtTelefono.Focus();
}
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message, titulo, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void ListarUbigeo(ProveedorDTO proveedor)
{
Dictionary <string, object> parameters = new Dictionary <string, object>();
List <PaisDTO> paisDTOList = _paisService.SearchFor(parameters, string.Empty);
ViewBag.PaisList = WebHelper.ToSelectListItem <PaisDTO>(
paisDTOList, x => x.PaisId.ToString(), x => x.Nombre, SelectListFirstElementType.Select, string.Empty);
parameters.Add("paisId", proveedor.DistritoDTO.ProvinciaDTO.DepartamentoDTO.PaisId);
List <DepartamentoDTO> departamentoDTOList = _departamentoService.SearchFor(parameters, string.Empty);
ViewBag.DepartamentoList = WebHelper.ToSelectListItem <DepartamentoDTO>(
departamentoDTOList, x => x.DepartamentoId.ToString(), x => x.Nombre, SelectListFirstElementType.Select, string.Empty);
parameters.Add("departamentoId", proveedor.DistritoDTO.ProvinciaDTO.DepartamentoId);
List <ProvinciaDTO> provinciaDTOList = _provinciaService.SearchFor(parameters, string.Empty);
ViewBag.ProvinciaList = WebHelper.ToSelectListItem <ProvinciaDTO>(
provinciaDTOList, x => x.ProvinciaId.ToString(), x => x.Nombre, SelectListFirstElementType.Select, string.Empty);
parameters.Add("provinciaId", proveedor.DistritoDTO.ProvinciaId);
List <DistritoDTO> distritoDTOList = _distritoService.SearchFor(parameters, string.Empty);
ViewBag.DistritoList = WebHelper.ToSelectListItem <DistritoDTO>(
distritoDTOList, x => x.DistritoId.ToString(), x => x.Nombre, SelectListFirstElementType.Select, string.Empty);
}
public JsonResult GetById(ProveedorDTO proveedorDTO)
{
var jsonResponse = new JsonResponse {
Success = true
};
try
{
var proveedor = MapperHelper.Map <ProveedorDTO, Proveedor>(proveedorDTO);
var proveedorResult = ProveedorBL.Instancia.GetById(proveedor);
if (proveedorResult != null)
{
proveedorDTO = MapperHelper.Map <Proveedor, ProveedorDTO>(proveedorResult);
jsonResponse.Data = proveedorDTO;
}
else
{
jsonResponse.Warning = true;
jsonResponse.Message = Mensajes.UsuarioNoExiste;
}
}
catch (Exception ex)
{
LogError(ex);
jsonResponse.Success = false;
jsonResponse.Message = Mensajes.IntenteloMasTarde;
}
return(Json(jsonResponse));
}
public IEnumerable <ProveedorDTO> GetAll()
{
var proveedores = _context.Proveedor.Where(x => x.Estado == Constantes.Activo);
var proveedoresDTO = ProveedorDTO.DeModeloADTO(proveedores);
return(proveedoresDTO);
}
public ActionResult EditarProveedor(short?id, ProveedorDTO model)
{
if (Session["StringToken"] == null)
{
return(View(AutenticacionServicio.InitIndex(new LoginModel())));
}
tkn = Session["StringToken"].ToString();
if (id != null)
{
return(RedirectToAction("Proveedor", CatalogoServicio.ActivarEditarProveedor(id.Value, tkn)));
}
else
{
var respuesta = CatalogoServicio.ModificarProveedor(model, tkn);
if (respuesta.Exito)
{
return(RedirectToAction("Proveedores"));
}
else
{
TempData["RespuestaDTO"] = respuesta;
return(RedirectToAction("Proveedor", model));
}
}
}
public ActionResult Create(string editAction, string proveedorId)
{
ProveedorDTO clienteDTO = new ProveedorDTO();
switch (editAction)
{
case EditActionConstant.NEW:
ViewBag.IsNew = true;
ViewBag.Title = "Nuevo Cliente";
clienteDTO.EditAction = editAction;
ListarUbigeo();
break;
case EditActionConstant.EDIT:
ViewBag.IsNew = false;
ViewBag.Title = "Editar Cliente";
clienteDTO = _clienteService.GetById(Convert.ToInt32(proveedorId));
clienteDTO.EditAction = editAction;
ListarUbigeo(clienteDTO);
break;
}
PopulateDropList();
return(PartialView(clienteDTO));
}
internal void Create(ProveedorDTO proveedorDTO)
{
Proveedor proveedor = new Proveedor();
proveedor.NIF = proveedorDTO.NIF;
db.Proveedors.Add(proveedor);
db.SaveChanges();
}
public async Task PutProveedor(int id, ProveedorDTO proveedorFromBody)
{
var proveedor = mapper.Map <Proveedor>(proveedorFromBody);
proveedor.Id = id;
context.Entry(proveedor).State = EntityState.Modified;
await context.SaveChangesAsync();
}
public async Task <Proveedor> PostProveedor(ProveedorDTO proveedorFromBody)
{
var proveedor = mapper.Map <Proveedor>(proveedorFromBody);
context.Proveedores.Add(proveedor);
await context.SaveChangesAsync();
return(proveedor);
}
public ProveedorDTO Create(ProveedorDTO dto)
{
// Mapeamos el dto a la entidad, la añadimos al contexto, guardamos y devolvemos el dto mapeado
var model = _mapper.Map <Proveedor>(dto);
_context.Proveedores.Add(model);
_context.SaveChanges();
return(_mapper.Map <ProveedorDTO>(model));
}
public NuevoProducto()
{
InitializeComponent();
_prodManager = new ProductoManager();
_provManager = new ProveedorManager();
_ent = new EntradaDTO();
_pro = new ProveedorDTO();
_tipoManager = new TipoProductoManager();
}
public ActionResult Create([Bind(Include = "NIF,Empresa,Direccion,Telefono,Fax")] ProveedorDTO proveedor)
{
if (ModelState.IsValid)
{
provServicio.Create(proveedor);
return(RedirectToAction("Index"));
}
return(View(proveedor));
}
public async Task <ProveedorDTO> ObtenerProveedor(int proveedorId)
{
try
{
ProveedorDTO proveedor = mapper.Map <Proveedor, ProveedorDTO>(await db.Proveedores.FirstOrDefaultAsync(p => p.Id == proveedorId));
return(proveedor);
}catch (Exception e)
{
return(null);
}
}
public async Task <ActionResult> Put(int id, [FromBody] ProveedorDTO proveedorFromBody)
{
if (!await proveedorService.ProveedorExists(id))
{
return(NotFound($"El Id {id} no se ha encontrado."));
}
await proveedorService.PutProveedor(id, proveedorFromBody);
return(NoContent());
}
public JsonResult Update(ProveedorDTO proveedorDTO)
{
var jsonResponse = new JsonResponse {
Success = true
};
try
{
var proveedor = MapperHelper.Map <ProveedorDTO, Proveedor>(proveedorDTO);
int resultado = 0;
resultado = ProveedorBL.Instancia.Update(proveedor);
if (resultado > 0)
{
jsonResponse.Title = Title.TitleActualizar;
jsonResponse.Message = Mensajes.ActualizacionSatisfactoria;
}
else
{
jsonResponse.Title = Title.TitleAlerta;
jsonResponse.Warning = true;
jsonResponse.Message = Mensajes.ActualizacionFallida;
}
LogBL.Instancia.Add(new Log
{
Accion = Mensajes.Update,
Controlador = Mensajes.UsuarioController,
Identificador = resultado,
Mensaje = jsonResponse.Message,
Usuario = proveedorDTO.UsuarioRegistro,
Objeto = JsonConvert.SerializeObject(proveedorDTO)
});
}
catch (Exception ex)
{
LogError(ex);
jsonResponse.Success = false;
jsonResponse.Title = Title.TitleAlerta;
jsonResponse.Message = Mensajes.IntenteloMasTarde;
LogBL.Instancia.Add(new Log
{
Accion = Mensajes.Update,
Controlador = Mensajes.UsuarioController,
Identificador = 0,
Mensaje = ex.Message,
Usuario = proveedorDTO.UsuarioRegistro,
Objeto = JsonConvert.SerializeObject(proveedorDTO)
});
}
return(Json(jsonResponse));
}
public async Task <ProveedorDTO> ExisteProveedor(string rut)
{
try
{
ProveedorDTO proveedor = mapper.Map <Proveedor, ProveedorDTO>(await db.Proveedores.FirstOrDefaultAsync(p => p.Rut.ToLower() == rut.ToLower()));
return(proveedor);
}
catch (Exception e)
{
return(null);
}
}
public async Task <ProveedorDTO> AgregarProveedor(ProveedorDTO proveedor)
{
var response = await httpClient.PostAsJsonAsync("/api/Proveedor", proveedor);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var proveedorNuevo = JsonConvert.DeserializeObject <ProveedorDTO>(content);
return(proveedorNuevo);
}
else
{
return(null);
}
}
private void btnEliminar_Click(object sender, EventArgs e)
{
if (_prov == null)
{
_prov = new ProveedorDTO();
_prov.idProveedor = Convert.ToInt32(txtId.Text);
if (MessageBox.Show("¿Está seguro de eliminar este proveedor?", titulo, MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
_provManager.EliminarProveedor(_prov);
txtId.Clear();
txtNombre.Clear();
txtTelefono.Clear();
dgvProveedor.DataSource = _provManager.Proveedores.ToList();
}
}
}
public async Task <ProveedorDTO> AgregarProveedor(ProveedorDTO proveedorDTO)
{
try {
Proveedor proveedor = mapper.Map <ProveedorDTO, Proveedor>(proveedorDTO);
proveedor.Activo = true;
var addProovedor = await db.Proveedores.AddAsync(proveedor);
await db.SaveChangesAsync();
return(mapper.Map <Proveedor, ProveedorDTO>(addProovedor.Entity));
}
catch (Exception e)
{
return(null);
}
}
public async Task <Response> GetById(long id)
{
var proveedor = await _context.Proveedor.FirstOrDefaultAsync(r => r.Id == id);
if (proveedor == null)
{
return(new Response {
Mensaje = "Este Proveedor no existe"
});
}
var data = ProveedorDTO.DeModeloADTO(proveedor);
return(new Response {
Datos = data
});
}
public ActionResult CrearProveedor(ProveedorDTO model)
{
if (Session["StringToken"] == null)
{
return(View(AutenticacionServicio.InitIndex(new LoginModel())));
}
tkn = Session["StringToken"].ToString();
var respuesta = CatalogoServicio.CrearProveedor(model, tkn);
if (respuesta.Exito)
{
return(RedirectToAction("Proveedores"));
}
else
{
TempData["RespuestaDTO"] = respuesta;
return(RedirectToAction("Proveedor", model));
}
}
public IHttpActionResult CreateProveedor(ProveedorDTO proveedorDTO)
{
if (!ModelState.IsValid)
{
log.Error("Formulario con datos incorrectos o insuficientes.");
return(BadRequest());
}
var proveedor = Mapper.Map <ProveedorDTO, Proveedor>(proveedorDTO);
proveedorBL.AddProveedor(proveedor);
proveedorDTO.ID = proveedor.ID;
log.Info("Proveedor creado satisfactoriamente, ID: " + proveedor.ID);
return(Created(new Uri(Request.RequestUri + "/" + proveedor.ID), proveedorDTO));
}
public async Task <IList <ProductoDTO> > BuscarProductos(ProveedorDTO fabricanteEntity)
{
IList <ProductoDTO> objetoLocal = null;
if (fabricanteEntity.TipoApi == "REST")
{
RestClient restClient = new RestClient();
string respuestaJSON = await restClient.MakeRequest
(requestUrlApi : fabricanteEntity.UrlServicio,
JSONRequest : fabricanteEntity.Body,
JSONmethod : fabricanteEntity.MetodoApi,
JSONContentType : "application/json",
msTimeOut : -1);
var routes_list = JsonConvert.DeserializeObject <Dictionary <string, object> >(respuestaJSON);
objetoLocal = await _convertJsonToDto.ConvertToProductList(routes_list, fabricanteEntity.TransformacionProductos);
}
else if (fabricanteEntity.TipoApi == "SOAP")
{
string body = fabricanteEntity.Body;
System.Net.WebHeaderCollection collection = new System.Net.WebHeaderCollection();
collection.Add("SOAPAction", fabricanteEntity.SOAPAction);
collection.Add("Content-Type", "text/xml");
RestClient soapClient = new RestClient();
string respuestaXML = await soapClient.MakeRequest
(requestUrlApi : fabricanteEntity.UrlServicio,
JSONRequest : fabricanteEntity.Body,
JSONmethod : fabricanteEntity.MetodoApi,
JSONContentType : "text/xml",
msTimeOut : -1,
headers : collection);
objetoLocal = await _convertXmlToDto.ConvertToProductList(respuestaXML, fabricanteEntity.TransformacionProductos);
}
return(objetoLocal);
}
public long Insertar(ProveedorDTO Proveedordto)
{
using (var context = new ModeloXCommerceContainer())
{
var ProovedorNueva = new AccesoDatos.Proveedor
{
RazonSocial = Proveedordto.RazonSocial,
Telefono = Proveedordto.Telefono,
Email = Proveedordto.Email,
CondicionIvaId = Proveedordto.CondicionIvaId,
Contacto = Proveedordto.Contacto
};
context.Proveedores.Add(ProovedorNueva);
context.SaveChanges();
return(ProovedorNueva.Id);
}
}
public override bool EjecutarComandoNuevo()
{
if (!VerificarDatosObligatorios())
{
MessageBox.Show(@"Por favor ingrese los campos Obligatorios.", @"Atención", MessageBoxButtons.OK,
MessageBoxIcon.Error);
return(false);
}
var ProveedorNuevo = new ProveedorDTO
{
RazonSocial = txtRazonSocial.Text,
Telefono = txtTelefono.Text,
Email = txtEmail.Text,
CondicionIvaId = ((CondicionIvaDTO)cmbCondicionIva.SelectedItem).Id,
Contacto = txtContacto.Text
};
_proveedorServicio.Insertar(ProveedorNuevo);
return(true);
}
public void Modificar(ProveedorDTO Proveedordto)
{
using (var context = new ModeloXCommerceContainer())
{
var ProveedorModificar = context.Proveedores.FirstOrDefault(x => x.Id == Proveedordto.Id);
if (ProveedorModificar == null)
{
throw new Exception("Ocurrió un error al obtener el Proovedor para modificarlo");
}
ProveedorModificar.RazonSocial = Proveedordto.RazonSocial;
ProveedorModificar.Contacto = Proveedordto.Contacto;
ProveedorModificar.Email = Proveedordto.Email;
ProveedorModificar.CondicionIvaId = Proveedordto.CondicionIvaId;
ProveedorModificar.Telefono = Proveedordto.Telefono;
context.SaveChanges();
}
}
public ActionResult Proveedor(ProveedorDTO model = null)
{
if (Session["StringToken"] == null)
{
return(View(AutenticacionServicio.InitIndex(new LoginModel())));
}
tkn = Session["StringToken"].ToString();
RespuestaDTO Resp = new RespuestaDTO();
ViewBag.EsAdmin = TokenServicio.ObtenerEsAdministracionCentral(tkn);
ViewBag.TipoProveedores = CatalogoServicio.ListaTipoProveedor(tkn);
ViewBag.CuentasContables = CatalogoServicio.ListaCtaCtble(tkn);
ViewBag.Estados = CatalogoServicio.GetEstados(tkn);
ViewBag.Paises = CatalogoServicio.GetPaises(tkn);
ViewBag.Bancos = CatalogoServicio.ListaBanco(tkn);
ViewBag.FormasPago = CatalogoServicio.ListaFormaPago(tkn);
ViewBag.RegimenesFiscales = CatalogoServicio.ObtenerRegimenFiscal(tkn);
ViewBag.TipoPersonas = CatalogoServicio.ObtenerTiposPersona(tkn);
if (TempData["RespuestaDTO"] != null)
{
Resp = (RespuestaDTO)TempData["RespuestaDTO"];
}
if (model != null)
{
if (model.IdProveedor != 0)
{
ViewBag.EsEdicion = true;
}
}
ViewBag.MensajeError = Validar(Resp);
if (ViewBag.EsAdmin)
{
ViewBag.Empresas = CatalogoServicio.Empresas(tkn);
}
else
{
ViewBag.Empresas = CatalogoServicio.Empresas(tkn).SingleOrDefault().NombreComercial;
}
return(View(model));
}
