PROYECTO FINAL - TIENDA

LENGUAJE DE PROGRAMACION (ASSOCIATE)

Se debe crear un sistema de información de escritorio para la Óptica “Ojitos”; donde cumpla con
las siguientes especificaciones técnicas y funcionales:

Especificaciones Técnicas y/o no Funcionales

1. Se debe implementar en lenguaje de programación .NET C#.

2. El motor de base de datos debe ser SQLServer Express.
3. La arquitectura debe ser en Capas (MVC).
4. Se debe diseñar el modelo relacional de la base de datos.
5. Se debe realizar el diagrama de clases de la solución.
6. El sistema debe contar con seguridad en el acceso por perfiles (administrador, asistente
y medico).
7. El sistema debe contar con ayudas de uso en los formularios; debe ser intuitivo.

Requerimientos Funcionales

El sistema debe contar con las siguientes condiciones y características basadas en la operación
de la Óptica:

1. El sistema debe contar con tres módulos principales

- Modulo administrador: debe permitir al administrador crear los usuarios del sistema
(identificación, nombre, usuario, clave, estado, perfil); crear los productos del
inventario, donde estos deben contar con los datos referencia, color, categoría,
precio, stock y deben estar clasificados por categorías (código y nombre); por último
se podrán crear los clientes (a este módulo todos los perfiles deben poder acceder).
- Módulo de Inventarios: los usuarios asistentes y médicos deben poder ingresar al
sistema y realizar la venta de los productos que son lentes de contacto y gafas; así
como realizar la compra de estos; actualizando el inventario.
o La venta disminuye el stock del producto.
o La compra aumenta el stock del producto.
o En una venta o compra pueden entrar varios productos; se debe almacenar
la fecha del movimiento, el cliente si es venta y total en pesos; y al detalle
de estos la cantidad, valor unitario y valor total por producto. Se debe
generar un documento de resumen por los dos movimientos.
o Los precios en la venta se deben traer de la tabla de productos, pero pueden
ser modificados
- Módulo de consultas clínicas: los médicos deberán poder consultar si su paciente
ya existe, si no es así crearlo y de los contrario poder modificarlo; a este le debe
asociar la cita medica donde se almacena fecha, motivo consulta, rx final,
diagnostico, remisiones, observaciones; un paciente puede tener varias visitas y
están deben poderse consultar por el médico. El medico debe poder generar un
resumen de historia.
- Modulo de reportes: debe generar por lo menos un reporte gerencial en pdf, una
consulta que se exporte a Excel, un reporte en archivo plano y un reporte en XML.
2. Debe contar con dos tipos de clientes; el primero son los compradores, que deben tener
unos datos básicos (*) y los segundos son pacientes que deben tener los mismos datos
de los anteriores más los complementarios. A los primeros los pueden crear el
administrador y asistente; a los segundos el médico, el medico puede completar la
información de uno creado como básico; el administrador y el asistente no pueden
modificar los datos del médico.

PRIMER SEGUNDO No.

NOMBRES FECHA TELEFONO CELULAR CORREO
APELLIDO APELLIDO DOCUMENTO EDAD
(*) NACIMIENTO FIJO (*) ELECTRONICO
(*) (*) (*)
 3. Todas las entidades deben contener campos de auditoria como usuario, fecha/hora. Esta
auditoria debe contenerse desde escribirse desde el primer modulo en archivos planos.
4. Debe estructurar la información de los productos, ventas y compras en un archivo XML
con la información acumulada a la fecha de generación. Esto debe incluirlo en el modulo
de reportes.
5.

Entregables

Actividad Fecha Peso

Primer Corte 30%
Parcial Septiembre 2 60%
Proyecto 40%
Modelo Relacional y Modelo de Clases Agosto 20 20%
Diagrama de flujo y Mockups Agosto 20 20%
Módulo Administrador - Formulario de Categorías Agosto 27 10%
Módulo Administrador - Formulario de Usuarios Septiembre 3 50%
Segundo Corte 30%
Parcial Octubre 14 20%
Proyecto 80%
Módulo inventarios - Formulario de Productos Septiembre 17 30%
Módulo inventarios - Formulario de Compras Octubre 1 30%
Módulo Administrador – Formulario de Clientes Octubre 15 40%
Tercer Corte 40%
Parcial Noviembre 18 20%
Proyecto 80%
Módulo inventarios - Formulario de Ventas Octubre 29 30%
Módulo de consultas clínicas Noviembre 12 40%
Reportes Noviembre 19 30%

