Example #1
0
        public ResultModel AddContacto(ContactoDto value, string token)
        {
            ResultModel resultModel = CheckToken(token);

            if (!resultModel.Result)
            {
                return(resultModel);
            }
            try
            {
                resultModel.Payload = Tools.Base64Encode(JsonConvert.SerializeObject(_contactoRepository.Add(value)));
            }
            catch (CustomException myException)
            {
                resultModel.ErrorMessage = myException.LocalError.ErrorMessage;
                resultModel.ErrorCode    = myException.LocalError.ErrorCode;
                resultModel.Payload      = String.Empty;
                resultModel.Result       = false;
                resultModel.Token        = String.Empty;
            }
            catch (Exception e)
            {
                resultModel.ErrorMessage = e.Message;
                resultModel.ErrorCode    = 10;
                resultModel.Payload      = String.Empty;
                resultModel.Result       = false;
                resultModel.Token        = String.Empty;
            }
            return(resultModel);
        }
Example #2
0
 public OrdenCabeceraDto()
 {
     Cliente  = new ClienteDto();
     Contacto = new ContactoDto();
     Negocio  = new SegmentacionNegocioDto();
     Detalles = new List <OrdenDetalleDto>();
 }
Example #3
0
        public async Task <IActionResult> Put(long id, [FromBody] ContactoDto valueDto)
        {
            var result = new ResultDto <bool>();

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

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

                valueDto.Id = modelExists.Id;
                result.Data = await _contactoService.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));
        }
Example #4
0
        public async Task <IActionResult> EliminaContacto(int IdContacto)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    ContactoDto contacto = null;
                    ///Registra usuario en BD y valida si ocurrio un error
                    contacto = await contactoBusisness.EliminaontactoBusisness(IdContacto);

                    if (contacto.Validations.Count > 0)
                    {
                        return(Ok(new { status = false, message = contacto.Validations[0].ErrorMessage }));
                    }

                    return(Ok(new { status = true, message = "El contacto se elimino con éxito" }));
                }
                else
                {
                    return(BadRequest(ModelState));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(new { message = ex.Message }));
            }
        }
Example #5
0
        public async Task <IActionResult> ActualizaContacto(ActualizaContactoModel contactoModel)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    ContactoDto contacto = null;
                    ///Registra usuario en BD y valida si ocurrio un error
                    contacto = await contactoBusisness.ActualizaContactoBusisness(mapper.Map <ActualizaContactoModel, ContactoDto>(contactoModel));

                    if (contacto.Validations.Count > 0)
                    {
                        return(Ok(new { status = false, message = contacto.Validations[0].ErrorMessage }));
                    }

                    return(Ok(new { status = true, message = "El contacto se actualizo con éxito" }));
                }
                else
                {
                    return(BadRequest(ModelState));
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(new { message = ex.Message }));
            }
        }
        /// <summary>
        /// Metodo para registrar un contacto de la agenda
        /// </summary>
        /// <param name="contacto">Modelo con la informacion del contacto a registrar </param>
        /// <returns>Retorna estatus de la accion </returns>
        public async Task <ContactoDto> RegistraContactoData(ContactoDto contacto)
        {
            ContactoDto objContacto = new ContactoDto();

            using (var transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.FromMinutes(15), TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = new SqlConnection(ConnectionString))
                {
                    using (var command = connection.CreateSpCommand(_configuration["StoresProcedures:REGISTRA_CONTACTO"]))
                    {
                        command.AddSqlParameter("@Nombre", contacto.Nombre);
                        command.AddSqlParameter("@Apellidos", contacto.Apellidos);
                        command.AddSqlParameter("@Telefono", contacto.Telefono);
                        command.AddSqlParameter("@Email", contacto.Email);
                        command.AddSqlParameter("@Direccion", contacto.Direccion);
                        command.AddSqlParameter("@CategoriaTel", contacto.CategoriaTel);

                        ///Valida que la conexion este abierta
                        if (connection.State == ConnectionState.Closed)
                        {
                            connection.Open();
                        }

                        ///Inicializa nueva instancia de la clase SqlDataAdapter con el objeto SqlCommand como parametro
                        var _adapter = new SqlDataAdapter(command);
                        var _dataSet = new DataSet();
                        _adapter.Fill(_dataSet);

                        foreach (DataRow row in _dataSet.Tables[0].Rows)
                        {
                            errorView = new ErrorViewModel()
                            {
                                ErrorMessage = row.ItemArray[0].ToString()
                            };

                            objContacto.Validations.Add(errorView);
                            connection.Close();
                            return(await Task.FromResult(objContacto));
                        }

                        //foreach (DataRow row in _dataSet.Tables[1].Rows)
                        //{
                        //    _
                        //}
                    }
                    connection.Close();
                }
                transactionScope.Complete();
            }
            return(await Task.FromResult(objContacto));
        }
