public string ProvidersTable(int year, int origenData, int orden)
{
ProveedorModel proveedorModel = new ProveedorModel();
proveedorModel.ListaCompleta(db, year, origenData, orden);
return(proveedorModel.JsonTabla);
}
public bool ActualizarProveedor(ProveedorModel proveedorModel)
{
bool succes = true;
data.ActualizarProveedor(proveedorModel);
return(succes);
}
/// <summary>
/// Crea una nueva instancia de ModifyItemStatus y se pasa asi mismo como parámetro y el item seleccionado
/// </summary>
/// <returns></returns>
public ModifyProveedorViewModel CreateModifyProveedorViewModel()
{
ProveedorModel proveedorModel = new ProveedorModel(new ProveedorDataMapper(), this.ActualUser);
if (this._proveedorModel != null && this._proveedorModel.SelectedProveedor != null)
{
proveedorModel.Calle = this._proveedorModel.SelectedProveedor.CALLE;
proveedorModel.CodigoPostal = this._proveedorModel.SelectedProveedor.CODIGO_POSTAL;
proveedorModel.Contacto = this._proveedorModel.SelectedProveedor.CONTACTO;
proveedorModel.Mail = this._proveedorModel.SelectedProveedor.MAIL;
proveedorModel.ProveedorName = this._proveedorModel.SelectedProveedor.PROVEEDOR_NAME;
proveedorModel.RFC = this._proveedorModel.SelectedProveedor.RFC;
proveedorModel.Tel1 = this._proveedorModel.SelectedProveedor.TEL1;
proveedorModel.Tel2 = this._proveedorModel.SelectedProveedor.TEL2;
proveedorModel.Ciudad = this._proveedorModel.SelectedProveedor.Ciudad;
proveedorModel.Pais = this._proveedorModel.SelectedProveedor.Pais;
proveedorModel.UnidProveedor = this._proveedorModel.SelectedProveedor.UNID_PROVEEDOR;
}
try
{
return(new ModifyProveedorViewModel(this, proveedorModel));
}
catch (Exception ex)
{
return(null);
}
}
public void POST([FromBody] ProveedorModel value)
{
try
{
var proveedor = db.ARPROVEEDOR.Where(q => q.CODIGO == value.CODIGO).FirstOrDefault();
if (proveedor != null)
{
proveedor.DURACION = value.DURACION;
}
db.SaveChanges();
}
catch (Exception ex)
{
long ID = db.APP_LOGERROR.Count() > 0 ? (db.APP_LOGERROR.Select(q => q.SECUENCIA).Max() + 1) : 1;
db.APP_LOGERROR.Add(new APP_LOGERROR
{
ERROR = string.IsNullOrEmpty(ex.Message) ? string.Empty : ex.Message.Substring(0, 1000),
INNER = string.IsNullOrEmpty(ex.InnerException.Message) ? string.Empty : ex.InnerException.Message.Substring(0, 1000),
FECHA = DateTime.Now,
PROCESO = "Proveedor/POST",
SECUENCIA = ID
});
db.SaveChanges();
}
}
public ActionResult Ver(int id = -1)
{
ProveedorModel model = null;
try
{
using (ArtexConnection db = new ArtexConnection())
{
ProveedorDAO CLDAO = new ProveedorDAO();
var entity = CLDAO.GetById(id, db);
if (entity != null)
{
model = new ProveedorModel();
CopiarEntidadModelo(ref model, entity, db);
}
ViewBag.Editar = false;
return(View(VER_ABSOLUTE_PATH, model));
}
}
catch (Exception e)
{
LogUtil.ExceptionLog(e);
}
return(View(ABSOLUTE_PATH));
}
//
public ActionResult Editar(int id = -1)
{
ProveedorModel model = null;
if (id > 0)
{
try
{
using (ArtexConnection db = new ArtexConnection())
{
ProveedorDAO CLDAO = new ProveedorDAO();
var entity = CLDAO.GetById(id, db);
if (entity != null)
{
model = new ProveedorModel();
CopiarEntidadModelo(ref model, entity, db);
ViewBag.Editar = true;
return(View(CREAR_EDITAR_ABSOLUTE_PATH, model));
}
}
}
catch (Exception e)
{
LogUtil.ExceptionLog(e);
}
}
return(RedirectToAction("Index"));
}
//
// GET: /CatalogoCliente/NuevoCliente/
public ActionResult Create()
{
ProveedorModel model = null;
try
{
using (ArtexConnection db = new ArtexConnection())
{
model = new ProveedorModel();
model.esPersonaFisica = true;
model.Activo = true;
model.paisList = PaisDAO.GetAlls(db);
model.pais = model.paisList.FirstOrDefault(m => m.NOMBRE.Contains("Mex")).ID;
model.estadoList = EstadoDAO.GetByIdPais((int)model.pais, db);
model.estado = model.estadoList.FirstOrDefault(m => m.NOMBRE.Contains("Jalis")).ID;
model.bancosList = BancoDAO.GetAlls();
}
}
catch (Exception e)
{
LogUtil.ExceptionLog(e);
model = null;
}
ViewBag.Editar = true;
return(View(CREAR_EDITAR_ABSOLUTE_PATH, model));
}
public bool EditarProveedor(ProveedorModel proveedorModel)
{
SqlCommand cmd = null;
bool prueba;
cmd = new SqlCommand("update Proveedores set nombreProveedor=@nombreProveedor,telefono=@telefono,celular=@celular,direccion=@direccion" +
" where codigo= @codigo", conectar.conn);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@codigo", proveedorModel.Codigo));
cmd.Parameters.Add(new SqlParameter("@nombreProveedor", proveedorModel.NombreProveedor));
cmd.Parameters.Add(new SqlParameter("@telefono", proveedorModel.Telefono));
cmd.Parameters.Add(new SqlParameter("@celular", proveedorModel.Celular));
cmd.Parameters.Add(new SqlParameter("@direccion", proveedorModel.Direccion));
conectar.abrir();
int resultado = cmd.ExecuteNonQuery();
cmd = null;
conectar.cerrar();
if (resultado > 0)
{
prueba = true;
}
else
{
prueba = false;
}
return(prueba);
}
public bool GuardarProveedor(ProveedorModel proveedorModel)
{
SqlCommand cmd = null;
bool prueba;
cmd = new SqlCommand(" insert into Proveedores(nombreProveedor,telefono,celular,direccion)" +
" values (@nombreProveedor,@telefono,@celular,@direccion)", conectar.conn);
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@nombreProveedor", proveedorModel.NombreProveedor));
cmd.Parameters.Add(new SqlParameter("@telefono", proveedorModel.Telefono));
cmd.Parameters.Add(new SqlParameter("@celular", proveedorModel.Celular));
cmd.Parameters.Add(new SqlParameter("@direccion", proveedorModel.Direccion));
conectar.abrir();
int resultado = cmd.ExecuteNonQuery();
cmd = null;
conectar.cerrar();
if (resultado > 0)
{
prueba = true;
}
else
{
prueba = false;
}
return(prueba);
}
public bool InsertarProveedor(ProveedorModel vendedorModel)
{
bool succes = true;
using (var cn = GetConnection())
{
cn.Open();
using (var comm = new SqlCommand())
{
comm.Connection = cn;
comm.CommandText = @"INSERT INTO dbo.Proveedor(ProveedorId, Proveedor, Contacto, Correo, Telefono1, Telefono2, Creado, Modificado)
VALUES(NEWID(), @Proveedor, @Contacto, @Correo, @Telefono1, @Telefono2, GETDATE(), GETDATE())";
try
{
comm.Parameters.AddWithValue("@Proveedor", vendedorModel.Proveedor);
comm.Parameters.AddWithValue("@Contacto", vendedorModel.Contacto);
comm.Parameters.AddWithValue("@Correo", vendedorModel.Correo);
comm.Parameters.AddWithValue("@Telefono1", vendedorModel.Telefono1);
comm.Parameters.AddWithValue("@Telefono2", vendedorModel.Telefono2);
comm.CommandType = CommandType.Text;
comm.ExecuteNonQuery();
}
catch (Exception ex)
{
succes = false;
}
}
}
return(succes);
}
public bool InsertarProveedor(ProveedorModel proveedorModel)
{
bool succes = true;
succes = data.InsertarProveedor(proveedorModel);
return(succes);
}
public ProveedorViewModel(ProveedorModel model)
{
apiService = new ApiService();
GetProveedor(model);
Duracion = model.Duracion == null ? 0 : Convert.ToDecimal(model.Duracion);
IsEnabled = true;
}
public List <ProveedorModel> TablaProveedores()
{
try
{
string Query = ("SELECT * FROM Vst_Lista_Proveedores");
var Resultado = _oConexionDAL.TablaConnsulta(Query);
List <ProveedorModel> Proveedores = new List <ProveedorModel>();
foreach (DataRow proveedor in Resultado.Rows)
{
var _oProveedorModel = new ProveedorModel()
{
IdProveedor = int.Parse(proveedor[0].ToString()),
NombreProv = proveedor[1].ToString(),
TelefonoProv = proveedor[2].ToString(),
CorreoProv = proveedor[3].ToString(),
FechaRegistroProv = Convert.ToDateTime(proveedor[4].ToString()),
StatusProv = Convert.ToBoolean(proveedor[5].ToString())
};
Proveedores.Add(_oProveedorModel);
}
return(Proveedores);
}
catch (Exception)
{
return(null);
}
}
public ProveedorNewViewModel(FacadeProvider facadeProvider, ProveedorModel proveedor, Action closeAction) : base(facadeProvider)
{
SaveProveedorComand = new SaveProveedorCommand(this);
UpdateProveedorComand = new UpdateProveedorCommand(this);
Proveedor = proveedor;
CloseAction = closeAction;
}
public async Task <Unit> Handle(RunPut request, CancellationToken cancellationToken)
{
var proveedor = await _proveedorRepository.Get(request.ProveedorId);;
if (proveedor == null)
{
throw new ManejadorError(HttpStatusCode.NotFound, new { mensaje = "No se encontro el proveedor" });
}
var proveedorModel = new ProveedorModel
{
ProveedorId = request.ProveedorId,
NombreProveedor = request.NombreProveedor ?? proveedor.NombreProveedor,
Telefono = request.Telefono ?? proveedor.Telefono,
Direccion = request.Direccion ?? proveedor.Direccion
};
var result = await _proveedorRepository.Put(proveedorModel);
if (result > 0)
{
return(Unit.Value);
}
throw new Exception("No se pudo actualizar el proveedor");
}
protected virtual void InitPedidoToAddObjects()
{
PrecioProveedor = 0;
Abono = 0;
//Identificador = "";
Proveedor = new ProveedorModel();
}
public ActionResult WSFactura()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <t_Tipo, TipoModel>();
});
List <FacturaModel> modelList = new List <FacturaModel>();
IMapper iMapper = config.CreateMapper();
COMPUTERMANAGEMENT_TestEntities _context = new COMPUTERMANAGEMENT_TestEntities();
List <t_Factura> usuariosT = new List <t_Factura>();
usuariosT = _context.t_Factura.ToList();
foreach (t_Factura userActual in usuariosT)
{
FacturaModel factM = new FacturaModel();
ProveedorModel provM = new ProveedorModel();
provM.IdProveedor = userActual.t_Proveedor.IdProveedor;
provM.Proveedor = userActual.t_Proveedor.Proveedor;
factM.IdFactura = userActual.IdFactura;
factM.Factura = userActual.Factura;
factM.Fecha = userActual.Fecha;
factM.Garantia = userActual.Garantia;
factM.ProveedorM = provM;
modelList.Add(factM);
}
return(Json(modelList, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> PutProveedorModel(int id, ProveedorModel proveedorModel)
{
if (id != proveedorModel.Id)
{
return(BadRequest());
}
_context.Entry(proveedorModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProveedorModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <ProveedorModel> > PostProveedorModel(ProveedorModel proveedorModel)
{
_context.Proveedores.Add(proveedorModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProveedorModel", new { id = proveedorModel.Id }, proveedorModel));
}
public ActionResult Create(ProveedorModel pro)
{
try
{
if (ModelState.IsValid)
{
if (proveedor.registrarProveedor(pro))
{
Session["response"] = "Registro Existoso";
return(RedirectToAction("index", "Dashboard"));
}
else
{
ViewBag.response = "Error registro invalido";
return(View());
}
}
else
{
return(RedirectToAction("Create"));
}
}
catch
{
ViewBag.response = "Error registro invalido";
return(View());
}
}
public ActionResult Factura(FacturaModel model)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <FacturaModel, t_Factura>();
});
IMapper iMapper = config.CreateMapper();
var source = model;
var destination = iMapper.Map <FacturaModel, t_Factura>(source);
COMPUTERMANAGEMENT_TestEntities _context = new COMPUTERMANAGEMENT_TestEntities();
var addfactura = _context.t_Factura.Add(destination);
_context.SaveChanges();
List <FacturaModel> modelList = new List <FacturaModel>();
var data = _context.t_Factura.ToList();
foreach (t_Factura facturaActual in data)
{
FacturaModel facturaM = new FacturaModel();
ProveedorModel proveedorM = new ProveedorModel();
proveedorM.IdProveedor = facturaActual.t_Proveedor.IdProveedor;
proveedorM.Proveedor = facturaActual.t_Proveedor.Proveedor;
facturaM.IdFactura = facturaActual.IdFactura;
facturaM.Factura = facturaActual.Factura;
facturaM.Fecha = facturaActual.Fecha;
facturaM.Garantia = facturaActual.Garantia;
facturaM.ProveedorM = proveedorM;
modelList.Add(facturaM);
}
return(View("FacturaList", modelList));
}
public ActionResult Editar(ProveedorModel modelo)
{
int codigoError = 0;
String tipoMensajeError = String.Empty;
String mensajeErrorTecnico = String.Empty;
String mensajeErrorUsuario = String.Empty;
Byte?codigo = modelo.CodigoProveedor;
if (codigo == null || codigo == 0)
{
modelo = modelo.Ingresar();
if (modelo.CodigoError == 0)
{
codigoError = 0;
tipoMensajeError = EtiquetasUtility.VARI_SIS_GLOB_TIPO_MENSAJE_CONFIRMACION;
mensajeErrorUsuario = EtiquetasUtility.MENC_SIS_GLOB_INGRESO_CONFIRMACION;
mensajeErrorTecnico = String.Empty;
}
else
{
codigoError = modelo.CodigoError;
tipoMensajeError = EtiquetasUtility.VARI_SIS_GLOB_TIPO_MENSAJE_ERROR;
mensajeErrorUsuario = EtiquetasUtility.MENE_SIS_GLOB_INGRESO_ERROR;
mensajeErrorTecnico = modelo.MensajeErrorTecnico;
}
codigo = 0;
}
else
{
modelo = modelo.Editar();
if (modelo.CodigoError == 0)
{
codigoError = 0;
tipoMensajeError = EtiquetasUtility.VARI_SIS_GLOB_TIPO_MENSAJE_CONFIRMACION;
mensajeErrorUsuario = EtiquetasUtility.MENC_SIS_GLOB_EDICION_CONFIRMACION;
mensajeErrorTecnico = String.Empty;
}
else
{
codigoError = modelo.CodigoError;
tipoMensajeError = EtiquetasUtility.VARI_SIS_GLOB_TIPO_MENSAJE_ERROR;
mensajeErrorUsuario = EtiquetasUtility.MENE_SIS_GLOB_EDICION_ERROR;
mensajeErrorTecnico = modelo.MensajeErrorTecnico;
}
}
return(RedirectToAction("Editar", new RouteValueDictionary {
{ "controller", "Proveedor" },
{ "action", "Editar" },
{ "codigoProveedor", codigo },
{ "codigoError", codigoError },
{ "tipoMensajeError", tipoMensajeError },
{ "mensajeErrorUsuario", mensajeErrorUsuario },
{ "mensajeErrorTecnico", mensajeErrorTecnico }
}));
}
private async void GetProveedor(ProveedorModel model)
{
IsEnabled = false;
try
{
Response con = await apiService.CheckConnection(Settings.UrlConexionActual);
if (!con.IsSuccess)
{
string UrlDistinto = Settings.UrlConexionActual == Settings.UrlConexionExterna ? Settings.UrlConexionInterna : Settings.UrlConexionExterna;
con = await apiService.CheckConnection(UrlDistinto);
if (!con.IsSuccess)
{
this.IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"Alerta",
con.Message,
"Aceptar");
return;
}
else
{
Settings.UrlConexionActual = UrlDistinto;
}
}
var response_pro = await apiService.GetObject <ProveedorModel>(Settings.UrlConexionActual, Settings.RutaCarpeta, "Proveedor", "CODIGO=" + model.Codigo);
if (!response_pro.IsSuccess)
{
await Application.Current.MainPage.DisplayAlert(
"Alerta",
response_pro.Message,
"Aceptar");
return;
}
var prov = (ProveedorModel)response_pro.Result;
if (prov != null)
{
model.DuracionAcumulada = prov.DuracionAcumulada;
}
Proveedor = model;
IsEnabled = true;
}
catch (Exception ex)
{
IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"Alerta",
ex.Message,
"Aceptar");
return;
}
}
public ActionResult EditarProveedor(ProveedorModel model)
{
if (Request.Cookies["user_login"] != null)
{
Conexiones.Conexion conexion_now = new Conexiones.Conexion();
if (conexion_now.valid_cookie(Request.Cookies["user_login"].Value))
{
Funciones.Funciones funcion = new Funciones.Funciones();
string respuesta = "";
if (ModelState.IsValid)
{
int id_proveedor = model.id_proveedor;
string nombre_empresa = model.nombre_empresa;
string direccion = model.direccion;
int telefono = model.telefono;
if (funcion.valid_number(id_proveedor.ToString()) && nombre_empresa != "" && direccion != "" && funcion.valid_number(telefono.ToString()))
{
if (conexion_now.comprobar_existencia_proveedor_editar(id_proveedor, nombre_empresa))
{
respuesta = "El proveedor " + nombre_empresa + " ya existe";
}
else
{
if (conexion_now.editarProveedor(id_proveedor, nombre_empresa, direccion, telefono))
{
respuesta = "El proveedor ha sido editado exitosamente";
}
else
{
respuesta = "Ha ocurrido un error en la base de datos";
}
}
}
else
{
respuesta = "Los datos ingresados en el formulario son invalidos";
}
}
else
{
respuesta = "Los datos ingresados en el formulario son invalidos";
}
ViewBag.estado = 1;
ViewBag.mensaje = respuesta;
ViewBag.Title = "Proveedores";
return(View("Proveedores", model));
}
else
{
return(RedirectToAction("LogOn", "Login"));
}
}
else
{
return(RedirectToAction("LogOn", "Login"));
}
}
public string ProvidersDetalle(int IdNivel1, int origenData)
{
ProveedorModel proveedorModel = new ProveedorModel();
proveedorModel.ListaDetalle(db, IdNivel1, origenData);
return(proveedorModel.JsonDetalle);
}
public AddFacturaArticuloViewModel(IFacturaViewModel factura)
{
if (factura != null && factura.SelectedProveedor != null)
{
this._Proveedor = factura.SelectedProveedor;
}
this._AddFacturaViewModel = factura;
this.init(factura);
}
//****************PROVEEDORES****************//
//****************************************//
public string Providers(int year, int origenData)
{
var idMunicipality = GetCurrentIdMunicipality();
var takeElements = 20;
ProveedorModel proveedorModel = new ProveedorModel();
proveedorModel.WordCloud(db, takeElements, year, origenData);
return(proveedorModel.JsonProveedor);
}
public int Agregar(object Obj)
{
ProveedorModel _oModel = (ProveedorModel)Obj;
SqlCommand Cmd = new SqlCommand("EXEC SP_Agregar_Proveedor @NombreProv,@TelefonoProv,@CorreoProv");
Cmd.Parameters.Add("@NombreProv", SqlDbType.VarChar).Value = _oModel.NombreProv;
Cmd.Parameters.Add("@TelefonoProv", SqlDbType.VarChar).Value = _oModel.TelefonoProv;
Cmd.Parameters.Add("@CorreoProv", SqlDbType.VarChar).Value = _oModel.CorreoProv;
Cmd.CommandType = CommandType.Text;
return(_oConexionDAL.EjecutarSQL(Cmd));
}
public AddFacturaArticuloViewModel(AgregarItemViewModel vm, bool b)
{
this.VM = vm;
ProveedorModel p = new ProveedorModel(null);
p.UnidProveedor = VM.ItemModel.Proveedor.UNID_PROVEEDOR;
this._Proveedor = p;
this.init();
}
public async Task <IActionResult> Insert(ProveedorModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var proveedor = _mapper.Map <ProveedorDto>(model);
await _proveedorRepositorio.Insertar(proveedor);
return(Ok(model));
}
