Beispiel #1
0
        private void Bindear()
        {
            if (usuarioCurrent.Id != 0)
            {
                this.txtNombre.Text         = usuarioCurrent.NombreUsuario;
                this.ddlRoles.SelectedValue = usuarioCurrent.Roles[0].Id.ToString();

                RolDto rol = ServiceFactory.GetSecurityService().ObtenerRol(int.Parse(this.ddlRoles.SelectedValue));
                if (rol.Codigo == FacturaElectronica.Ui.Web.Code.Roles.Administrador)
                {
                    this.pnlCientes.Visible = false;
                }
                else
                {
                    this.pnlCientes.Visible = true;
                    if (usuarioCurrent.ClienteId.HasValue)
                    {
                        ClienteDto clienteDto = ServiceFactory.GetClienteService().ObtenerCliente(usuarioCurrent.ClienteId.Value);
                        this.txtRazonSocial.Text = clienteDto.RazonSocial;
                        this.hfClienteId.Value   = clienteDto.Id.ToString();
                    }
                }
            }
            else
            {
                this.pnlCientes.Visible = false;
            }
        }
Beispiel #2
0
        private void btnPagar_Click(object sender, EventArgs e)
        {
            var TotalAPagar = _factura.Total - _factura.TotalAbonado;

            var facturaId = _factura.Id;

            if (string.IsNullOrEmpty(txtEfectivo.Text))
            {
                Mensaje.Mostrar("Ingrese un valor en el campo efectivo.", Mensaje.Tipo.Informacion);
            }

            else
            {
                if (decimal.Parse(txtEfectivo.Text.Trim()) >= TotalAPagar)
                {
                    var vuelto = decimal.Parse(txtEfectivo.Text.Trim()) - TotalAPagar;

                    _movimientoServicio.EmitirMovimiento(_clienteId, TotalAPagar, TipoMovimiento.Ingreso, facturaId, null);

                    _facturServicio.ModificarEstado(facturaId, TotalAPagar);

                    _clienteServicio.RestarPagoActual(_clienteId, TotalAPagar);

                    _cliente = _clienteServicio.obtenerPorId(_clienteId);

                    if (_cliente.DeudaTotal < 1000m)
                    {
                        _clienteServicio.ActivarParaCompras(_clienteId);
                    }

                    RealizoAlgunaOperacion = true;

                    var form = new _Cliente_CtaCte_EmisionFactura(_factura, TotalAPagar, decimal.Parse(txtEfectivo.Text), vuelto).ShowDialog();

                    Close();
                }

                else
                {
                    _movimientoServicio.EmitirMovimiento(_clienteId, decimal.Parse(txtEfectivo.Text), TipoMovimiento.Ingreso, facturaId, null);

                    _facturServicio.ModificarEstado(facturaId, decimal.Parse(txtEfectivo.Text));

                    _clienteServicio.RestarPagoActual(_clienteId, decimal.Parse(txtEfectivo.Text.Trim()));

                    _cliente = _clienteServicio.obtenerPorId(_clienteId);

                    if (_cliente.DeudaTotal < 1000m)
                    {
                        _clienteServicio.ActivarParaCompras(_clienteId);
                    }

                    RealizoAlgunaOperacion = true;

                    var form = new _Cliente_CtaCte_EmisionFactura(_factura, decimal.Parse(txtEfectivo.Text), decimal.Parse(txtEfectivo.Text), 0m).ShowDialog();

                    Close();
                }
            }
        }
        public override void EjecutarComandoNuevo()
        {
            if (!ValidarEmail(txtMail.Text, error, txtMail))
            {
                MessageBox.Show("Formato de correo Iconrrecto");
                return;
            }

            var nuevoCliente = new ClienteDto
            {
                Apellido          = txtApellido.Text,
                Nombre            = txtNombre.Text,
                Dni               = txtDni.Text,
                Telefono          = txtTelefono.Text,
                Direccion         = txtDomicilio.Text,
                ProvinciaId       = (long)cmbProvincia.SelectedValue,
                DepartamentoId    = (long)cmbDepartamento.SelectedValue,
                LocalidadId       = (long)cmbLocalidad.SelectedValue,
                Mail              = txtMail.Text,
                CondicionIvaId    = (long)cmbCondicionIva.SelectedValue,
                ActivarCtaCte     = chkActivarCuentaCorriente.Checked,
                TieneLimiteCompra = chkLimiteCompra.Checked,
                MontoMaximoCtaCte = nudLimiteCompra.Value,
                Eliminado         = false
            };

            _clienteServicio.Insertar(nuevoCliente);

            LimpiarControles(this);
        }
