Example #1
0
        public void EliminarProveedor(ProveedorEntity proveedor)
        {
            try
            {
                using (dbventasEntity context = new dbventasEntity())
                {
                    var connection = context.Database.Connection as SqlConnection;

                    using (connection)
                    {
                        connection.Open();
                        string     Qry = "SP_SET_DELETE_PROVEEDOR";
                        SqlCommand cmd = new SqlCommand(Qry, connection);
                        cmd.CommandType = CommandType.StoredProcedure;
                        cmd.Parameters.Add(new SqlParameter("@codigo", proveedor.idproveedor));
                        cmd.Parameters.Add(new SqlParameter("@estado", proveedor.statu));
                        cmd.ExecuteNonQuery();
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #2
0
        /// <summary>
        /// Realiza la búsqueda de un Proveedor y si no lo encuentra lo registra
        /// </summary>
        /// <param name="filtro">Filtro de búsqueda</param>
        /// <returns>Registro de Proveedor encontrado o registrado</returns>
        public ProcessResult <List <ProveedorResponse> > BuscarRegistrarProveedorContrato(ProveedorRequest filtro)
        {
            ProcessResult <List <ProveedorResponse> > resultado = new ProcessResult <List <ProveedorResponse> >();

            try
            {
                Guid?codigoProveedor = filtro.CodigoProveedor != null ? new Guid(filtro.CodigoProveedor) : (Guid?)null;

                resultado = BuscarProveedor(filtro);

                if (resultado.Result.Count == 0)
                {
                    ProveedorEntity entidad = ProveedorAdapter.RegistrarProveedor(filtro);
                    proveedorEntityRepository.Insertar(entidad);
                    proveedorEntityRepository.GuardarCambios();

                    resultado = BuscarProveedor(new ProveedorRequest {
                        CodigoProveedor = entidad.CodigoProveedor.ToString()
                    });
                }
            }
            catch (Exception e)
            {
                resultado.IsSuccess = false;
                resultado.Exception = new ApplicationLayerException <ProveedorService>(e);
            }

            return(resultado);
        }
Example #3
0
        public async Task <ProveedorEntity> SaveProveedor(ProveedorEntity proveedor)
        {
            string          webApiUrl      = WebApiMethods.SaveProveedor;
            ProveedorEntity supplierResult = await App.HttpTools.HttpPostObjectWithResponseDataAsync <ProveedorEntity, ProveedorEntity>(webApiUrl, proveedor, "Hubo un error el guardar el proveedor").ConfigureAwait(false);

            return(supplierResult);
        }
Example #4
0
 private void saveSupplier()
 {
     if (supplierToSave.idProveedor.Equals(0))
     {
         supplierToSave = _orderPurchasePresenter.SaveProveedor(supplierToSave).Result;
         if (supplierToSave != null && supplierToSave.estatus)
         {
             suppliersList.Add(supplierToSave);
         }
     }
     else
     {
         if (!supplierToSave.estatus)
         {
             suppliersList.Remove(supplierToSave);
             _orderPurchasePresenter.SaveProveedor(supplierToSave);
         }
         else
         {
             supplierToSave = _orderPurchasePresenter.SaveProveedor(supplierToSave).Result;
             suppliersList.Clear();
             suppliersList.AddRange(_orderPurchasePresenter.GetSuppliersWithProducts());
         }
     }
 }
Example #5
0
 private void deactivateSupplierBtn_Click(object sender, RoutedEventArgs e)
 {
     supplierToSave = suppliersGrid.SelectedItem as ProveedorEntity;
     if (supplierToSave != null)
     {
         supplierToSave.estatus = false;
         saveSupplier();
         cleanView();
     }
 }
Example #6
0
 private void cleanView()
 {
     txtNameSupplier.Text       = string.Empty;
     txtRepresentative.Text     = string.Empty;
     txtPhones.Text             = string.Empty;
     txtEmail.Text              = string.Empty;
     txtWeb.Text                = string.Empty;
     txtComments.Text           = string.Empty;
     checkEstatus.IsChecked     = true;
     searchSupplierTextBox.Text = string.Empty;
     supplierToSave             = new ProveedorEntity();
 }
Example #7
0
        private void suppliersGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            DataGrid dataGrid = (DataGrid)sender;

            supplierToSave         = dataGrid.SelectedItem as ProveedorEntity;
            txtNameSupplier.Text   = supplierToSave.nombre;
            txtRepresentative.Text = supplierToSave.representante;
            txtPhones.Text         = supplierToSave.telefonos;
            txtEmail.Text          = supplierToSave.correos;
            txtWeb.Text            = supplierToSave.paginaWeb;
            txtComments.Text       = supplierToSave.comentarios;
            checkEstatus.IsChecked = supplierToSave.estatus;
        }
Example #8
0
        public static bool AddProveedor(string Codigo, string NomEmpresa, string Direccion, string Tel, string Cel, string Descripcion, string Correo)
        {
            ProveedorEntity _ProveedorEntity = new ProveedorEntity();

            _ProveedorEntity.codigo        = Codigo;
            _ProveedorEntity.nombreEmpresa = NomEmpresa;
            _ProveedorEntity.direccion     = Direccion;
            _ProveedorEntity.tel           = Tel;
            _ProveedorEntity.cel           = Cel;
            _ProveedorEntity.descripcion   = Descripcion;
            _ProveedorEntity.correo        = Correo;

            ProveedorAPI _ProveedorAPI = new ProveedorAPI();

            return(_ProveedorAPI.AddProveedor(_ProveedorEntity));
        }
        public async Task <IActionResult> Edit(string id, ProveedorEntity proveedorEntity)
        {
            if (id != proveedorEntity.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Auditoria();
                    _context.Update(proveedorEntity);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateException dbUpdateException)
                {
                    if (dbUpdateException.InnerException.Message.Contains("duplicate"))
                    {
                        if (dbUpdateException.InnerException.Message.Contains("Nombre"))
                        {
                            ModelState.AddModelError(string.Empty, "Ya existe un proveedor con este nombre.");
                        }
                        if (dbUpdateException.InnerException.Message.Contains("NRC"))
                        {
                            ModelState.AddModelError(string.Empty, "Ya existe un proveedor con este NRC.");
                        }
                        if (dbUpdateException.InnerException.Message.Contains("NIT"))
                        {
                            ModelState.AddModelError(string.Empty, "Ya existe un proveedor con este NIT.");
                        }
                    }
                    else
                    {
                        ModelState.AddModelError(string.Empty, dbUpdateException.InnerException.Message);
                    }
                }
                catch (Exception exception)
                {
                    ModelState.AddModelError(string.Empty, exception.Message);
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(proveedorEntity));
        }
Example #10
0
        public ProductDealer(OrderPurchasePresenter orderPurchasePresenter, string supplier, ProveedorEntity supplierToSave)
        {
            InitializeComponent();
            _supplierToSave         = supplierToSave;
            _orderPurchasePresenter = orderPurchasePresenter;
            supplierNametxt.Text    = supplier;
            List <Departamentos> departmentsList = new List <Departamentos>();

            departmentsList.Add(new Departamentos {
                idDepartamento = 0, Descripcion = "TODOS"
            });
            departmentsList.AddRange(_orderPurchasePresenter.GetAllDepartamentos());
            comboDepartmentsProducts.ItemsSource = departmentsList;
            productsDepartmentGrid.ItemsSource   = productsDepartment;
            productsSupplierGrid.ItemsSource     = productsSupplier;
            productsSupplier.AddRange(_supplierToSave.productosWithDepartment);
            comboDepartmentsProducts.SelectedValue = 0;
        }
Example #11
0
        public bool AddProveedor(ProveedorEntity prov)
        {
            var client = new RestClient(RutaBase.direccion);

            client.CookieContainer = new System.Net.CookieContainer();
            var request = new RestRequest("proveedores/", Method.POST);

            // request.RequestFormat = DataFormat.Json;
            request.AddHeader("Authorization", "token " + Credencial.Token);
            var json = request.JsonSerializer.Serialize(prov);

            request.AddParameter("application/json; charset=utf-8", json, ParameterType.RequestBody);

            var response = client.Execute(request);

            if (response.StatusCode == HttpStatusCode.Created)
            {
                return(true);
            }

            if (response.StatusCode == HttpStatusCode.BadRequest)
            {
                msError.ErrorMessage = response.Content.ToString();
                return(false);
            }
            if (response.StatusCode == 0)
            {
                msError.ErrorMessage = "No es posible conectar con el servidor remoto";

                return(false);
            }
            if (response.StatusCode == HttpStatusCode.Unauthorized)
            {
                msError.ErrorMessage = "No esta autorizado";
                return(false);
            }
            if (response.StatusCode == HttpStatusCode.Forbidden)
            {
                msError.ErrorMessage = "Usted no tiene permisos.";
                return(false);
            }
            msError.ErrorMessage = "----Error R21441 ----";
            return(false);
        }
Example #12
0
        //Apartir de esta Linea Empieso con las Buenas Practivas
        /// <summary>
        /// Metodo que Guarda o Actualiza el Proveedor
        /// </summary>
        /// <param name="idproveedor"></param>
        /// <param name="razonsocial"></param>
        /// <param name="NombreProveedor"></param>
        /// <param name="tipodocumento"></param>
        /// <param name="numdocumento"></param>
        /// <param name="direccion"></param>
        /// <param name="telefono"></param>
        /// <param name="email"></param>
        /// <param name="url"></param>
        /// <param name="statu"></param>
        /// <param name="FechaAdiciona"></param>
        /// <param name="FechaModifica"></param>
        /// <param name="UsuarioAdiciona"></param>
        /// <param name="UsuarioModifica"></param>
        /// <returns></returns>
        public bool Registrar_Proveedor(int idproveedor
                                        , string razonsocial
                                        , string NombreProveedor
                                        , string tipodocumento
                                        , string numdocumento
                                        , string direccion
                                        , string telefono
                                        , string email
                                        , string url
                                        , bool statu
                                        , DateTime FechaAdiciona
                                        , DateTime FechaModifica
                                        , string UsuarioAdiciona
                                        , string UsuarioModifica)
        {
            ProveedorEntity p = new ProveedorEntity();

            if (String.IsNullOrWhiteSpace(tipodocumento) || String.IsNullOrWhiteSpace(numdocumento))
            {
                return(false);
            }
            if (String.IsNullOrWhiteSpace(NombreProveedor) || String.IsNullOrWhiteSpace(telefono))
            {
                return(false);
            }
            p.idproveedor     = idproveedor;
            p.razon_social    = razonsocial;
            p.NombreProveedor = NombreProveedor;
            p.tipo_documento  = tipodocumento;
            p.num_documento   = numdocumento;
            p.direccion       = direccion;
            p.telefono        = telefono;
            p.email           = email;
            p.url             = url;
            p.statu           = statu;
            p.FechaAdiciona   = FechaAdiciona;
            p.FechaModifica   = FechaModifica;
            p.UsuarioAdiciona = UsuarioAdiciona;
            p.UsuarioModifica = UsuarioModifica;
            int filasAfectadas = _metodos.Registrar_Proveedor(p);

            return(filasAfectadas > 0 ? true : false);
        }
Example #13
0
        public int Registrar_Proveedor(ProveedorEntity proveedor)
        {
            try
            {
                using (dbventasEntity context = new dbventasEntity())
                {
                    var connection = context.Database.Connection as SqlConnection;

                    using (connection)
                    {
                        connection.Open();
                        string     Qry = "SP_SET_UDATE_INSERT_PROVEEDOR";
                        SqlCommand cmd = new SqlCommand(Qry, connection);
                        cmd.CommandType = CommandType.StoredProcedure;

                        cmd.Parameters.Add(new SqlParameter("@idproveedor", proveedor.idproveedor));
                        cmd.Parameters.Add(new SqlParameter("@razon_social", proveedor.razon_social));
                        cmd.Parameters.Add(new SqlParameter("@NombreProveedor", proveedor.NombreProveedor));
                        cmd.Parameters.Add(new SqlParameter("@tipo_documento", proveedor.tipo_documento));
                        cmd.Parameters.Add(new SqlParameter("@num_documento", proveedor.num_documento));
                        cmd.Parameters.Add(new SqlParameter("@direccion", proveedor.direccion));
                        cmd.Parameters.Add(new SqlParameter("@telefono", proveedor.telefono));
                        cmd.Parameters.Add(new SqlParameter("@email", proveedor.email));
                        cmd.Parameters.Add(new SqlParameter("@url", proveedor.url));
                        cmd.Parameters.Add(new SqlParameter("@statu", proveedor.statu));
                        cmd.Parameters.Add(new SqlParameter("@FechaAdiciona", proveedor.FechaAdiciona));
                        cmd.Parameters.Add(new SqlParameter("@FechaModifica", proveedor.FechaModifica));
                        cmd.Parameters.Add(new SqlParameter("@UsuarioAdiciona", proveedor.UsuarioAdiciona));
                        cmd.Parameters.Add(new SqlParameter("@UsuarioModifica", proveedor.UsuarioModifica));
                        //cmd.Parameters.Add(new SqlParameter("@HostNa", proveedor.HostNa));

                        cmd.ExecuteNonQuery();
                        return(1);
                    }
                }
            }
            catch (Exception ex)
            {
                return(0);

                throw ex;
            }
        }
Example #14
0
        /// <summary>
        /// Realiza la adaptación de campos para registrar o actualizar
        /// </summary>
        /// <param name="data">Datos a registrar o actualizar</param>
        /// <returns>Entidad Proveedor con los datos a registrar</returns>
        public static ProveedorEntity RegistrarProveedor(ProveedorRequest data)
        {
            var proveedorEntity = new ProveedorEntity();

            if (data.CodigoProveedor != null)
            {
                proveedorEntity.CodigoProveedor = new Guid(data.CodigoProveedor.ToString());
            }
            else
            {
                Guid code;
                code = Guid.NewGuid();
                proveedorEntity.CodigoProveedor = code;
            }

            proveedorEntity.CodigoIdentificacion = data.CodigoIdentificacion;
            proveedorEntity.Nombre          = data.Nombre;
            proveedorEntity.NombreComercial = data.Nombre;
            proveedorEntity.TipoDocumento   = data.TipoDocumento;
            proveedorEntity.NumeroDocumento = data.NumeroDocumento;

            return(proveedorEntity);
        }
        public List <ProveedorEntity> ConsultarProveedores()
        {
            List <ProveedorEntity> respuesta = new List <ProveedorEntity>();

            try
            {
                DataSet resultado = GetDataBaseHelper().ExecuteProcedureToDataSet("SP_CONSULTAR_PROVEEDORES");
                foreach (DataRow row in resultado.Tables[0].Rows)
                {
                    ProveedorEntity proveedor = new ProveedorEntity();
                    if (row["CODIGO"] != DBNull.Value)
                    {
                        proveedor.codigo = Convert.ToInt32(row["CODIGO"]);
                    }
                    if (row["NOMBRE"] != DBNull.Value)
                    {
                        proveedor.nombre = row["NOMBRE"].ToString();
                    }
                    if (row["CORREO"] != DBNull.Value)
                    {
                        proveedor.correo = row["CORREO"].ToString();
                    }
                    if (row["TELEFONO"] != DBNull.Value)
                    {
                        proveedor.telefono = row["TELEFONO"].ToString();
                    }
                    respuesta.Add(proveedor);
                }
            }
            catch (Exception exc)
            {
                throw new Exception(exc.Message);
            }

            return(respuesta);
        }
Example #16
0
        public static void ciclo()
        {
            do
            {
                System.Console.WriteLine("Identificando Despachos pendientes");
                List <DespachoEntity>   despachos    = (new DespachoBusiness()).ConsultarDespachos();
                List <CotizacionEntity> cotizaciones = (new CotizacionBusiness()).ConsultarCotizaciones();
                List <ProveedorEntity>  proveedores  = (new ProveedorBusiness()).ConsultarProveedores();
                List <ClientesEntity>   clientes     = (new ClienteBusiness()).ConsultarClientes();

                List <CotizacionEntity> cotizacionesReview = new List <CotizacionEntity>();

                foreach (var despacho in despachos)
                {
                    if (despacho.estado == "PENDIENTE")
                    {
                        int ofertas = 0;
                        foreach (var proveedor in proveedores)
                        {
                            bool oferto = false;
                            foreach (var cotizacion in cotizaciones)
                            {
                                if (cotizacion.codigoProveedor == proveedor.codigo && despacho.codigo == cotizacion.codigoDespacho)
                                {
                                    cotizacionesReview.Add(cotizacion);
                                    oferto = true;
                                }
                            }
                            if (oferto)
                            {
                                ofertas++;
                            }
                        }
                        if (proveedores.Count() == ofertas)
                        {
                            despacho.estado = "ASIGNADO";
                            (new DespachoBusiness()).ActualizarDespacho(despacho);
                            System.Console.WriteLine("Despacho:" + despacho.codigo.ToString() + " :" + despacho.estado);

                            CotizacionEntity menor = null;

                            foreach (var cotizacion in cotizacionesReview)
                            {
                                if (menor == null)
                                {
                                    menor = cotizacion;
                                }
                                if (menor.precio > cotizacion.precio)
                                {
                                    menor = cotizacion;
                                }
                            }
                            foreach (var cotizacion in cotizacionesReview)
                            {
                                if (menor.codigo != cotizacion.codigo)
                                {
                                    cotizacion.estado = "RECHAZADA";
                                    (new CotizacionBusiness()).ActualizarCotizacion(cotizacion);
                                }
                            }
                            menor.estado = "APROBADA";
                            (new CotizacionBusiness()).ActualizarCotizacion(menor);
                            ProveedorEntity proveedorSeleccionado = null;
                            foreach (var proveedor in proveedores)
                            {
                                if (proveedor.codigo == menor.codigoProveedor)
                                {
                                    proveedorSeleccionado = proveedor;
                                }
                            }
                            System.Console.WriteLine("Cotizacion:" + proveedorSeleccionado.nombre + " :" + menor.estado);
                            string texto    = "El proveedor seleccionado para su despacho es: " + proveedorSeleccionado.nombre + " valor:" + menor.precio.ToString();
                            string telefono = string.Empty;

                            foreach (var cliente in clientes)
                            {
                                if (cliente.codigo == despacho.codigoCliente)
                                {
                                    telefono = cliente.telefono;
                                }
                            }

                            controlSMS.Service SMSproxy = new controlSMS.Service();

                            string retorno = SMSproxy.SSA(telefono + "|" + texto + "|[email protected]|");

                            SMSproxy.Dispose();
                        }
                    }
                }
                System.Threading.Thread.Sleep(10000);
            } while (true);
        }
Example #17
0
        /// <summary>
        /// Obtiene la entidad response RequerimientoResponse de la Entidad RequerimientoEntity
        /// </summary>
        /// <param name="objEnt"></param>
        /// <param name="objProv"></param>
        /// <returns>Entidad Requerimiento</returns>
        public static RequerimientoResponse ObtenerRequerimientoResponseDeEntity(RequerimientoEntity objEnt, ProveedorEntity objProv = null)
        {
            RequerimientoResponse rpta = new RequerimientoResponse();

            rpta.CodigoRequerimiento   = objEnt.CodigoRequerimiento;
            rpta.CodigoUnidadOperativa = objEnt.CodigoUnidadOperativa;
            rpta.CodigoProveedor       = objEnt.CodigoProveedor;
            if (objProv != null)
            {
                rpta.NombreProveedor = objProv.Nombre;
            }
            rpta.NumeroRequerimiento = (objEnt.NumeroRequerimiento != null) ? objEnt.NumeroRequerimiento : "";
            rpta.Descripcion         = objEnt.Descripcion;
            //rpta.CodigoTipoServicio = objEnt.CodigoTipoServicio;
            rpta.CodigoTipoRequerimiento = objEnt.CodigoTipoRequerimiento;
            rpta.CodigoTipoDocumento     = objEnt.CodigoTipoDocumento;

            rpta.IndicadorVersionOficial   = objEnt.IndicadorVersionOficial;
            rpta.FechaInicioVigencia       = objEnt.FechaInicioVigencia;
            rpta.FechaFinVigencia          = objEnt.FechaFinVigencia;
            rpta.FechaInicioVigenciaString = objEnt.FechaInicioVigencia.ToString(DatosConstantes.Formato.FormatoFecha);
            rpta.FechaFinVigenciaString    = objEnt.FechaFinVigencia.ToString(DatosConstantes.Formato.FormatoFecha);
            rpta.CodigoMoneda                 = objEnt.CodigoMoneda;
            rpta.MontoRequerimiento           = objEnt.MontoRequerimiento;
            rpta.MontoRequerimientoString     = rpta.MontoRequerimiento.ToString(DatosConstantes.Formato.FormatoNumeroDecimal);
            rpta.MontoAcumulado               = objEnt.MontoAcumulado;
            rpta.MontoAcumuladoString         = rpta.MontoAcumulado.ToString(DatosConstantes.Formato.FormatoNumeroDecimal);
            rpta.CodigoEstado                 = objEnt.CodigoEstado;
            rpta.CodigoPlantilla              = objEnt.CodigoPlantilla;
            rpta.CodigoRequerimientoPrincipal = objEnt.CodigoRequerimientoPrincipal;
            rpta.CodigoEstadoEdicion          = objEnt.CodigoEstadoEdicion;
            rpta.ComentarioModificacion       = objEnt.ComentarioModificacion;
            rpta.RespuestaModificacion        = objEnt.RespuestaModificacion;
            rpta.CodigoFlujoAprobacion        = objEnt.CodigoFlujoAprobacion;
            rpta.CodigoEstadioActual          = objEnt.CodigoEstadioActual;
            rpta.EstadoRegistro               = objEnt.EstadoRegistro;
            rpta.CodigoEstado                 = objEnt.CodigoEstado;
            rpta.NumeroAdendaConcatenado      = objEnt.NumeroAdendaConcatenado;
            rpta.CodigoRequerimientoOriginal  = objEnt.CodigoRequerimientoOriginal;
            rpta.EsFlexible      = objEnt.EsFlexible == null ? false : (bool)objEnt.EsFlexible;
            rpta.EsCorporativo   = objEnt.EsCorporativo == null ? false : (bool)objEnt.EsCorporativo;
            rpta.CodigoRequerido = objEnt.CodigoRequerido.ToString();
            return(rpta);
        }
Example #18
0
 public Task <ProveedorEntity> SaveProveedor(ProveedorEntity proveedor)
 {
     return(_orderPurchaseServices.SaveProveedor(proveedor));
 }
Example #19
0
 public void Registrar_Proveedor(ProveedorEntity proveedor)
 {
     _metodos.Registrar_Proveedor(proveedor);
 }