ACCIÓN NOTA FECHA

Reporte notas primer corte 1er 30 % 6 al 9 de septiembre
Modificaciones primer corte 10 al 11 de septiembre
Reporte notas segundo corte 2do 30 % 18 al 21 de octubre
Modificaciones segundo corte 22 al 23 de octubre
Reporte notas tercer corte 3er 40 % 17 al 18 de noviembre
Modificaciones segundo corte 19 al 20 de noviembre
Cierre y entrega de planillas 20 y 21 de noviembre

En cada una de las fechas estipuladas se hará la sustentación y revisión del avance, para la
presentación y la retroalimentación debe estar el grupo completo.

Para la entrega final el grupo deberá realizar la presentación de todo el proyecto a todo el grupo.

Las entregas son acumuladas.

 GUIA PARA A ELABORACION DEL PROYECTO EN .NET #C

Se desarrollará el formulario para administrar

Categorías, basado en la entidad categoría
del modelo relacional
Como primera instancia en el motor de base
de datos se deben crear los procedimientos
almacenados que se utilizaran para la
persistencia, en los métodos de Listar todas
Categorías, Buscar Categoría por Id, Insertar,
Actualizar y Eliminar.

USE Optica_XX
--(XX Numero_grupo)
GO

CREATE PROCEDURE ListarCategorias

AS
SELECT IdCategoria [Id],
ISNULL(CodigoCategoria,'') [Codigo],
ISNULL(Nombre,'')[Nombre],
ISNULL(Observacion,'')[Observacion]
FROM Categoria
GO

CREATE PROCEDURE TraerCategoriaPorId

@ID int
AS
SELECT IdCategoria [Id],
ISNULL(CodigoCategoria,'') [Codigo],
ISNULL(Nombre,'')[Nombre],
ISNULL(Observacion,'')[Observacion]
FROM Categoria
WHERE IdCategoria = @ID
GO

CREATE PROCEDURE InsertarCategoria

@CODIGO VARCHAR(8),
@NOMBRE VARCHAR(100),
@OBSERVACION TEXT
AS
INSERT INTO Categoria(CodigoCategoria,Nombre,Observacion)
VALUES(@CODIGO,@NOMBRE,@OBSERVACION)
GO

CREATE PROCEDURE ActualizarCategoria

@ID INT,
@CODIGO VARCHAR(8),
@NOMBRE VARCHAR(100),
@OBSERVACION TEXT
AS
UPDATE Categoria SET CodigoCategoria = @CODIGO,
Nombre = @NOMBRE, Observacion = @OBSERVACION
WHERE IdCategoria = @ID
GO

CREATE PROCEDURE EliminarCategoria

@ID INT
AS
DELETE FROM Categoria
WHERE IdCategoria = @ID
GO
Ahora, vamos a construir el formulario de administración de categorías

1) Crear una solución en blanco

Ingrese al menú Archivo => Nuevo => Proyecto
Visual C# => Escritorio de Windows =>Proyecto Vacío
Nombre de la solución Optica_XX
Seleccione la ubicación del proyecto

2) Agregar a la solución las carpetas Modelo y Aplicaciones.

Clic derecho sobre la solución => agregar => nueva carpeta de soluciones
Asignar el nombre Modelo
 Clic derecho sobre la solución =>
agregar => nueva carpeta de
soluciones
Asignar el nombre Aplicaciones

3) Crear la capa de entidad.

Sobre la Carpeta Modelo, clic derecho => agregar => nuevo proyecto

Seleccione escritorio de windows => biblioteca de clases como tipo de

proyecto.
Asigne el nombre Optica_XX.Entidades
 Elimine la clase que se crea por defecto (Class1.cs)
Agregue un nuevo Item al proyecto, clic derecho =>
agregar => nuevo elemento

Seleccione e tipo Clase de visual C# y asigne el nombre Categoria

Para que la clase sea visible para los demás proyectos le agregamos el
modificador public

public class Categoria

Creamos los campos y métodos de la clase.
 // Atributos de la clase Categoria
int _id;
string _codigo;
string _nombre;
string _observacion;

// Se definen los metodos get y set

public int Id
{
get { return _id; }
set { _id = value; }
}

public string Codigo

{
get { return _codigo; }
set { _codigo = value; }
}