Beispiel #4
0
        public IHttpActionResult GetClienteByCpf(string cpf)
        {
            try
            {
                var cliente = new ClienteDto();
                cliente = _clienteService.GetClienteByCpf(cpf);

                if (_notifications.Notificacoes.Count > 0)
                {
                    string erros = "";
                    foreach (var erro in _notifications.Notificacoes)
                    {
                        erros = erros + " " + erro;
                    }
                    return(BadRequest(erros));
                }
                else
                {
                    return(Ok(cliente));
                }
            }
            catch (Exception e)
            {
                return(BadRequest($"Ops! algo deu errado! Erro: {e.Message}"));
            }
        }
        private void CargarComprobantesYaAutorizados(FEAuthRequest feAuthRequest, FECAERequest feCAERequest)
        {
            // Agregar comprobantes que fueron autorizados pero que no fueron cargados
            // por problemas en la comunicacion (devolucion de datos por parte de la AFIP)
            FERecuperaLastCbteResponse ultimoCbteAutorizadoAfip = this.ObtenerUltimoComprobanteAutorizado(feAuthRequest, feCAERequest);
            ComprobanteDto             ultimoCbteCargado        = this.ObtenerUltimoComprobanteCargado(feCAERequest);

            if (ultimoCbteCargado == null ||
                ultimoCbteCargado.CbteHasta < ultimoCbteAutorizadoAfip.CbteNro)
            {
                // Cargarlo en la base los comprobantes faltantes
                long           cbteNro = ultimoCbteCargado != null ? (long)ultimoCbteCargado.CbteHasta + 1 : 1;
                ComprobanteDto cbteDto = null;
                while (cbteNro <= ultimoCbteAutorizadoAfip.CbteNro)
                {
                    FECompConsResponse cbteAfip = this.ObtenerComprobanteAfip(feAuthRequest, feCAERequest, cbteNro).ResultGet;
                    if (cbteAfip == null)
                    {
                        break;
                    }

                    if (cbteAfip.EmisionTipo == "CAE")
                    {
                        cbteDto     = new ComprobanteDto();
                        cbteDto.CAE = cbteAfip.CodAutorizacion;
                        cbteDto.CAEFechaVencimiento = DateTimeHelper.ConvertyyyyMMddToDate(cbteAfip.FchVto);
                        cbteDto.CbteDesde           = cbteAfip.CbteDesde;
                        cbteDto.CbteHasta           = cbteAfip.CbteHasta;
                        cbteDto.CbteFecha           = DateTimeHelper.ConvertyyyyMMddToDate(cbteAfip.CbteFch);
                        cbteDto.PtoVta            = cbteAfip.PtoVta;
                        cbteDto.TipoComprobanteId = cbteAfip.CbteTipo;
                        TipoComprobanteDto tipoCbteDto = this.comprobanteSvc.ObtenerTipoComprobantePorCodigoAfip(cbteDto.TipoComprobanteId);
                        if (tipoCbteDto != null)
                        {
                            cbteDto.TipoComprobanteId = tipoCbteDto.Id;
                        }
                        if (cbteAfip.DocTipo == 80) // CUIT
                        {
                            ClienteDto clienteDto = this.clienteSvc.ObtenerClientePorCuit(cbteAfip.DocNro);
                            if (clienteDto != null)
                            {
                                cbteDto.ClienteId = clienteDto.Id;
                            }
                        }
                        // #TODO: borrar
                        //EstadoComprobanteDto estadoDto = this.comprobanteSvc.ObtenerEstado(CodigoEstadoCbte.NoVisualizado);
                        //if (estadoDto != null)
                        //{
                        //    cbteDto.EstadoId = estadoDto.Id;
                        //}
                        this.comprobanteSvc.CrearComprobante(cbteDto);
                        cbteNro = (long)cbteDto.CbteHasta + 1;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
Beispiel #6
0
        public int Atualizar(ClienteDto entity)
        {
            Cliente cliente = new Cliente();

            cliente.PrepararDadosParaAtualizar(entity.NCodCliente, entity.CNome, entity.DNascimento, entity.CSexo, entity.CCep, entity.CEndereco, entity.NNumero, entity.CComplemento, entity.CEstado, entity.CCidade, entity.CBairro);
            return(_serviceCliente.Atualizar(cliente));
        }
Beispiel #7
0
        public async Task <int> Inserir(ClienteDto clienteDto)
        {
            if (string.IsNullOrWhiteSpace(clienteDto.Nome))
            {
                throw new ValidationException("Nome", "Preencha o nome");
            }

            //cliente.Id = GerarProximoId();
            var cliente = new Cliente();

            cliente.Nome           = clienteDto.Nome.ToUpper();
            cliente.CpfOuCnpj      = clienteDto.CpfOuCnpj.Trim();
            cliente.DataNascimento = clienteDto.DataNascimento;

            if (clienteDto.Telefones != null)
            {
                foreach (var telefoneDto in clienteDto.Telefones)
                {
                    var telefone = new ClienteTelefone();

                    telefone.Numero = telefoneDto.Numero;

                    cliente.Telefones.Add(telefone);
                }
            }

            _lojaContext.Add(cliente);

            await _lojaContext.SaveChangesAsync();

            return(cliente.Id);
        }
Beispiel #8
0
        public async Task <ActionResult <ClienteDto> > Put(string idCli, [FromBody] ClienteDto clienteDto)
        {
            if (clienteDto == null)
            {
                BadRequest();
            }

            var cliente = new TblClientes()
            {
                IdCli           = clienteDto.IdCli,
                NumeroDocumento = clienteDto.NumeroDocumento,
                Nombre          = clienteDto.Nombre,
                Direccion       = clienteDto.Direccion,
                Telefono        = clienteDto.Telefono,
                Ciudad          = clienteDto.Ciudad
            };
            //var cuenta = _mapper.Map<Cuenta>(cuentaDto);
            var resultado = await _clienteRepository.Update(cliente);

            if (!resultado)
            {
                NotFound();
            }

            return(clienteDto);
        }
Beispiel #9
0
        public async Task <IActionResult> PutCliente(int id, ClienteDto cliente)
        {
            var cliente2 = new Cliente
            {
                Nome = cliente.Nome,
                Numeroidentificacao = cliente.Numeroidentificacao,
                PetshopId           = int.Parse(cliente.PetshopId)
            };

            if (id != cliente2.Id)
            {
                return(BadRequest());
            }

            _context.Entry(cliente2).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ClienteExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Beispiel #10
0
        private static ClienteDto ToClienteDto(Cliente cliente)
        {
            if (cliente == null)
            {
                return(null);
            }

            ClienteDto clienteDto = new ClienteDto();

            clienteDto.Id                                    = cliente.Id;
            clienteDto.NombreContacto                        = cliente.NombreContacto;
            clienteDto.NombreContactoSecundario              = cliente.NombreContactoSecundario;
            clienteDto.RazonSocial                           = cliente.RazonSocial;
            clienteDto.ApellidoContacto                      = cliente.ApellidoContacto;
            clienteDto.ApellidoContactoSecundario            = cliente.ApellidoContactoSecundario;
            clienteDto.CUIT                                  = cliente.CUIT;
            clienteDto.EmailContacto                         = cliente.EmailContacto;
            clienteDto.EmailContactoSecundario               = cliente.EmailContactoSecundario;
            clienteDto.CalculaVencimientoConVisualizacionDoc = cliente.CalculaVencimientoConVisualizacionDoc;

            Usuario usuario = cliente.Usuarios.FirstOrDefault();

            if (usuario != null)
            {
                clienteDto.UsuarioId = usuario.Id;
            }

            return(clienteDto);
        }
Beispiel #11
0
        public _0010_VentaDelivery(ClienteDto Cliente, long EmpleadoId)
        {
            InitializeComponent();

            _clienteSeleccionado    = Cliente;
            _empleadoSeleccionadoId = EmpleadoId;
            _comprobante            = new ComprobanteDeliveryDto();
            _productoServicio       = new ProductoServicio();
            _productoSeleccionado   = new ComprobanteDeliveryDetalleDto();
            _empleadoServicio       = new EmpleadoServicio();
            _clienteServicio        = new ClienteServicio();
            _comprobanteDelivery    = new ComprobanteDeliveryServicio();
            _listaPrecioServicio    = new ListaPrecioServicio();
            _realizoAlgunaOperacion = false;

            txtDescripcion.KeyPress += Validacion.NoSimbolos;
            txtDescripcion.KeyPress += Validacion.NoInyeccion;

            txtObservacion.KeyPress += Validacion.NoInyeccion;


            txtObservacion.Enter += txt_Enter;
            txtObservacion.Leave += txt_Leave;

            txtDescripcion.Enter += txt_Enter;
            txtDescripcion.Leave += txt_Leave;

            nudCantidad.Enter += txt_Enter;
            nudCantidad.Leave += txt_Leave;

            nudDescuento.Enter += txt_Enter;
            nudDescuento.Leave += txt_Leave;
        }
Beispiel #12
0
 public ActionResult AddCliente(ClienteDto cli)
 {
     try
     {
         int id      = 0;
         var cliente = contexto.cliente.OrderByDescending(c => c.cod_cliente).FirstOrDefault();
         if (cliente != null)
         {
             id = cliente.cod_cliente + 1;
         }
         cliente cl = new cliente();
         cl.cod_cliente    = id;
         cl.nombre_cliente = cli.nombre_cliente;
         cl.nit            = cli.nit;
         cl.rol            = "cliente";
         int    idCuenta = 0;
         cuenta cu       = new cuenta();
         var    cuenta   = contexto.cuenta.OrderByDescending(cue => cue.ncta).FirstOrDefault();
         if (cuenta != null)
         {
             idCuenta = cuenta.ncta + 1;
         }
         cu.ncta        = idCuenta;
         cu.saldo       = cli.saldo;
         cu.cod_cliente = id;
         contexto.cliente.Add(cl);
         contexto.cuenta.Add(cu);
         contexto.SaveChanges();
         return(Json(new { resultado = true }));
     }
     catch (Exception e)
     {
         return(Json(new { resultado = e.Message.ToString() }));
     }
 }
Beispiel #13
0
        public Cliente FindClient(string clientId)
        {
            var querysession = _repositryLocalScheme.Session.CallFunction <ClienteDto>(_PACKAGE_NAME + "PR_GET_CLIENTE(?)")

                               .SetParameter(0, clientId);

            List <ClienteDto> clientes = (List <ClienteDto>)querysession.List <ClienteDto>();

            ClienteDto cliente = clientes[0];

            ApplicationTypes appType = new ApplicationTypes();

            if ((int)ApplicationTypes.JavaScript == (cliente.ApplicationTypeId))
            {
                appType = ApplicationTypes.JavaScript;
            }
            else if ((int)ApplicationTypes.NativeConfidential == (cliente.ApplicationTypeId))
            {
                appType = ApplicationTypes.NativeConfidential;
            }

            return(new Cliente
            {
                Id = cliente.IdCliente,
                Secret = cliente.Secret,
                Name = cliente.Name,
                ApplicationType = appType,
                Active = cliente.Active.Equals("S"),
                RefreshTokenLifeTime = cliente.RefreshTokenLifeTime,
                AllowedOrigin = cliente.AllowedOrigin
            });
        }
        public ActionResult <Retorno> Cadastrar([FromBody] ClienteDto clienteDto)
        {
            Retorno retornoCliente;

            try
            {
                Cliente cliente = _mapper.Map <Cliente>(clienteDto);

                retornoCliente = _clienteServico.ClienteValido(cliente);

                if (!retornoCliente._sucesso)
                {
                    return(BadRequest(retornoCliente));
                }

                bool cadastrouCliente = _clienteServico.CadastrarCliente(cliente);

                if (cadastrouCliente)
                {
                    retornoCliente = new Retorno(true);
                    retornoCliente.AdicionarMensagemSucesso("Cliente cadastrado com sucesso");
                    return(Ok(retornoCliente));
                }

                retornoCliente = new Retorno(false);
                retornoCliente.AdicionarMensagemFalha("Falha ao cadastrar o cliente");
                return(Ok(retornoCliente));
            }
            catch (Exception) // Gravar o Exception em log
            {
                retornoCliente = new Retorno(false);
                retornoCliente.AdicionarMensagemFalha("Falha ao gravar cliente");
                return(BadRequest(retornoCliente));
            }
        }
        public async Task <IActionResult> Put(int ClienteId, ClienteDto model)
        {
            try
            {
                var cliente = await _repo.GetClientesAsyncById(ClienteId, false);

                if (cliente == null)
                {
                    return(NotFound());
                }
                ;

                var idContas = new List <int>();

                model.Contas.ForEach(item => idContas.Add(item.Id));

                var contas = cliente.ContasClientes.Where(
                    conta => !idContas.Contains(conta.ContaId)
                    ).ToArray();
            }
            catch (Exception ex)
            {
                throw;
            }

            return(BadRequest());
        }
Beispiel #16
0
        public ClienteDto GetByClienteId(int id)
        {
            ClienteDto cliente = null;

            _conn.ExecuteProcedure(Procedures.PBSP_GETCLIENTEBYID);
            _conn.AddParameter("@id", id);
            using (var result = _conn.ExecuteReader())
                while (result.Read())
                {
                    cliente = new ClienteDto
                    {
                        Id           = Convert.ToInt32(result["Id"].ToString()),
                        nome         = result["nome"].ToString(),
                        cpf          = result["cpf"].ToString(),
                        rg           = result["rg"].ToString(),
                        rua          = result["rua"].ToString(),
                        fone         = result["fone"].ToString(),
                        bairro       = result["bairro"].ToString(),
                        nivel        = Convert.ToChar(result["nivel"].ToString()),
                        num          = Convert.ToInt32(result["num"].ToString()),
                        dataCadastro = Convert.ToDateTime(result["dataCadastro"].ToString()),
                        ativo        = Convert.ToBoolean(result["ativo"].ToString()),
                        cidadeId     = Convert.ToInt32(result["CidadeId"].ToString()),
                        estadoId     = Convert.ToInt32(result["EstadoId"].ToString())
                    };
                }
            return(cliente);
        }
        public JsonResult AgregarCliente(ClienteDto cliente)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    string[] campos = { cliente.Nombre, cliente.Apellido, cliente.Direccion };

                    _clienteServicio.Add(cliente);

                    return(Json(new
                    {
                        finalizado = true
                    }));
                }
            }
            catch (System.Exception e)
            {
                throw new System.Exception(e.Message);
            }

            return(Json(new
            {
                finalizado = false
            }));
        }
Beispiel #18
0
        private void Datos()
        {
            _ArregloDto = arregloServicio.ObtenerPorId(_ArregloId);

            _ClienteDto = clienteServicio.ObtenerPorId(_ArregloDto.ClienteId);

            lblCliente.Text = $"{_ClienteDto.Apellido} {_ClienteDto.Nombre}";

            lblFechaDejado.Text  = $"{_ArregloDto.FechaPedido.ToLongDateString()}";
            lblFechaEntrega.Text = $"{_ArregloDto.FechaEntrega.ToLongDateString()}";

            lblEstado.Text = $"{_ArregloDto.Estado}";

            lblHorarioRetiro.Text = $"{_ArregloDto.Horario}";

            txtDescripcion.Text = $"{_ArregloDto.Descripcion}";

            txtTotal.Text          = $"$ {_ArregloDto.Total}";
            txtDineroAdelanto.Text = $"$ {_ArregloDto.Adelanto}";

            txtDebe.Text = $"$ {_ArregloDto.Total - _ArregloDto.Adelanto}";

            _Debe            = _ArregloDto.Total - _ArregloDto.Adelanto;
            nudCobro.Maximum = _Debe;
        }
Beispiel #19
0
        private void LinkCliente_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            var lookupCliente = new _00047_LookUp_Clientes();

            lookupCliente.ShowDialog();

            var clienteDto = new ClienteDto();

            clienteDto = (ClienteDto)lookupCliente.ObjetoLookUp;

            if (clienteDto != null)
            {
                if (_clienteServicio.TieneCuentaCorriente(clienteDto.Id))
                {
                    if (clienteDto.MontoDeudaCtaCte == 0)
                    {
                        MessageBox.Show("El cliente no posee deuda a pagar");
                        return;
                    }
                    txtDni.Text      = clienteDto.Dni;
                    txtCliente.Text  = clienteDto.ApyNom;
                    nudDeuda.Value   = clienteDto.MontoDeudaCtaCte;
                    txtDni.Enabled   = false;
                    btnPagar.Enabled = true;
                    nudSaldo.Focus();
                }
                else
                {
                    MessageBox.Show(@"El cliente no posee cuenta corriente.");
                    return;
                }
            }
        }
Beispiel #20
0
 private void dgvGrillaClientes_RowEnter(object sender, DataGridViewCellEventArgs e)
 {
     if (dgvGrillaClientes.RowCount > 0)
     {
         _clienteSeleccionado = (ClienteDto)dgvGrillaClientes.Rows[e.RowIndex].DataBoundItem;
     }
 }
        public ClienteDto RegistrarCliente(ResponseCreateCliente cliente)
        {
            ClienteDto imprimir = new ClienteDto();

            if (Validaciones.SoloLetras(cliente.Apellido.ToString()) &&
                Validaciones.SoloLetras(cliente.Nombre.ToString()) &&
                Validaciones.SoloNumeros(cliente.DNI) &&
                !_query.ExisteDni(cliente.DNI))
            {
                Cliente entity = new Cliente()
                {
                    DNI      = cliente.DNI,
                    Apellido = cliente.Apellido,
                    Nombre   = cliente.Nombre,
                    Email    = cliente.Email
                };
                Add(entity);
                imprimir.Mensaje = "El cliente fue registrado con el exito";
                return(imprimir);
            }
            else
            {
                imprimir.Mensaje = "Ocurrio un error, el dni ya estba registrado, o ingreso incorrectamente los datos, vuelva a intentarlo";
                return(imprimir);
            }
        }
Beispiel #22
0
        public ActionResult Update(ClienteDto clienteDto)
        {
            if (ModelState.IsValid)
            {
                if (clienteDto.Foto != null)
                {
                    //guarda la imagen en la carpeta wwwroot/imgsistema
                    var path = $"wwwroot\\imgsistema\\{clienteDto.Foto.FileName}";

                    using (var stream = new FileStream(path, FileMode.Create))
                    {
                        clienteDto.Foto.CopyTo(stream);
                    }

                    //guarda en la base de datos
                    clienteDto.FotoLink = $"/imgsistema/{clienteDto.Foto.FileName}";
                }
                ///---///
                if (clienteDto.Foto == null)
                {
                    clienteDto.FotoLink = _clienteRepositorio.ObtenerPorId(clienteDto.Id).FotoLink;
                }

                _clienteRepositorio.Modificar(clienteDto);

                return(RedirectToAction("Index"));
            }
            else
            {
                return(View());
            }
        }
        public async Task <IActionResult> Editar([FromBody] ClienteDto clienteDto)
        {
            if (clienteDto.Nome == null)
            {
                ModelState.AddModelError("Nome", "Preencha o nome");
            }

            if (ModelState.IsValid == false)
            {
                return(BadRequest(ModelState.ObterErros()));
            }

            var cliente = await _lojaContext
                          .Set <Cliente>()
                          .Where(p => p.Id == clienteDto.Id)
                          .FirstOrDefaultAsync();

            if (cliente == null)
            {
                return(NotFound());
            }

            cliente.Nome           = clienteDto.Nome.ToUpper();
            cliente.CpfOuCnpj      = clienteDto.CpfOuCnpj.Trim();
            cliente.DataNascimento = clienteDto.DataNascimento;

            await _lojaContext.SaveChangesAsync();

            return(Ok("Salvo!"));
        }
Beispiel #24
0
        public ActionResult Create(ClienteDto cliente)
        {
            if (ModelState.IsValid)
            {
                if (cliente.Foto != null)
                {
                    //guarda la imagen en la carpeta wwwroot/imgsistema
                    var path = $"wwwroot\\imgsistema\\{cliente.Foto.FileName}";

                    using (var stream = new FileStream(path, FileMode.Create))
                    {
                        cliente.Foto.CopyTo(stream);
                    }

                    //guarda en la base de datos
                    cliente.FotoLink = $"/imgsistema/{cliente.Foto.FileName}";
                }

                var Cliente = _clienteRepositorio.Agregar(cliente);

                return(RedirectToAction("Index"));
            }
            else
            {
                return(RedirectToAction("Index"));
            }
        }
Beispiel #25
0
        public async Task <IActionResult> Put(long id, [FromBody] ClienteDto valueDto)
        {
            var result = new ResultDto <bool>();

            try
            {
                var modelExists = await _clienteService.GetByIdAsync(id);

                if (modelExists == null)
                {
                    throw new AwayException("No existe el registro que desea editar.");
                }

                valueDto.Id = modelExists.Id;
                result.Data = await _clienteService.UpdateAsync(valueDto);
            }
            catch (AwayException ex)
            {
                _logger.Error(KOriginApp, ex.Message, ex);
                result.AddError(ex.Message);
            }
            catch (Exception ex)
            {
                _logger.Error(KOriginApp, ex.Message, ex);
                result.AddError("Ocurrió un error al intentar editar los datos del registro.");
            }
            return(Ok(result));
        }
Beispiel #26
0
        public async Task <bool> ModificarCliente(ClienteDto cliente)
        {
            var entity = _mapper.Map <ClientEntity>(cliente);

            _clienteDomainService.Update(entity);
            return((await _clienteDomainService.SaveChanges()) > 0);
        }
        /// <summary>
        /// Método para definir propriedades do projeto DTO
        /// </summary>
        /// <param name="projeto">Entidade projeto</param>
        /// <returns>DadosBasicoProjetoDto</returns>
        private DadosBasicoProjetoDto DefinirPropriedadesProjeto(Projeto projeto)
        {
            DadosBasicoProjetoDto projetoDto = new DadosBasicoProjetoDto
            {
                IdProjeto         = projeto.Oid,
                Nome              = projeto.TxNome,
                Situacao          = projeto.CsSituacaoProjeto,
                InicioPlanejado   = projeto.DtInicioPlan,
                InicioReal        = projeto.DtInicioReal,
                TerminoReal       = projeto.DtTerminoReal,
                Gerente           = ColaboradorBo.Instancia.ConsultarColaboradorPorGuid(projeto.GerenteOid ?? System.Guid.Empty),
                HasProjetosMicros = ExistemProjetosMicros(projeto.Oid),
                Clientes          = new List <ClienteDto>()
            };

            foreach (ProjetoCliente projetoCliente in projeto.ProjetoClientes)
            {
                ClienteDto clienteDto = new ClienteDto
                {
                    IdCliente = projetoCliente.IdCliente ?? Guid.Empty,
                    Nome      = projetoCliente.EmpresaInstituicao.TxNome
                };

                projetoDto.Clientes.Add(clienteDto);
            }

            return(projetoDto);
        }
        public Response Add(ClienteDto clienteDto)
        {
            #region Validation
            if (clienteDto.IsNotValid())
            {
                return(Response.BuildBadRequest(ExceptionMessages.ObjetoInvalido));
            }

            if (!clienteDto.CpfValid())
            {
                return(Response.BuildBadRequest(ExceptionMessages.CpfInvalido));
            }

            if (_clienteRepository.Any(CpfValidation.Limpa(clienteDto.Cpf)))
            {
                return(Response.BuildBadRequest(ExceptionMessages.CpfJaCadastrado));
            }
            #endregion

            var cliente = _clienteRepository
                          .Add(_mapper.Map <Cliente>(clienteDto));

            if (!_unitOfWork.Commit())
            {
                throw new ExceptionHttp(ExceptionMessages.ErroAoSalvarDados);
            }

            return(Response.BuildSuccess(_mapper.Map <ClienteDto>(cliente)));
        }
Beispiel #29
0
        public _101_Elegir_FormaDePago(ClienteDto Cliente, long MesaId)
        {
            InitializeComponent();
            _cliente          = Cliente;
            _mesaId           = MesaId;
            _comprobanteSalon = new ComprobanteSalon();
            _ctaCteServicio   = new CuentaCorrienteServicio();

            if (_ctaCteServicio.verificarSiTieneCtaCte(_cliente.Id))
            {
                _ctaCte = _ctaCteServicio.ObtenerCuentaCorrientePorClienteIdSinFiltro(_cliente.Id);

                if (_cliente.TieneCuentaCorriente == false || _ctaCte.EstaHabilitada == false)
                {
                    btnCuentaCorriente.Visible = false;
                    PBCtaCte.Visible           = false;
                }
            }

            else
            {
                if (_cliente.TieneCuentaCorriente == false)
                {
                    btnCuentaCorriente.Visible = false;
                    PBCtaCte.Visible           = false;
                }
            }

            _realizoAlgunaOperacion = false;
        }
Beispiel #30
0
        private void btnBuscarCliente_Click(object sender, EventArgs e)
        {
            var fClienteUp = ObjectFactory.GetInstance <ClienteLookUp>();

            fClienteUp.ShowDialog();

            if (fClienteUp.EntidadSeleccionada != null)
            {
                _clienteSeleccionado = (ClienteDto)fClienteUp.EntidadSeleccionada;

                txtApyNom.Text  = _clienteSeleccionado.ApyNom;
                txtCelular.Text = _clienteSeleccionado.Telefono;
                txtDni.Text     = _clienteSeleccionado.Dni;

                CargarDatos();
            }
            else
            {
                txtCelular.Clear();
                txtApyNom.Clear();
                txtDni.Clear();

                _clienteSeleccionado = null;

                dgvGrilla.DataSource = new List <CuentaCorrienteDto>();
            }
        }
        public Cliente Criar(Guid siteId, ClienteDto clienteDto)
        {
            Validar(siteId, clienteDto);

            var cliente = _fabricaCliente.Criar(siteId, Guid.NewGuid(), clienteDto);
            _repositorioClientes.Inserir(cliente);
            return cliente;
        }
        private static int CrearNuevaCuenta(string cuit,int empresa)
        {
            var cuentaNueva = new ClienteDto(
                    new KeyCliente(empresa, HelperPersona.CuitToDni(cuit), GetNumeroNuevo(empresa)),
                        GetParentesco("Titular"), 1);
            cuentaNueva.Save();

            return cuentaNueva.Key.NroCuenta;
        }
 public virtual Cliente Criar(Guid siteId, Guid id, ClienteDto clienteDto)
 {
     return new Cliente(
             siteId, 
             id,
             clienteDto.GrupoId.ParaGuid(),
             new Cnpj(clienteDto.Cnpj),
             clienteDto.Nome,
             clienteDto.Codigo,
             new Endereco(clienteDto.Logradouro, clienteDto.Numero, clienteDto.Complemento, clienteDto.Bairro, clienteDto.Cidade, clienteDto.Estado, clienteDto.Cep),
             new CorreioEletronico(clienteDto.CorreioEletronicoLoja),
             new CorreioEletronico(clienteDto.CorreioEletronicoManutencao),
             new CorreioEletronico(clienteDto.CorreioEletronicoAdministracao));
 }
        private void Validar(Guid siteId, string id, ClienteDto clienteDto)
        {
            if (!id.GuidValido())
                throw new FormatoInvalido("O identificador de cliente informado não é válido.");

            if (_repositorioClientes.BuscarPorId(siteId, new Guid(id)) == null)
                throw new RecursoNaoEncontrado("O cliente não foi encontrado.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Nome) && _repositorioClientes.BuscarPorNomeExcetoId(siteId, clienteDto.Nome, id.ParaGuid()) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este nome.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Cnpj) && _repositorioClientes.BuscarPorCnpjExcetoId(siteId, clienteDto.Cnpj, id.ParaGuid()) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este CNPJ.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Codigo) && _repositorioClientes.BuscarPorCodigoExcetoId(siteId, clienteDto.Codigo, id.ParaGuid()) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este código.");

            if (clienteDto.GrupoId.GuidValido() && _repositorioGrupos.BuscarPorId(siteId, clienteDto.GrupoId.ParaGuid()) == null)
                throw new FormatoInvalido("O grupo informado para o cliente não existe.");
        }
        private void Validar(Guid siteId, ClienteDto clienteDto)
        {
            if (clienteDto.Id != Guid.Empty)
                throw new FormatoInvalido("O identificador de cliente não deve ser informado neste contexto.");

            if (!clienteDto.GrupoId.GuidValido())
                throw new FormatoInvalido("O identificador de grupo do cliente não é válido.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Nome) && _repositorioClientes.BuscarPorNome(siteId, clienteDto.Nome) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este nome.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Cnpj) && _repositorioClientes.BuscarPorCnpj(siteId, clienteDto.Cnpj) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este CNPJ.");

            if (!String.IsNullOrWhiteSpace(clienteDto.Codigo) && _repositorioClientes.BuscarPorCodigo(siteId, clienteDto.Codigo) != null)
                throw new JaExisteUmRecursoComEstasCaracteristicas("Já existe um cliente informado com este código.");

            if (clienteDto.GrupoId.GuidValido() && _repositorioGrupos.BuscarPorId(siteId, clienteDto.GrupoId.ParaGuid()) == null)
                throw new FormatoInvalido("O grupo informado para o cliente não existe.");
        }
 public void Modificar(Guid siteId, string id, ClienteDto clienteDto)
 {
     Validar(siteId, id, clienteDto);
     _repositorioClientes.Editar(_fabricaCliente.Criar(siteId, id.ParaGuid(), clienteDto));
 }
 public virtual Cliente Criar(Guid siteId, ClienteDto clienteDto)
 {
     return Criar(siteId, clienteDto.Id, clienteDto);
 }