Correcciones: relación Venta–Cotizacion, RegistroVenta, Fachada

Author: Thiag

src/Library/Cotizacion.cs

@@ -3,8 +3,8 @@
 namespace Library
 {
     /// <summary>
-    /// Representa una cotización asociada a un cliente o interacción.
-    /// Hereda de Interaccion.
+    /// Representa una cotización realizada en el sistema.
+    /// Hereda de Interaccion porque comparte los datos básicos (fecha, descripcion, notas, etc.).
     /// </summary>
     public class Cotizacion : Interaccion
     {
@@ -24,16 +24,8 @@ public class Cotizacion : Interaccion
         public double ImporteTotal { get; private set; }
 
         /// <summary>
-        /// Constructor que inicializa todos los campos de la cotización.
+        /// Constructor que permite crear una cotización con todos los datos necesarios.
         /// </summary>
-        /// <param name="estado">Estado de la cotización.</param>
-        /// <param name="fechaEnvio">Fecha de envío de la cotización.</param>
-        /// <param name="importeTotal">Importe total de la cotización.</param>
-        /// <param name="fecha">Fecha de la interacción.</param>
-        /// <param name="descripcion">Descripción de la interacción.</param>
-        /// <param name="notas">Notas adicionales de la interacción.</param>
-        /// <param name="respondida">Indica si la interacción fue respondida.</param>
-        /// <param name="direccion">Dirección asociada a la interacción.</param>
         public Cotizacion(
             string estado,
             DateTime fechaEnvio,
@@ -45,14 +37,17 @@ public Cotizacion(
             string direccion
         ) : base(fecha, descripcion, notas, respondida, direccion)
         {
-            Estado = estado;
-            FechaEnvio = fechaEnvio;
-            ImporteTotal = importeTotal;
+            this.Estado = estado;
+            this.FechaEnvio = fechaEnvio;
+            this.ImporteTotal = importeTotal;
         }
 
         /// <summary>
-        /// Constructor vacío para crear una cotización sin inicializar valores.
+        /// Constructor por defecto.
         /// </summary>
-        public Cotizacion() : base() { }
+        public Cotizacion() : base()
+        {
+            // Este constructor deja los valores por defecto.
+        }
     }
-}
+}

src/Library/Fachada.cs

@@ -13,6 +13,7 @@ public class Fachada
         private GestorUsuarios gestorUsuarios;
         private RegistroVenta registroVenta;
         private List<Etiqueta> etiquetas;
+        private List<Cliente> clientes;
 
         /// <summary>
         /// Constructor: inicializa los gestores y listas internas.
@@ -23,6 +24,7 @@ public Fachada()
             gestorUsuarios = GestorUsuarios.Instancia;
             registroVenta = new RegistroVenta(new List<Venta>());
             etiquetas = new List<Etiqueta>();
+            clientes = new List<Cliente>();
         }
 
         // =============================
@@ -37,6 +39,7 @@ public Fachada()
         /// <returns>ID asignado al vendedor.</returns>
         public int RegistrarVendedor(bool activo, DateTime fechaCreacion)
         {
+            // Más adelante podríamos diferenciar tipos de usuario (vendedor/administrador)
             return gestorUsuarios.AgregarUsuario(activo, fechaCreacion);
         }
 
@@ -48,6 +51,7 @@ public int RegistrarVendedor(bool activo, DateTime fechaCreacion)
         /// <returns>ID asignado al administrador.</returns>
         public int RegistrarAdministrador(bool activo, DateTime fechaCreacion)
         {
+            // Idem comentario en RegistrarVendedor
             return gestorUsuarios.AgregarUsuario(activo, fechaCreacion);
         }
 
@@ -58,12 +62,15 @@ public int RegistrarAdministrador(bool activo, DateTime fechaCreacion)
         public List<Usuario> ObtenerUsuarios()
         {
             List<Usuario> lista = new List<Usuario>();
+
+            // Este esquema asume IDs consecutivos comenzando en 1
             for (int id = 1; ; id++)
             {
                 Usuario u = gestorUsuarios.ObtenerUsuario(id);
                 if (u == null) break;
                 lista.Add(u);
             }
+
             return lista;
         }
 
@@ -95,7 +102,10 @@ public void RegistrarCliente(string nombre, string apellido, string telefono, st
                 FechaNacimiento = nacimiento,
                 FechaUltimaInteraccion = DateTime.Now
             };