public string Nombre

{
get { return _nombre; }
set { _nombre = value; }
}

public string Observacion

{
get { return _observacion; }
set { _observacion = value; }
}

Creamos los constructores de la clase.

public Categoria(int Id, string Codigo, string Nombre, string Observacion)

{
this._id = Id;
this._codigo = Codigo;
this._nombre = Nombre;
this._observacion = Observacion;
}

public Categoria(int Id, string Codigo, string Nombre) : this(Id, Codigo,

Nombre, "")
{
}

public Categoria(int Id, string Nombre): this(Id, "", Nombre, "")

{
}

public Categoria(): this(0, "", "", "")

{
}
4) Crear la capa de Datos.
Sobre la Carpeta Modelo, clic derecho => agregar => nuevo proyecto
Seleccione Escritorio de Windows => biblioteca de clases como tipo de
proyecto.
Asigne el nombre Optica_XX.Datos
Elimine la clase que se crea por defecto (Class1.cs)

Agregue un nuevo Item al proyecto, clic derecho => agregar => nuevo elemento

Seleccione el tipo Class y asigne el nombre DAOCategoria

Para que la clase sea visible para los demás proyectos le agregamos el
modificador public

public class DAOCategoria

Agregue la referencia al proyecto:

Proyecto Optica_XX.Datos, clic derecho => Agregar => Referencia,

Seleccione la ficha Proyectos, luego ubique el proyecto Optica_XX.Entidades =>

Aceptar
 Importamos la referencia para esto
agregamos la siguiente instrucción.

using Optica_XX.Entidades;

Vamos a crear una propiedad que tome la cadena de conexión a la base de

datos, esta cadena de conexión será definida más adelante en el archivo de
configuración de la aplicación sea web (webconfig) o Windows (AppConfig), para
tomar esta configuración hacemos sobre el Proyecto Optica_XX.Datos, clic
derecho => agregar referencia, Seleccione la ficha Ensamblados, luego ubique
System.Configuration y Aceptar. (esto solo se hace una vez)

Ahora sobre la clase DAOCategoria, importamos la referencia

System.Configuration, para la conexión a la base de datos y System.Data, para
acceder a la librería de Datos y a SQLServer.

using System.Configuration;
using System.Data.SqlClient;
using System.Data;
Creamos una propiedad llamada CadenaConexion, para este caso
preguntamos si es que el campo _cadenaConexion recuperó el valor de un key
llamado Conex que estará definido en el archivo de configuración.

string _cadenaConexion;

public string CadenaConexion

{
get
{
if (_cadenaConexion == null)
 {
_cadenaConexion = ConfigurationManager.
ConnectionStrings["Conex"].ConnectionString;
}
return _cadenaConexion;
}
set { _cadenaConexion = value; }
}
Ahora creamos los métodos de acceso a datos, tales como Listar, Insertar,
Eliminar, Actualizar.

public List<Categoria> Listar()

{
List<Categoria> lista = new List<Categoria>();

using (SqlConnection con = new SqlConnection(CadenaConexion))

{
con.Open();
SqlCommand cmd = new SqlCommand("ListarCategorias", con);
cmd.CommandType = CommandType.StoredProcedure;
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null && dr.HasRows)
{
while (dr.Read())
{
Categoria c = new Categoria((int)dr["Id"],
(string)dr["Codigo"], (string)dr["Nombre"],
(string)dr["Observacion"]);
lista.Add(c);
}
}
}
return lista;
}

public Categoria TraerPorId(int Id)

{
Categoria Categoria = new Categoria();
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
con.Open();
SqlCommand cmd = new SqlCommand("TraerCategoriaPorId", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@ID", Id);
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null && dr.HasRows)
{
dr.Read();
Categoria = new Categoria((int)dr["Id"],
(string)dr["Codigo"], (string)dr["Nombre"],
(string)dr["Observacion"]);
}
}
return Categoria;
}

public int Insertar(Categoria Categoria)

{
int n = -1;
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
con.Open();
 SqlCommand cmd = new SqlCommand("InsertarCategoria", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Codigo", Categoria.Codigo);
cmd.Parameters.AddWithValue("@Nombre", Categoria.Nombre);
cmd.Parameters.AddWithValue("@Observacion", Categoria.Observacion);
n = cmd.ExecuteNonQuery();
}
return n;
}

public int Actualizar(Categoria Categoria)