Example #7
0
        public async Task <IActionResult> Post([FromBody] ContactoDto valueDto)
        {
            var result = new ResultDto <ContactoDto>();

            try
            {
                result.Data = await _contactoService.CreateAsync(valueDto);
            }
            catch (Exception ex)
            {
                _logger.Error(KOriginApp, ex.Message, ex);
                result.AddError("Ocurrió un error al intentar agregar el registro.");
            }
            return(Ok(result));
        }
        /// <summary>
        /// Metodo para consiltar todos los contactos
        /// </summary>
        /// <returns>Lista de contactos</returns>
        public async Task <IList <ContactoDto> > ConsultaContactos()
        {
            IList <ContactoDto> listContactos = new List <ContactoDto>();
            ContactoDto         contacto      = null;

            using (var transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.FromMinutes(15), TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = new SqlConnection(ConnectionString))
                {
                    connection.Open();
                    SqlCommand command = connection.CreateCommand();
                    command.CommandText    = @"SELECT [ContactoId],c.[Nombre],ISNULL(c.[Apellidos],''),c.[Telefono],ISNULL(c.[Email],''),ISNULL(c.[Direccion],''),cat.[Descripcion]
	                                         FROM [dbo].[TBL_CONTACTO]  c
		                                        INNER JOIN [dbo].[TBL_CATEGORIA] cat ON	cat.CategoriaTelId = c.CategoriaTelId"        ;
                    command.CommandTimeout = 15;
                    command.CommandType    = CommandType.Text;

                    ///Inicializa nueva instancia de la clase SqlDataAdapter con el objeto SqlCommand como parametro
                    var _adapter = new SqlDataAdapter(command);
                    var _dataSet = new DataSet();
                    _adapter.Fill(_dataSet);

                    ///Valida si existio un error al actualizar domicilio
                    foreach (DataRow row in _dataSet.Tables[0].Rows)
                    {
                        contacto = new ContactoDto()
                        {
                            ContactoId   = int.Parse(row.ItemArray[0].ToString()),
                            Nombre       = row.ItemArray[1].ToString(),
                            Apellidos    = row.ItemArray[1].ToString(),
                            Telefono     = row.ItemArray[1].ToString(),
                            Email        = row.ItemArray[1].ToString(),
                            Direccion    = row.ItemArray[1].ToString(),
                            CategoriaTel = row.ItemArray[1].ToString()
                        };
                        listContactos.Add(contacto);
                    }
                    connection.Close();
                }
                transactionScope.Complete();
            }
            return(await Task.FromResult(listContactos));
        }
        /// <summary>
        /// Metodo para eliminar un contacto de la agenda
        /// </summary>
        /// <param name="IdContacto">Identificador unico del contacto </param>
        /// <returns>Retorna estatus de la accion </returns>
        public async Task <ContactoDto> EliminaontactoData(int IdContacto)
        {
            ContactoDto objContacto = new ContactoDto();

            using (var transactionScope = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.FromMinutes(15), TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = new SqlConnection(ConnectionString))
                {
                    using (var command = connection.CreateSpCommand(_configuration["StoresProcedures:ELIMINA_CONTACTO"]))
                    {
                        command.AddSqlParameter("@ContactoId", IdContacto);

                        ///Valida que la conexion este abierta
                        if (connection.State == ConnectionState.Closed)
                        {
                            connection.Open();
                        }

                        ///Inicializa nueva instancia de la clase SqlDataAdapter con el objeto SqlCommand como parametro
                        var _adapter = new SqlDataAdapter(command);
                        var _dataSet = new DataSet();
                        _adapter.Fill(_dataSet);

                        foreach (DataRow row in _dataSet.Tables[0].Rows)
                        {
                            errorView = new ErrorViewModel()
                            {
                                ErrorMessage = row.ItemArray[0].ToString()
                            };

                            objContacto.Validations.Add(errorView);
                            connection.Close();
                            return(await Task.FromResult(objContacto));
                        }
                    }
                    connection.Close();
                }
                transactionScope.Complete();
            }
            return(await Task.FromResult(objContacto));
        }
Example #10
0
        public void ContactoNew_Probar_CafeeRut()
        {
            ContactoDto entity = new ContactoDto
            {
                contacRutContacto = "12492054-K"
            };
            //Act
            int result = 0;

            try
            {
                result = objRepo.Add(entity);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

            //Assert
            Assert.IsNotNull(result);
            //Assert.AreEqual(1822, result.contacNumero);
        }
Example #11
0
        public ResultModel Post([FromBody] ContactoDto value, [FromUri] string token)
        {
            ContactoManager contactoManager = new ContactoManager();

            return(contactoManager.AddContacto(value, token));
        }
 /// <summary>
 /// Metodo para actualizar un contacto de la agenda
 /// </summary>
 /// <param name="contacto">Modelo con la informacion del contacto a actualizar </param>
 /// <returns>Retorna estatus de la accion </returns>
 public async Task <ContactoDto> ActualizaContactoBusisness(ContactoDto contacto)
 => await agendaData.ActualizaContactoData(contacto);
 /// <summary>
 /// Metodo para registrar un contacto de la agenda
 /// </summary>
 /// <param name="contacto">Modelo con la informacion del contacto a registrar </param>
 /// <returns>Retorna estatus de la accion </returns>
 public async Task <ContactoDto> RegistraContactoBusisness(ContactoDto contacto)
 => await agendaData.RegistraContactoData(contacto);