Agentes - AndresRamos/ARSoftware.Contpaqi.Comercial GitHub Wiki

Modelos

Agente

La clase Agente representa un modelo amigable de un agente. Se utiliza principalmente para la creación de agentes.

public class Agente
{
    /// <summary>
    ///     Id del agente.
    /// </summary>
    public int Id { get; set; }

    /// <summary>
    ///     Código del agente.
    /// </summary>
    public string Codigo { get; set; } = string.Empty;

    /// <summary>
    ///     Nombre del agente.
    /// </summary>
    public string Nombre { get; set; } = string.Empty;

    /// <summary>
    ///     Tipo del agente.
    /// </summary>
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public TipoAgente Tipo { get; set; } = TipoAgente.VentasCobro;

    /// <summary>
    ///     Datos extra del agente.
    /// </summary>
    public Dictionary<string, string> DatosExtra { get; set; } = new();
}

admAgentes

La clase admAgentes representa el modelo de SQL con el esquema completo de la tabla de agentes en la base de datos. Se utiliza principalmente para consultar el catalogo de agentes cuando se necesita obtener el esquema completo.

public partial class admAgentes
{
    public int CIDAGENTE { get; set; }
    public string CCODIGOAGENTE { get; set; } = null!;
    public string CNOMBREAGENTE { get; set; } = null!;
    public DateTime CFECHAALTAAGENTE { get; set; }
    public int CTIPOAGENTE { get; set; }
    public double CCOMISIONVENTAAGENTE { get; set; }
    public double CCOMISIONCOBROAGENTE { get; set; }
    public int CIDCLIENTE { get; set; }
    public int CIDPROVEEDOR { get; set; }
    public int CIDVALORCLASIFICACION1 { get; set; }
    public int CIDVALORCLASIFICACION2 { get; set; }
    public int CIDVALORCLASIFICACION3 { get; set; }
    public int CIDVALORCLASIFICACION4 { get; set; }
    public int CIDVALORCLASIFICACION5 { get; set; }
    public int CIDVALORCLASIFICACION6 { get; set; }
    public string CSEGCONTAGENTE { get; set; } = null!;
    public string CTEXTOEXTRA1 { get; set; } = null!;
    public string CTEXTOEXTRA2 { get; set; } = null!;
    public string CTEXTOEXTRA3 { get; set; } = null!;
    public DateTime CFECHAEXTRA { get; set; }
    public double CIMPORTEEXTRA1 { get; set; }
    public double CIMPORTEEXTRA2 { get; set; }
    public double CIMPORTEEXTRA3 { get; set; }
    public double CIMPORTEEXTRA4 { get; set; }
    public string CTIMESTAMP { get; set; } = null!;
    public string CSCAGENTE2 { get; set; } = null!;
    public string CSCAGENTE3 { get; set; } = null!;
}

AgenteDto

La clase AgenteDto representa un modelo agente simplificado. Se utiliza principalmente para consultar el catalogo de agentes cuando solo se necesitan algunas propiedades. Las propiedades de este modelo tienen los los mismos nombres que las propiedades del modelo de SQL para facilitar la asignacion de valores cuando se utiliza con los repositorios genericos de agentes, como por ejemplo los que implementan IAgenteRepository<T> de AgenteDto.

public class AgenteDto
{
    /// <summary>
    ///     Id del agente.
    /// </summary>
    public int CIDAGENTE { get; init; }

    /// <summary>
    ///     Codigo del agente.
    /// </summary>
    public string CCODIGOAGENTE { get; init; } = string.Empty;

    /// <summary>
    ///     Nombre del agente.
    /// </summary>
    public string CNOMBREAGENTE { get; init; } = string.Empty;

    /// <summary>
    ///     Tipo del agente: 1 = Agente de Ventas. 2 = Agente Venta / Cobro. 3 = Agente de Cobro. 4 = Figuras de transporte.
    ///     5 = Medios de transporte.
    /// </summary>
    public int CTIPOAGENTE { get; init; }
}

Comandos

Servicios

El servicio IAgenteService proporciona metodos para crear y actualizar agentes.

public interface IAgenteService
{
    /// <summary>
    ///     Actualiza un agente por su Id. Los datos a actualizar se pasan en un diccionario donde la llave es el nombre de la
    ///     columna de la tabla de agentes en la base de datos y el valor es un valor valido para la columna.
    /// </summary>
    /// <param name="idAgente">El Id del agente a actualizar.</param>
    /// <param name="datosAgente">Datos del agente a actualizar.</param>
    void Actualizar(int idAgente, Dictionary<string, string> datosAgente);