{
int n = -1;
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
con.Open();
SqlCommand cmd = new SqlCommand("ActualizarCategoria", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", Categoria.Id);
cmd.Parameters.AddWithValue("@Codigo", Categoria.Codigo);
cmd.Parameters.AddWithValue("@Nombre", Categoria.Nombre);
cmd.Parameters.AddWithValue("@Observacion", Categoria.Observacion);
n = cmd.ExecuteNonQuery();
}
return n;
}

public int Eliminar(int Id)

{
int n = -1;
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
con.Open();
SqlCommand cmd = new SqlCommand("EliminarCategoria", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", Id);
n = cmd.ExecuteNonQuery();
}
return n;
}
5) Crear la capa de Negocio.
Sobre la Carpeta Modelo, clic derecho => agregar => nuevo proyecto
Seleccione escritorio de Windows => biblioteca de clases como tipo de
proyecto.
Asigne el nombre Optica_XX.Negocio
 Elimine la clase que se crea por
defecto (Class1.cs)
Agregue un nuevo Item al
proyecto, clic derecho => agregar
=> nuevo elemento
Seleccione el tipo Class y asigne
el nombre BLCategoria

Para que la clase sea visible para los demás proyectos le agregamos el
modificador public

public class BLCategoria

@) Agregue la referencia al proyecto:

Optica_XX.Datos, clic derecho => Agregar referencia, Seleccione la ficha

Proyectos, luego seleccione el proyecto Optica_XX.Entidades
y Optica_XX.Datos => Aceptar
Importamos la referencia para esto agregamos la siguiente instrucción.
using Optica_XX.Entidades;
using Optica_XX.Datos;

Creamos ahora nuestra lógica de negocio, para esto creamos los métodos tales
como Listar, TraerPorId, Insertar, Eliminar, Actualizar.

public List<Categoria> Listar()

{
DAOCategoria daCategoria = new DAOCategoria();
return daCategoria.Listar();
}

public Categoria TraerPorId(int Id)

{
DAOCategoria daCategoria = new DAOCategoria();
return daCategoria.TraerPorId(Id);
}

public int Insertar(Categoria Categoria)

{
DAOCategoria daCategoria = new DAOCategoria();
return daCategoria.Insertar(Categoria);
}

public int Actualizar(Categoria Categoria)

{
DAOCategoria daCategoria = new DAOCategoria();
return daCategoria.Actualizar(Categoria);
}

public int Eliminar(int Id)

{
DAOCategoria daCategoria = new DAOCategoria();
return daCategoria.Eliminar(Id);
}

6) Crear la Aplicación.
Sobre la Carpeta Aplicaciones, clic derecho => agregar => nuevo proyecto
 Seleccione escritorio de windows => aplicación de Windows Forms como
tipo de proyecto.
Asigne el nombre Optica_XXWindows

Diseñe el siguiente formulario

En el GroupBox gbDatos: Contiene a todos los label y TextBox (txtCodigo;

txtNombre; txtObservacion); el txtObservacion debería mostrarse multilinea
En el GroupBox gbControl: contiene a los Button (btnNuevo, btnGrabar, btnEditar,
btnEliminar, btnSalir)

DataGridView dgvDatos; Personalize el control dgvDatos, agregue las columnas Id,

Código, Nombre, Observación. Modifique la propiedad Visible=False de la columna
Id.

@) Agregue la referencia al proyecto:

Proyecto Optica_XXWindows, clic derecho => Agregar =>Referencia,

Seleccione la ficha Proyectos, luego seleccione el proyecto
Optica_XX.Entidades y Optica_XX.Negocio => Aceptar
 Agregue un nuevo Item al proyecto, clic derecho => Agregar => nuevo
elemento

Seleccione e tipo Application Configuration File, el nombre será por defecto

App.config.

Abrimos el archivo App.config y agregamos la siguiente instrucción después de

<configuration>.
 <connectionStrings>
<add name="Conex" connectionString="Data Source=NOMBRE_SERVIDOR;
Initial Catalog= Optica_XX; UID = usuarioBD; PWD = ClaveBD"/>
</connectionStrings>

Importamos la referencia para esto agregamos la siguiente instrucción.

using Optica_XX.Entidades;
using Optica_XX.Negocio;

Declaramos las variables generales

List<Categoria> lista = null;

BLCategoria blCategoria = new BLCategoria();
Categoria c;
bool _nuevo = false;