-            // Podés integrar GestorClientes si querés manejar almacenamiento persistente
+
+            // Por ahora lo almacenamos en la lista interna de la fachada.
+            // Más adelante se puede delegar a un GestorClientes.
+            clientes.Add(nuevo);
         }
 
         /// <summary>
@@ -104,7 +114,8 @@ public void RegistrarCliente(string nombre, string apellido, string telefono, st
         /// <returns>Lista de clientes.</returns>
         public List<Cliente> ObtenerClientes()
         {
-            return new List<Cliente>();
+            // Devolvemos una copia para no exponer la lista interna.
+            return new List<Cliente>(clientes);
         }
 
         // =============================
@@ -118,11 +129,42 @@ public List<Cliente> ObtenerClientes()
         public void RegistrarVenta(Venta venta)
         {
             if (venta == null)
+            {
                 throw new ArgumentNullException(nameof(venta));
+            }
+
+            // La responsabilidad de almacenar la venta es de RegistroVenta.
+            registroVenta.AgregarVenta(venta);
+        }
+
+        /// <summary>
+        /// Registra una nueva venta a partir de una cotización.
+        /// De esta forma se mantiene la relación entre Venta y Cotizacion.
+        /// </summary>
+        /// <param name="cotizacion">Cotización desde la cual se genera la venta.</param>
+        /// <param name="total">Total de la venta.</param>
+        public void RegistrarVentaDesdeCotizacion(Cotizacion cotizacion, double total)
+        {
+            if (cotizacion == null)
+            {
+                throw new ArgumentNullException(nameof(cotizacion));
+            }
 
-            // Agregamos la venta simbólicamente
-            registroVenta.getVentasEntre(venta.Fecha, venta.Fecha);
-            // Se puede agregar método AddVenta en RegistroVenta si se desea almacenamiento real
+            // Creamos la venta a partir de la cotización
+            Venta venta = new Venta(
+                total,
+                DateTime.Now,
+                "Venta desde cotización",
+                "",
+                false,
+                ""
+            );
+
+            // Relacionamos la venta con la cotización de origen
+            venta.AsignarCotizacion(cotizacion);
+
+            // Registramos la venta en el registro de ventas
+            registroVenta.AgregarVenta(venta);
         }
 
         /// <summary>
@@ -133,6 +175,7 @@ public void RegistrarVenta(Venta venta)
         /// <returns>Lista de ventas filtradas por fecha.</returns>
         public List<Venta> ObtenerVentasEntre(DateTime desde, DateTime hasta)
         {
+            // Este método delega en RegistroVenta.
             return registroVenta.getVentasEntre(desde, hasta);
         }
 
@@ -166,20 +209,24 @@ public List<Etiqueta> ObtenerEtiquetas()
         // =============================
 
         /// <summary>
-        /// Registra una interacción de un cliente.
+        /// Registra una interacción asociada a un cliente.
+        /// La interacción concreta (llamada, mensaje, reunión, etc.) se construye fuera de la fachada.
         /// </summary>
         /// <param name="cliente">Cliente al que se le asocia la interacción.</param>
-        /// <param name="descripcion">Descripción de la interacción.</param>
-        public void RegistrarInteraccion(Cliente cliente, string descripcion)
+        /// <param name="interaccion">Interacción ya construida.</param>
+        public void RegistrarInteraccion(Cliente cliente, Interaccion interaccion)
         {
             if (cliente == null)
+            {
                 throw new ArgumentNullException(nameof(cliente));
-            if (string.IsNullOrWhiteSpace(descripcion))
-                throw new Exception("La descripción no puede estar vacía.");
+            }
 
-            // Ejemplo: usamos Venta como tipo concreto de interacción
-            Interaccion nueva = new Venta(0, DateTime.Now, descripcion, "", false, "");
-            cliente.AgregarInteraccion(nueva);
+            if (interaccion == null)
+            {
+                throw new ArgumentNullException(nameof(interaccion));
+            }
+
+            cliente.AgregarInteraccion(interaccion);
         }
 
         /// <summary>
@@ -190,7 +237,9 @@ public void RegistrarInteraccion(Cliente cliente, string descripcion)
         public List<Interaccion> ObtenerInteraccionesDeCliente(Cliente cliente)
         {
             if (cliente == null)
+            {
                 throw new ArgumentNullException(nameof(cliente));
+            }
 
             return cliente.GetInteracciones();
         }

src/Library/GestorUsuario.cs

@@ -22,15 +22,20 @@ public static GestorUsuarios Instancia
         {
             get
             {
-                // Crea la instancia si no existe
-                return instancia ?? (instancia = new GestorUsuarios());
+                if (instancia == null)
+                {
+                    instancia = new GestorUsuarios();
+                }
+                return instancia;
             }
         }
 
         /// <summary>
         /// Constructor privado para evitar la creación de instancias fuera de la clase.
         /// </summary>
-        private GestorUsuarios() { }
+        private GestorUsuarios()
+        {
+        }
 
         /// <summary>
         /// Lista interna que actúa como base de datos de usuarios.
@@ -52,37 +57,42 @@ public int AgregarUsuario(bool activo, DateTime fechaCreacion)
         {
             Usuario nuevo = new Usuario(activo, fechaCreacion)
             {
-                Id = proximoId
+                Id = this.proximoId
             };
 
-            usuarios.Add(nuevo);
-            proximoId++;
+            this.usuarios.Add(nuevo);
+            this.proximoId++;
             return nuevo.Id;
         }
 
         /// <summary>
         /// Obtiene un usuario a partir de su ID.
         /// </summary>
         /// <param name="id">Identificador único del usuario.</param>
-        /// <returns>El objeto <see cref="Usuario"/> si se encuentra; de lo contrario, null.</returns>
+        /// <returns>El objeto Usuario si se encuentra; de lo contrario, null.</returns>
         public Usuario ObtenerUsuario(int id)
         {
-            foreach (var usuario in usuarios)
+            foreach (Usuario usuario in this.usuarios)
             {
                 if (usuario.Id == id)
+                {
                     return usuario;
+                }
             }
             return null;
         }
 
         /// <summary>
         /// Muestra todos los usuarios registrados en la consola.
+        /// Este método se puede usar para pruebas simples en la capa de presentación.
         /// </summary>
         public void MostrarTodosUsuarios()
         {
-            foreach (var usuario in usuarios)
+            foreach (Usuario usuario in this.usuarios)
             {
-                Console.WriteLine($"ID: {usuario.Id}, Activo: {(usuario.Activo ? "Sí" : "No")}, FechaCreacion: {usuario.FechaCreacion.ToShortDateString()}");
+                Console.WriteLine(
+                    $"ID: {usuario.Id}, Activo: {(usuario.Activo ? "Sí" : "No")}, FechaCreacion: {usuario.FechaCreacion.ToShortDateString()}"
+                );
             }
         }
 
@@ -94,7 +104,7 @@ public void MostrarTodosUsuarios()
         /// <returns>True si se actualizó correctamente; false si no se encontró el usuario.</returns>
         public bool ActualizarActivo(int id, bool nuevoActivo)
         {
-            Usuario usuario = ObtenerUsuario(id);
+            Usuario usuario = this.ObtenerUsuario(id);
             if (usuario != null)
             {
                 usuario.Activo = nuevoActivo;
@@ -110,10 +120,10 @@ public bool ActualizarActivo(int id, bool nuevoActivo)
         /// <returns>True si se eliminó correctamente; false si no se encontró el usuario.</returns>
         public bool EliminarUsuario(int id)
         {
-            Usuario usuario = ObtenerUsuario(id);
+            Usuario usuario = this.ObtenerUsuario(id);
             if (usuario != null)
             {
-                usuarios.Remove(usuario);
+                this.usuarios.Remove(usuario);
                 return true;
             }
             return false;

src/Library/RegistroVenta.cs

@@ -23,6 +23,18 @@ public RegistroVenta(List<Venta> ventas)
             this.ventas = ventas ?? new List<Venta>();
         }
 
+        /// <summary>
+        /// Agrega una venta al registro.
+        /// </summary>
+        /// <param name="venta">Venta a registrar.</param>
+        public void AgregarVenta(Venta venta)
+        {
+            if (venta != null)
+            {
+                this.ventas.Add(venta);
+            }
+        }
+
         /// <summary>
         /// Obtiene todas las ventas registradas dentro de un rango de fechas.
         /// </summary>
@@ -33,17 +45,14 @@ public List<Venta> getVentasEntre(DateTime desde, DateTime hasta)
         {
             List<Venta> resultado = new List<Venta>();
 
-            // Recorre todas las ventas registradas
-            foreach (var v in ventas)
+            foreach (Venta v in this.ventas)
             {
-                // Agrega la venta si su fecha está dentro del rango indicado
                 if (v.Fecha >= desde && v.Fecha <= hasta)
                 {
                     resultado.Add(v);
                 }
             }
 
-            // Devuelve la lista de ventas filtradas
             return resultado;
         }
     }