    /// <summary>
    ///     Actualiza un agente por su código. Los datos a actualizar se pasan en un diccionario donde la llave es el nombre de
    ///     la columna de la tabla de agentes en la base de datos y el valor es un valor valido para la columna.
    /// </summary>
    /// <param name="codigoAgente">El código del agente a actualizar.</param>
    /// <param name="datosAgente">Datos del agente a actualizar.</param>
    void Actualizar(string codigoAgente, Dictionary<string, string> datosAgente);

    /// <summary>
    ///     Crea un agente. Los datos del agente se pasan en un diccionario donde la llave es el nombre de la columna de la
    ///     tabla de agentes en la base de datos y el valor es un valor valido para la columna.
    /// </summary>
    /// <param name="datosAgente">Datos del agente a crear.</param>
    /// <returns>El Id del agente creado.</returns>
    int Crear(Dictionary<string, string> datosAgente);

    /// <summary>
    ///     Crea un agente.
    /// </summary>
    /// <param name="agente">Agente a crear.</param>
    /// <returns>El Id del agente creado. </returns>
    int Crear(Agente agente);
}

Crear Agente

public class CrearAgente
{
    private readonly IAgenteService _ageteService;

    public CrearAgente(IAgenteService ageteService)
    {
        _ageteService = ageteService;
    }

    public int Crear()
    {
        var agente = new Agente { Codigo = "PRUEBA", Nombre = "AGENTE DE PRUEBAS", Tipo = TipoAgente.VentasCobro };

        agente.DatosExtra.Add(nameof(admAgentes.CCOMISIONVENTAAGENTE), "5"); // Comisión de venta del agente.
        agente.DatosExtra.Add(nameof(admAgentes.CTEXTOEXTRA1), "Texto extra 1"); // Texto extra 1.
        agente.DatosExtra.Add(nameof(admAgentes.CTEXTOEXTRA2), "Texto extra 2"); // Texto extra 2.

        int nuevoAgenteId = _ageteService.Crear(agente);

        return nuevoAgenteId;
    }
}

Editar Agente

public class EditarAgente
{
    private readonly IAgenteService _agenteService;

    public EditarAgente(IAgenteService agenteService)
    {
        _agenteService = agenteService;
    }

    public void Editar()
    {
        var codigoAgente = "PRUEBA";

        var datosAgente = new Dictionary<string, string>
        {
            { nameof(admAgentes.CNOMBREAGENTE), "AGENTE DE PRUEBAS MODIFICADO" }, // Nombre del agente.
            { nameof(admAgentes.CCOMISIONVENTAAGENTE), "10" }, // Comisión de venta del agente.
            { nameof(admAgentes.CCOMISIONCOBROAGENTE), "5" }, // Comisión de cobro del agente.
            { nameof(admAgentes.CTEXTOEXTRA1), "Texto extra 1" }, // Texto extra 1.
            { nameof(admAgentes.CTEXTOEXTRA2), "Texto extra 2" }, // Texto extra 2.
            { nameof(admAgentes.CTEXTOEXTRA3), "Texto extra 3" } // Texto extra 3.
        };

        _agenteService.Actualizar(codigoAgente, datosAgente);
    }
}

Consultas

Repositorios

El proyecto incluye repositorios que implementan la interfaz IAgenteRepository<T> que proporciona metodos que puedes utilizar para consultar el catalogo agentes.

Los repositorios disponibles para SDK son:

  • AgenteSdkRepository<T> - Implementa IAgenteRepository<T>.

El repositorio AgenteSdkRepository<T> utiliza reflection para buscar los valores de la propiedades del tipo T en el modelo de SQL admAgentes por lo que debes asegurarte que las propiedades del tipo T tengan el mismo nombre que las columnas de la tabla admAgentes en la base de datos. El proyecto ya incluye el tipo AgenteDto que cumple con este requisito.

Los repositorios disponibles para SQL son:

  • AgenteSqlRepository<T> - Implementa IAgenteSqlRepository<T>. IAgenteSqlRepository hereda de IAgenteRepository<T> y define las versiones asincronas de los metodos para beneficiarse del uso de Entity Framework Core.

El repositorio AgenteSqlRepository<T> utiliza AutoMapper para proyectar el modelo de SQL admAgentes al tipo del parametro T por lo debes crear una configuracion de mapeo con AutoMapper para que funcione. El proyecto ya incluye una configuracion de mapeo para el tipo AgenteDto.

IAgenteRepository<T>