public Cartegorias()
{
InitializeComponent();
ActivarControlDatos(gbDatos, false);
CargarDatos();
}

Creamos un método que permita activar los controles

private void ActivarControlDatos(Control Contenedor, bool Estado)

{
try
{
foreach (var item in Contenedor.Controls)
{
if (item.GetType() == typeof(TextBox))
{
((TextBox)item).Enabled = Estado;
}
}
}
catch (Exception)
{

}
}

Creamos un método que limpie los controles

private void LimpiarControl(Control Contenedor)

{
foreach (var item in Contenedor.Controls)
{
if (item.GetType() == typeof(TextBox))
{
((TextBox)item).Clear();
}
}
}

Creamos un método que Active los Botones

private void ActivarButton(bool Estado)

{
 btnNuevo.Enabled = Estado;
btnGrabar.Enabled = !Estado;
btnEliminar.Enabled = Estado;
btnSalir.Enabled = Estado;
}

Creamos el método CargarDatos

private void CargarDatos()

{
if (lista == null)
{
lista = blCategoria.Listar();
}
if (lista.Count > 0)
{
dgvDatos.Rows.Clear();
for (int i = 0; i < lista.Count; i++)
{
dgvDatos.Rows.Add(lista[i].Id, lista[i].Codigo,
lista[i].Nombre, lista[i].Observacion);
}
}
}

Botón Nuevo
private void btnNuevo_Click(object sender, EventArgs e)
{
_nuevo = true;
ActivarControlDatos(gbDatos, true);
btnEditar.Text = "Cancelar";
ActivarButton(false);
LimpiarControl(gbDatos);
txtCodigo.Focus();
}

Botón Grabar

private void btnGrabar_Click(object sender, EventArgs e)

{
int n = -1;
if (_nuevo)
{
c = new Categoria(0, txtCodigo.Text,
txtNombre.Text, txtObservacion.Text);
n = blCategoria.Insertar(c);
}
else
{
c.Codigo = txtCodigo.Text;
c.Nombre = txtNombre.Text;
c.Observacion = txtObservacion.Text;
n = blCategoria.Actualizar(c);
}
if (n > 0)
{
MessageBox.Show("Datos grabados correctamente", "Aviso",
MessageBoxButtons.OK, MessageBoxIcon.Information);
ActivarControlDatos(gbDatos, false);
ActivarButton(true);
dgvDatos.Enabled = true;
LimpiarControl(gbDatos);
 btnEditar.Text = "Editar";
lista = blCategoria.Listar();
CargarDatos();
}
else
{
MessageBox.Show("Error al grabar", "Aviso",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}

Botón Editar
private void btnEditar_Click(object sender, EventArgs e)
{
_nuevo = false;
if (btnEditar.Text == "Cancelar")
{
LimpiarControl(gbDatos);
ActivarControlDatos(gbDatos, false);
ActivarButton(true);
dgvDatos.Enabled = true;
btnEditar.Text = "Editar";
}
else
{
if (dgvDatos.RowCount > 0)
{
c = blCategoria.TraerPorId((int)dgvDatos[0, dgvDatos.
CurrentRow.Index].Value);
txtCodigo.Text = c.Codigo;
txtNombre.Text = c.Nombre;
txtObservacion.Text = c.Observacion;
ActivarControlDatos(gbDatos, true);
ActivarButton(false);
dgvDatos.Enabled = false;
btnEditar.Text = "Cancelar";
}
}
}

Botón Eliminar
private void btnEliminar_Click(object sender, EventArgs e)
{
if (dgvDatos.RowCount > 0)
{
c = blCategoria.TraerPorId((int)dgvDatos[0, dgvDatos.
CurrentRow.Index].Value);
DialogResult rpta =
MessageBox.Show("Desea eliminar el registro", "Eliminar",
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (rpta == System.Windows.Forms.DialogResult.Yes)
{
int n = blCategoria.Eliminar(c.Id);
if (n > 0)
{
MessageBox.Show("Registro eliminado", "Aviso",
MessageBoxButtons.OK, MessageBoxIcon.Information);
lista = blCategoria.Listar();
CargarDatos();
}
else
{
 MessageBox.Show("Error al eliminar", "Aviso",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}

}
}

Botón Salir
private void btnSalir_Click(object sender, EventArgs e)
{
Close();
}

Ejecutar la Aplicación