/// <summary>
///     Interfaz de repositorio que define métodos para consultar agentes.
/// </summary>
/// <typeparam name="T">
///     El tipo de agente utilizado por el repositorio.
/// </typeparam>
public interface IAgenteRepository<T> where T : class, new()
{
    /// <summary>
    ///     Busca un agente por código.
    /// </summary>
    /// <param name="codigoAgente">
    ///     Código del agente a buscar.
    /// </param>
    /// <returns>
    ///     Un agente, o <see langword="null" /> si no existe un agente con el código proporcionado.
    /// </returns>
    T? BuscarPorCodigo(string codigoAgente);

    /// <summary>
    ///     Busca un agente por id.
    /// </summary>
    /// <param name="idAgente">
    ///     Id del agente a buscar.
    /// </param>
    /// <returns>
    ///     Un agente, o <see langword="null" /> si no existe un agente con el id proporcionado.
    /// </returns>
    T? BuscarPorId(int idAgente);

    /// <summary>
    ///     Busca todos los agentes de un tipo.
    /// </summary>
    /// <param name="tipoAgente">
    ///     Tipo de los agentes a buscar.
    /// </param>
    /// <returns>
    ///     Lista de agentes.
    /// </returns>
    List<T> TraerPorTipo(TipoAgente tipoAgente);

    /// <summary>
    ///     Busca todos los agentes.
    /// </summary>
    /// <returns>
    ///     Lista de agentes.
    /// </returns>
    List<T> TraerTodo();
}

IAgenteSqlRepository<T>

/// <inheritdoc cref="IAgenteRepository{T}" />
public interface IAgenteSqlRepository<T> : IAgenteRepository<T> where T : class, new()
{
    /// <summary>
    ///     Busca un agente por código.
    /// </summary>
    /// <param name="codigoAgente">
    ///     Código del agente a buscar.
    /// </param>
    /// <param name="cancellationToken">
    ///     Token de cancelación.
    /// </param>
    /// <returns>
    ///     Un agente, o <see langword="null" /> si no existe un agente con el código proporcionado.
    /// </returns>
    Task<T?> BuscarPorCodigoAsync(string codigoAgente, CancellationToken cancellationToken);

    /// <summary>
    ///     Busca un agente por id.
    /// </summary>
    /// <param name="idAgente">
    ///     Id del agente a buscar.
    /// </param>
    /// <param name="cancellationToken">
    ///     Token de cancelación.
    /// </param>
    /// <returns>
    ///     Un agente, o <see langword="null" /> si no existe un agente con el id proporcionado.
    /// </returns>
    Task<T?> BuscarPorIdAsync(int idAgente, CancellationToken cancellationToken);

    /// <summary>
    ///     Busca todos los agentes de un tipo.
    /// </summary>
    /// <param name="tipoAgente">
    ///     Tipo de los agentes a buscar.
    /// </param>
    /// <param name="cancellationToken">
    ///     Token de cancelación.
    /// </param>
    /// <returns>
    ///     Lista de agentes.
    /// </returns>
    Task<List<T>> TraerPorTipoAsync(TipoAgente tipoAgente, CancellationToken cancellationToken);

    /// <summary>
    ///     Busca todos los agentes.
    /// </summary>
    /// <param name="cancellationToken">
    ///     Token de cancelación.
    /// </param>
    /// <returns>
    ///     Lista de agentes.
    /// </returns>
    Task<List<T>> TraerTodoAsync(CancellationToken cancellationToken);
}

Dependency Injection

public sealed class BuscarAgentesConRepositorio
{
    private readonly IAgenteRepository<admAgentes> _agenteRepository;
    // private readonly IAgenteRepository<AgenteDto> _agenteRepository;
    // private readonly IAgenteRepository<TuModelo> _agenteRepository;

    public BuscarAgentesConRepositorio(IAgenteRepository<admAgentes> agenteRepository)
    {
        _agenteRepository = agenteRepository;
    }
}

Buscar Por Codigo

public void BuscarPorCodigo()
{
    var codigoAgente = "PRUEBA";

    admAgentes? agente = _agenteRepository.BuscarPorCodigo(codigoAgente);

    _logger.LogInformation("{@Agente}", agente);
}

Buscar Por Id

public void BuscarPorId()
{
    var idAgente = 1;

    admAgentes? agente = _agenteRepository.BuscarPorId(idAgente);

    _logger.LogInformation("{@Agente}", agente);
}

Buscar Por Tipo

public void TraerPorTipo()
{
    var tipoAgente = TipoAgente.VentasCobro;

    List<admAgentes> agentes = _agenteRepository.TraerPorTipo(tipoAgente);

    _logger.LogInformation("{@Agentes}", agentes);
}

Traer Todo

public void TraerTodo()
{
    List<admAgentes> agentes = _agenteRepository.TraerTodo();

    _logger.LogInformation("{@Agentes}", agentes);
}
⚠️ **GitHub.com Fallback** ⚠️