INSTITUTO POLITÉCNICO NACIONAL
Escuela Superior de Ingeniería Mecánica y
Eléctrica
Unidad Profesional Zacatenco
“Sistema de Cómputo para el Control de Reportes de Equipos
Dañados”
T e s i s
Que para obtener el Título de:
Ingeniero en Comunicaciones y Electrónica
P r e s e n t a :
Manuel Sánchez Martínez
A s e s o r e s :
Ing. Catalina Patiño Gallegos
M. en C. David Vázquez Álvarez
México,D.F. 2013
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página II
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página III
Agradecimientos
La presente Tesis es un esfuerzo en el cual, directa o indirectamente, participaron
varias personas leyendo, opinando, corrigiendo, criticando, teniéndome paciencia, dando
ánimo, acompañando en los momentos de crisis y en los momentos de felicidad. Éste
trabajo escrito es la muestra de la dedicación, lucha y esfuerzo que he realizado a lo largo
de mi carrera y en el largo camino de la vida.
Agradezco a todas las personas que han creído en mí y en mis capacidades, así
mismo, agradezco a todas aquellas personas que por algún motivo tenían comentarios
negativos gracias a sus críticas ya que fueron una fuente de motivación para poder
demostrar que soy capaz de realizar grandes cosas.
Gracias a todos mis compañeros que conocí y con los cuáles he convivido a lo largo
de la carrera, ya que gracias a sus opiniones y experiencias han ayudado a forjar no solo
una persona si no a un profesionista que tiene deseo de luchar y seguir adelante con
dedicación, compromiso y responsabilidad.
Agradezco a mis grandes amigos que han estado junto a mí en los momentos más
difíciles brindando su apoyo para que no me rinda nunca. Gracias a una gran persona que
ha estado conmigo siendo un fuerte pilar en el desarrollo de los estudios de mi carrera,
una compañera de vida y una gran amiga, alguien que llego a mi vida y de quién he
aprendido mucho tanto en lo personal como en lo profesional, gracias a ella he podido
crecer y mantenerme en el camino del éxito. Doy las gracias a mi familia, por todo su
apoyo por sus consejos y por estar a mi lado siempre ya que si no estuvieran conmigo éste
sueño difícilmente se habría hecho realidad.
A todos ellos, muchas gracias.
Manuel Sánchez Martínez
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página IV
Tabla de Contenido
AGRADECIMIENTOS .................................................................................................................................... III
TABLA DE CONTENIDO ................................................................................................................................ IV
INTRODUCCIÓN .......................................................................................................................................... VI
OBJETIVO GENERAL ........................................................................................................................................... VII
OBJETIVOS ESPECÍFICOS ..................................................................................................................................... VII
JUSTIFICACIÓN ................................................................................................................................................. VIII
CAPÍTULO 1: ................................................................................................................................................. 9
ESTADO DEL ARTE ........................................................................................................................................ 9
1.1 HISTORIA NEC ........................................................................................................................................... 10
1.2 GRUPO DE VALORES DE NEC ......................................................................................................................... 11
1.3 CORPORACIÓN NEC .................................................................................................................................... 12
1.4 ACERCA DE NEC AUDIOVISUAL ...................................................................................................................... 14
1.5 SISTEMA DE SEGUIMIENTO DE REPORTES ......................................................................................................... 15
1.5.1 Sistema de Seguimiento OSTicket. .................................................................................................. 16
1.5.1 Sistema de Seguimiento PHPTicket. ............................................................................................... 16
1.5.3 Ticket de Servicio............................................................................................................................. 16
1.5.4 Orden de Servicio ............................................................................................................................ 17
1.6 PROCESO DEL CONTROL DE REPORTES DE EQUIPO DAÑADOS NEC MÉXICO S.A. DE C.V. .......................................... 18
CAPÍTULO 2: ............................................................................................................................................... 20
MARCO TEÓRICO Y METODOLÓGICO ......................................................................................................... 20
2.1 ¿QUÉ ES UNA METODOLOGÍA DE DESARROLLO DE SOFTWARE?............................................................................ 21
2.2 BASES DE DATOS. ........................................................................................................................................ 21
2.3 MANEJADOR BASES DE DATOS. ...................................................................................................................... 23
2.4 LENGUAJE DE PROGRAMACIÓN C SHARP (C#) ................................................................................................... 25
2. 5 METODOLOGÍA PARA DESARROLLAR SISTEMAS DE INFORMACIÓN BASADOS EN COMPUTADORAS (LAGS) ................... 27
2.5.1 Análisis, Evaluación y Diagnóstico del Sistema de Información Actual .......................................... 28
2.5.2 Identificación de los Elementos del Sistema Actual ........................................................................ 29
2.5.3 Tabla Sistémica ............................................................................................................................... 31
2.6 PROPUESTA GENERAL DE LA SOLUCIÓN ............................................................................................................ 34
CAPÍTULO 3: ............................................................................................................................................... 35
DISEÑO Y DESARROLLO .............................................................................................................................. 35
3.1 DISEÑO PRELIMINAR .................................................................................................................................... 36
3.1.1 Diseño de las Salidas ....................................................................................................................... 36
3.1.2 Diseño de las Entradas .................................................................................................................... 37
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página V
3.2 DISEÑO DETALLADO ..................................................................................................................................... 37
3.2.1 Diccionario de Datos ....................................................................................................................... 37
3.3 DIAGRAMA ENTIDAD RELACIÓN ..................................................................................................................... 43
3.4 CONSTRUCCIÓN DE PROGRAMAS Y/O MODELOS ............................................................................................... 45
3.5 DESARROLLO DE PROCEDIMIENTOS DEL USUARIO .............................................................................................. 45
3.6 PRUEBAS Y ACEPTACIÓN DEL SISTEMA ............................................................................................................. 54
CAPÍTULO 4: ............................................................................................................................................... 55
IMPLEMENTACIÓN ..................................................................................................................................... 55
4.1 PREPARACIÓN DE LA IMPLEMENTACIÓN ........................................................................................................... 56
4.2 VERIFICAR CONDICIONES PARA IMPLEMENTACIÓN ............................................................................................. 56
4.3 PROCESO DE PROBLEMAS REPORTADOS ........................................................................................................... 58
4.4 PROCESO DE SOLICITUDES DE CAMBIO ............................................................................................................. 58
4.5 MODIFICACIONES DEL SISTEMA ...................................................................................................................... 59
4.6 IDENTIFICACIÓN DE NUEVAS NECESIDADES ....................................................................................................... 59
CONCLUSIONES .......................................................................................................................................... 60
RECOMENDACIONES .................................................................................................................................. 61
ÍNDICE DE FIGURAS .................................................................................................................................... 62
ÍNDICE DE TABLAS ...................................................................................................................................... 63
FUENTES BIBLIOGRÁFICAS ......................................................................................................................... 64
FUENTES ELECTRÓNICAS ............................................................................................................................ 65
ANEXOS ..................................................................................................................................................... 66
Menú Principal ......................................................................................................................................... 66
Agregar Nuevo Reporte ........................................................................................................................... 69
Modificar Reporte .................................................................................................................................... 81
Imprimir Reporte ...................................................................................................................................... 92
Buscar Reporte Ticket .............................................................................................................................. 96
Buscar por Número de Serie del Equipo ................................................................................................... 98
Buscar por Modelo de Pantalla .............................................................................................................. 100
Buscar por Modelo de Proyector ........................................................................................................... 102
Buscar por Empresa ............................................................................................................................... 104
Agregar Nuevo Modelo de Pantalla al Catálogo ................................................................................... 106
Consultar Características de una Pantalla ............................................................................................. 111
Agregar Nuevo Modelo de Proyector al Catálogo ................................................................................. 114
Consultar Características de Proyector .................................................................................................. 119
Agregar Empresa al Catálogo ................................................................................................................ 122
Consultar Contacto Directo con Empresa .............................................................................................. 124
Clases y Funciones utilizadas en el Sistema ........................................................................................... 127
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página VI
Introducción
El propósito del siguiente trabajo de Tesis Profesional es explicar el desarrollo del
Sistema de Cómputo para el Control de Reportes de Equipos Dañados, el cuál es la
solución para la problemática de la empresa NEC de México S.A. de C.V. El sistema realiza
el manejo de eventos suscitados dentro de la organización de una manera fácil y eficiente,
esto basándose en los sistemas de gestión de tickets (en inglés Trouble Ticket System).
La metodología empleada para la realización del Sistema de Cómputo para el
Control de Reportes fue la metodología LAG’S, ésta metodología permitió trabajar en
fases e iteraciones para el desarrollo efectivo del sistema, permitió definir las
funcionalidades del sistema; así como también su estructura y arquitectura.
El sistema de Control de Reportes se describe como una herramienta centralizada,
la cual permite gestionar y solucionar los diversos reportes que introducen los usuarios del
sistema. Éste sistema está a la disposición del Área de Soporte Audiovisual de NEC de
México S.A de C.V.
Como propósito final, la herramienta permite mejorar los procesos que el Área de
Soporte Audiovisual lleva a cabo para dar de alta los reportes de los equipos dañados, con
esto se garantiza una atención oportuna por parte de NEC de México a sus clientes y así
mantener su política de Satisfacción al Cliente.
Gracias a éstas características y beneficios que poseerá el Sistema de Cómputo
Control de Reportes se puede aseverar que éste apoyará por completo la gestión
adecuada y eficiente de los reportes del Área de Soporte Audiovisual.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página VII
Objetivo General
Diseñar, desarrollar e implementar un Sistema encargado del control de los
reportes del Área de Soporte Audiovisual de la empresa NEC de México S.A. de C.V.,
basado en los sistemas de seguimiento de tickets, el cual permite controlar y gestionar
todos los eventos suscitados.
Objetivos Específicos
Analizar el procedimiento que realiza Soporte Audiovisual para llevar a cabo
el control de reportes de los equipos dañados.
Identificar los principales problemas que se presentan al registrar los
reportes de los equipos dañados.
Determinar el método con el cuál se optimizará el procedimiento para un
mejor control de los reportes de equipos dañados.
Desarrollar la Interfaz de Cómputo mediante lenguaje C#.
Evaluar el sistema de cómputo para verificar que se adecua a las
necesidades del Área de Soporte Audiovisual de NEC México S. A. de C. V. y
realizar las correcciones y/o adecuaciones necesarias.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página VIII
Justificación
El Área de Soporte Audiovisual de la empresa NEC de México S.A. de C.V.
debido a su crecimiento en los últimos años a nivel comercial, se ha visto obligada a
invertir en el desarrollo de nuevas formas para mejorar sus procesos de negocios, para así
lograr mantener un control de todas sus actividades. Uno de sus problemas es el hecho de
no poder controlar todos los reportes, debido a que deben atender un gran número de
llamadas, lo cual no permite llevar un control de todos los sucesos que se presentan.
Luego de un breve análisis de los requerimientos y necesidades
relacionadas con ésta situación, se logró obtener el siguiente listado de conclusiones:
Ausencia de control sobre quién realizó o atendió un reporte.
Ausencia de reportes que sirvan como indicadores para los clientes, con la
intención de demostrar los esfuerzos realizados por el personal de
atención.
Descontrol sobre el estado de los reportes. No existe forma de saber si un
reporte se encuentra sin atención, es necesario saber si el reporte se
encuentra con un estado abierto o cerrado.
Dificultad para identificar las empresas que presentan con mayor
frecuencia para los reportes de equipos.
La creación de los reportes es manual, lo que ocasiona desorganización.
A consecuencia de estos problemas, el Área de Soporte Audiovisual se ve en la
imperante necesidad de desarrollar algún sistema y poder resolver la situación planteada.
Es precisamente en estos casos cuando se habla de sistemas de ayuda, específicamente de
los sistemas de seguimiento de tickets (en inglés Trouble Ticket System), los cuales
permiten establecer los procedimientos para solventar las deficiencias encontradas en el
análisis previo.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 9
Capítulo 1:
ESTADO DEL
ARTE
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 10
1.1 Historia NEC
El 17 de julio de 1899, Nippon Electric Company (nombre de NEC Corporation, a partir de abril de 1983) fue establecido por KunihikoIwadare en asociación con la empresa de EE.UU. Western Electric Company (actualmente Alcatel-Lucent).
El objetivo básico de la nueva compañía, el cual se encuentra expresado en el lema "mejores productos, mejor servicio", era llevar a cabo la promesa de ofrecer a sus clientes productos de clase mundial y un servicio confiable de seguimiento. La noción de darle seguimiento a los servicios prestador no se arraigó entre las empresas japonesas hasta medio siglo más tarde, mientras que NEC tuvo desde el principio un concepto que se desarrolló en lo que ahora se le conoce como la satisfacción del cliente.
Premios nacionales en tecnología y desarrollo de la investigación fue posible, gracias a la innovación empresarial y respaldada por la mejora y reforma de sus sistemas de personal, así como los principios de montaje de los proyectos ambientales. Esto hace que sea posible decir que la historia de NEC ha estado marcada por una innovación constante desde hace más de un centenar de años.
Fig. 1.1 Presencia NEC en todo el Mundo
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 11
1.2 Grupo de Valores de NEC
En la filosofía corporativa, se han definido los valores importantes para el Grupo NEC, que se fundamentan en la historia de más de 100 años de la empresa. Esto es en lo que se basan las conductas y actividades individuales, como una guía para servir mejor a los clientes y contribuir a la sociedad.
Valores
fundamentales
Las acciones impulsadas por
valores fundamentales
[Nuestra
Motivación]
Pasión por la
innovación
Explorar y comprender la verdadera esencia de los problemas.
Cuestionar las formas existentes y desarrollar nuevas formas.
Unir la inteligencia y la experiencia de todo el mundo.
[Como una
persona]
de auto-ayuda
Actuar con rapidez.
Trabajar con integridad hasta la finalización del reto más allá de los límites propios.
[Como miembro
del equipo]
Colaboración
El respeto de cada individuo.
Escuchar y aprender con la mente abierta.
Colaborar más allá de las fronteras organizacionales.
[Para nuestros
clientes]
Mejores
Productos,
mejores
servicios
Pensar desde el punto de vista del usuario.
Impresionar e inspirar a nuestros clientes.
Continuar la búsqueda de "Mejor Global".
Fig. 1.2 Valores representativos de NEC
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 12
1.3 Corporación NEC
Es una compañía de tecnología y comunicaciones establecida en Julio de 1899 con oficina central en Tokio, Japón.
NEC proporciona: Soluciones IT (tecnologías de información), soluciones de comunicaciones y
telecomunicaciones a empresas y al gobierno. La compañía está dividida en tres principales ramas:
Soluciones IT.
Soluciones de Red.
Dispositivos Electrónicos.
Las soluciones IT ofrecen a sus clientes software, hardware y otros servicios relacionados.
La rama de soluciones de Red diseña y proporciona sistemas de conexión de banda ancha, telefonía móvil y sistemas de conexión inalámbricos.
La rama de Dispositivos Electrónicos incluye semiconductores, pantallas y otros componentes electrónicos.
Hasta la fecha cuenta con 365 Oficinas alrededor del mundo (Oficinas NEC Corporation y Filiales consolidadas). Cuenta con 156,545 Empleados.
Fig. 1.3 Oficinas Alrededor del Mundo
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 13
Un aspecto importante de la empresa NEC es su lema "Empowered by Innovation", el cual representa el implacable deseo de innovar, no solo en la vida y los negocios de los clientes, sino también en la sociedad entera.
NEC de México surge en el año 1968, cuenta con oficinas en 8 estados de la
República Mexicana, situando su oficina central en México D.F. El ShowRoom es el lugar en que se encuentra la demostración de la línea de productos de la División Audiovisual, dicho ShowRoom se encuentra ubicado en México D.F. El almacén general de la línea de productos se encuentra en el estado de Morelos
. NEC de México cuenta con las siguientes áreas:
Fig. 1.4 Oficinas en México
Fig. 1.5 Áreas NEC de México S.A. de C.V.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 14
Dentro del Área Enterprise o Soluciones de Redes Empresariales, la línea de productos se basa en:
1.4 Acerca de NEC Audiovisual
NEC División Audiovisual diseña, produce y entrega al mercado una amplia
variedad de tecnología de punta en la rama de audiovisual. Se especializan en monitores
LCD para escritorio, pantallas con tecnología LCD y pantallas de plasma, además de una
variada línea de proyectores. El negocio es impulsado por las tecnologías avanzadas, líderes en la industria,
servicio y software que son un valor agregado que ayudan a aumentar su productividad y dejar ver el mundo digital de forma más dinámica y atractiva.
Fig. 1.6 Línea de Productos de Redes Empresariales
Fig. 1.7 Línea de Productos del Área Audiovisual.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 15
1.5 Sistema de Seguimiento de Reportes
Un sistema de seguimiento de reportes o tickets (denominado en inglés como issue tracking system, trouble ticket system o incident ticket system) es un paquete de software que administra y mantiene listas de incidentes. Los sistemas de este tipo son comúnmente usados en la central de llamadas de servicio al cliente de una organización para crear, actualizar y resolver incidentes reportados por usuarios, o inclusive incidentes reportados por otros empleados de la organización.
Un sistema de seguimiento de incidencias también contiene una base de datos que contiene información de cada cliente, soluciones a problemas comunes y otros datos relacionados. Un sistema de seguimiento de reportes es similar a un Sistema de seguimiento de errores (bugtracker).
Un ticket es un archivo contenido en el sistema de seguimiento que contiene información acerca del reporte realizado por el personal de soporte técnico o terceros a pedido de un usuario final que ha reportado un incidente. Típicamente el ticket tiene un número único de referencia, también conocido como un número de caso, incidente o reporte de llamada, el cual es usado para permitir al cliente o al personal de soporte localizar, añadir o comunicar el estado del reporte.
Estos tickets también son llamados así debido a su origen como pequeñas tarjetas con un pequeño muro a manera de un sistema de planificación de trabajo acumulado. Cuando este tipo de soporte comenzaba, los operadores o personal recibía una llamada o consulta de un usuario podía llenar una tarjeta con los detalles del usuario y un breve resumen de su requerimiento y lo colocaba en una posición (usualmente la última), en una columna de "pendientes" para que una persona apropiada pueda determinar qué persona debía encargarse de la consulta y la prioridad del requerimiento.
El diseño más común de sistema de seguimiento de tickets consiste en una base de
datos para el almacenamiento de toda la información. Estos datos son manejados por el
área que recibe las llamadas de los clientes reportando un problema en algún equipo o
para recibir mantenimiento correctivo y preventivo. En esta etapa se brindan los datos
primarios del cliente más un reporte del problema reportado. Cada vez que el usuario del
sistema efectúa un cambio, el sistema de seguimiento de tickets registra la acción. Por
seguridad, un sistema de seguimiento de incidentes verificará la identidad de los usuarios
antes de permitirles el acceso al sistema, aunque cabe señalar que la identificación de los
usuarios no es una regla indispensable, ya que en algunas ocasiones el estar ingresando
datos para verificar la identidad del usuario hace que el sistema no sea óptimo y se pierda
tiempo en estar verificando la identidad de los usuarios, por tal motivo algunas empresas
desean que sus sistema sea abierto, ya que es de uso local.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 16
1.5.1 Sistema de Seguimiento OSTicket.
El sistema de seguimiento Osticket es una aplicación abierto (en inglés
opensource) para la gestión de solicitudes de soporte de una empresa mediante tickets en
línea, de ésta manera se agiliza los procesos y se organiza la información.
Además que su entorno está enfocado al internet, trabaja con PHP y MYSQL.
Características:
Fuente libre, o sea que puede modificarlo.
Organiza todas las peticiones de soporte hechas por los usuarios.
Flujo de Correo Electrónico.
Tiene un panel de administración y muchas funciones más.
1.5.1 Sistema de Seguimiento PHPTicket.
El sistema de seguimiento PHPTicket es un sistema avanzado de venta de entradas,
escrito en PHP y MySQL. Incluye la gestión a través de sesiones de usuario, una función de
búsqueda y varias otras funciones de gestión de tickets. Puede ser utilizado en cualquier
plataforma usando PHP y MySQL.
1.5.3 Ticket de Servicio
Un Ticket es un reporte, caso, pregunta, comentario o solicitud, al cual se le asigna automáticamente un identificador para darle seguimiento al mismo en un sistema de soporte y/o atención.
El ticket de servicio es un número de identificación que le asignan de forma interna para poder tener un control y un registro del reporte del equipo.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 17
1.5.4 Orden de Servicio
La orden de servicio se genera cuando el equipo ha sido devuelto del Centro de Servicio, y el status del ticket se cambia a Cerrado (Close), los campos que presenta la orden de servicio son los siguientes:
Fecha de Recepción.
Número de Ticket.
Cliente.
Contacto directo del cliente.
Encargado de Atención.
Tipo de Equipo.
Modelo de Pantalla.
Modelo de Proyector.
Número de serie del equipo.
Garantía.
Fecha de Inicio de Garantía.
Fecha de Término de Garantía.
Falla.
Observaciones.
Detalles del Servicio
Firma de Aceptación de servicio
Al emplear un Sistema de Seguimiento de Tickets (System Trouble Tickets), la empresa se asegura que no se pierda ninguna solicitud de los clientes, y que se resuelven eficientemente. Por lo tanto es importante que éste Sistema cumpla y satisfaga las necesidades específicas del Área de Soporte Audiovisual de la empresa NEC México S.A. de C.V.
Un aspecto importante que poseerán los tickets para su seguimiento es agregar una gama de estados (status) para tener un mejor control y seguimiento de los reportes:
Open (Abierto) Close (Cerrado)
El término de Open y Close son palabras que no se pueden cambiar ya que la empresa necesita que los estados de sus reportes posean las palabras en inglés. Al implementar un Sistema de Seguimiento de Tickets se busca que el Área de Soporte Audiovisual pueda mantener un registro de todos los reportes que se den de alta, poseer un mejor seguimiento de los equipos enviados al Centro de Servicio y así poder brindar una mejor atención al cliente.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 18
1.6 Proceso del Control de Reportes de Equipo
Dañados NEC México S.A. de C.V.
El siguiente diagrama de flujo presenta el proceso que realiza la empresa NEC
México S.A. de C.V. para efectuar el levantamiento de un reporte, considerando desde el
momento en el que se recibe la llama del cliente, hasta que se da solución a su problema;
en el proceso se da un diagnóstico con posible solución del problema, en dado caso de
que no exista dicha solución se asigna un número de ticket, los tickets cuentan con dos
estados: Abierto y Cerrado (Open y Close), esto con la finalidad de llevar seguimiento del
reporte, el equipo es enviado al Centro de Servicio (ASC). Una vez que el Centro de
Servicio da un diagnóstico del equipo; se lleva a cabo una reparación o incluso un
remplazo del equipo. El equipo se devuelve al área de Soporte Audiovisual y se entrega al
Cliente. El diagrama de flujo se muestra en la página siguiente.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 19
Fig. 1.8 Diagrama de Flujo
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 20
Capítulo 2:
MARCO TEÓRICO Y METODOLÓGICO
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 21
2.1 ¿Qué es una Metodología de Desarrollo de
Software?
El concepto de metodología, dentro de la Ingeniería del Software es, sin duda, uno
de los más oscuros y que más confusión produce tanto en estudiantes como en
profesionales involucrados en procesos de desarrollo de software.
Tanto es así, que en muchos proyectos de desarrollo, la aplicación de una
metodología brilla por su ausencia, siendo éste un concepto casi desconocido. Además, la
constante innovación tecnológica hace que cada vez sea necesaria la aplicación de nuevas
metodologías adaptadas a los nuevos tiempos y, sin embargo, sigue figurando en los libros
de texto viejas metodologías pensadas para viejos problemas. Y no es que haya una
metodología claramente superior a las demás. Las metodologías más modernas
responden a problemas y necesidades más actuales.
Afortunadamente, los tiempos van cambiando. La informática va madurando y
tanto algunos profesionales de las tecnologías de la información como algunos de sus
clientes se van dando cuenta de que se hace necesario seguir unas ciertas pautas
predefinidas en el desarrollo del software de calidad: es decir, llevar un comportamiento
metódico: seguir una metodología.
Una metodología de desarrollo de software es un conjunto de pasos y procedimientos
que deben seguirse para desarrollar software. Una metodología está compuesta por:
Cómo dividir un proyecto en etapas.
Qué tareas se llevan a cabo en cada etapa.
Qué restricciones deben aplicarse.
Qué técnicas y herramientas se emplean.
Cómo se controla y gestiona un proyecto.
2.2 Bases de Datos.
Una base de datos o banco de datos es un conjunto de datos que pertenecen al
mismo contexto almacenados sistemáticamente para su posterior uso. En este sentido,
una biblioteca puede considerarse una base de datos compuesta en su mayoría por
documentos y textos impresos en papel e indexados para su consulta. En la actualidad, y
debido al desarrollo tecnológico de campos como la informática y la electrónica, la
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 22
mayoría de las bases de datos tienen formato electrónico, que ofrece un amplio rango de
soluciones al problema de almacenar datos.
En informática existen los sistemas gestores de bases de datos, que permiten
almacenar y posteriormente acceder a los datos de forma rápida y estructurada. Las
propiedades de los sistemas gestores de bases de datos se estudian en informática.
Las aplicaciones más usuales son para la gestión de empresas e instituciones
públicas. También son ampliamente utilizadas en entornos científicos con el objeto de
almacenar la información experimental.
Tipos de bases de datos
Las bases de datos pueden clasificarse de varias maneras, de acuerdo al criterio
elegido para su clasificación:
Según la variabilidad de los datos almacenados
Bases de datos estáticas
Éstas son bases de datos de sólo lectura, utilizadas primordialmente para
almacenar datos históricos que posteriormente se pueden utilizar para estudiar el
comportamiento de un conjunto de datos a través del tiempo, realizar proyecciones y
tomar decisiones.
Bases de datos dinámicas
Éstas son bases de datos donde la información almacenada se modifica con el
tiempo, permitiendo operaciones como actualización y adición de datos, además de las
operaciones fundamentales de consulta. Un ejemplo de esto puede ser la base de datos
utilizada en un sistema de información de una tienda de abarrotes, una farmacia, etc.
Según el contenido
Bases de datos bibliográficas
Solo contienen un representante de la fuente primaria, que permite localizarla. Un
registro típico de una base de datos bibliográfica contiene información sobre el autor,
fecha de publicación, editorial, título, edición, de una determinada publicación, etc. Puede
contener un resumen o extracto de la publicación original, pero nunca el texto completo,
porque si no se estaría en presencia de una base de datos a texto completo. Como su
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 23
nombre lo indica, el contenido son cifras o números. Por ejemplo, una colección de
resultados de análisis de laboratorio, entre otras.
Bases de datos de texto completo
Almacenan las fuentes primarias, como por ejemplo, todo el contenido de todas
las ediciones de una colección de revistas científicas.
Directorios.
Un ejemplo son las guías telefónicas en formato electrónico.
Banco de imágenes, audio, video, multimedia, etc.
Bases de datos o “bibliotecas” de información Biológica.
Son bases de datos que almacenan diferentes tipos de información proveniente de
las ciencias de la vida o médicas. Se pueden considerar en varios subtipos:
Aquellas que almacenan secuencias de nucleótidos o proteínas.
Las bases de datos de rutas metabólicas.
Bases de datos de estructura, comprende los registros de datos
experimentales sobre estructuras 3D de bio-moléculas.
Bases de datos clínicas.
Bases de datos bibliográficas (biológicas).
2.3 Manejador Bases de Datos.
El sistema manejador de bases de datos es la porción más importante del software de un sistema de base de datos. Un manejador de base de datos es una colección de numerosas rutinas de software interrelacionadas, cada una de las cuales es responsable de alguna tarea específica.
Las funciones principales de un manejador de base de datos son:
Crear y organizar la Base de datos.
Establecer y mantener las trayectorias de acceso a la base de datos de tal forma que los datos puedan ser consultados rápidamente.
Manejar los datos de acuerdo a las peticiones de los usuarios.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 24
Registrar el uso de las bases de datos.
Interacción con el manejador de archivos.
Respaldo y recuperación.
Consiste en contar con mecanismos implantados que permitan la recuperación
fácilmente de los datos en caso de ocurrir fallas en el sistema de base de datos.
Control de concurrencia.
Consiste en controlar la interacción entre los usuarios concurrentes para no afectar
la inconsistencia de los datos.
Seguridad e integridad.
Consiste en contar con mecanismos que permitan el control de la consistencia de
los datos evitando que estos se vean perjudicados por cambios no autorizados o previstos.
El sistema manejador de Base de Datos está compuesto por:
El gestor de la base de datos
Se trata de un conjunto de programas no visibles al usuario final que se encargan
de la privacidad, la integridad, la seguridad de los datos y la interacción con el sistema
operativo. Proporciona una interfaz entre los datos, los programas que los manejan y los
usuarios finales. Cualquier operación que el usuario hace contra la base de datos está
controlada por el gestor. El gestor almacena una descripción de datos en lo que llamamos
diccionario de datos, así como los usuarios permitidos y los permisos. Tiene que haber un
usuario administrador encargado de centralizar todas estas tareas.
Diccionario de datos
Es una base de datos donde se guardan todas las propiedades de la base de datos,
descripción de la estructura, relaciones entre los datos, etc.
El diccionario debe contener:
La descripción externa, conceptual e interna de la base de datos.
Las restricciones sobre los datos.
El acceso a los datos.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 25
Las descripciones de las cuentas de usuario.
Los permisos de los usuarios.
Los esquemas externos de cada programa.
El administrador de la base de datos
Es una persona o grupo de personas responsables del control del sistema gestor de
base de datos.
Las principales tareas de un administrador son:
La definición del esquema lógico y físico de la base de datos.
La definición de las vistas de usuario.
La asignación y edición de permisos para los usuarios.
Mantenimiento y seguimiento de la seguridad en la base de datos.
Mantenimiento general del sistema gestor de base de datos.
2.4 Lenguaje de Programación C Sharp (C#)
El lenguaje de programación C# es un lenguaje orientado a objetos que permite a
los desarrolladores crear una amplia gama de aplicaciones sólidas y seguras que se
ejecutan en .NET Framework. Puede utilizar este lenguaje para crear aplicaciones cliente
para Windows tradicionales, servicios Web XML, componentes distribuidos, aplicaciones
cliente-servidor, aplicaciones de base de datos, y muchas tareas más. Microsoft Visual C#
2010 proporciona un editor de código avanzado, diseñadores de interfaz de usuario
prácticos, un depurador integrado y muchas otras herramientas para facilitar un rápido
desarrollo de la aplicación basado en la versión 2.0 del lenguaje C# y en .NET Framework.
La sintaxis de C# puede ser reconocida inmediatamente por cualquier persona
familiarizada con C, C++ o Java. Los desarrolladores que conocen cualquiera de estos
lenguajes pueden empezar a trabajar de forma productiva en C# en un plazo muy breve.
Como lenguaje orientado a objetos, C# admite los conceptos de encapsulamiento,
herencia y polimorfismo. Todas las variables y métodos, incluido el método principal
(main) que es el punto de entrada de la aplicación, se encapsulan dentro de definiciones
de clase. Una clase puede heredar directamente de una clase primaria, pero puede
implementar cualquier número de interfaces. Además C# facilita el desarrollo de
componentes de software a través de varias construcciones de lenguaje innovadoras,
entre las que se incluyen:
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 26
Firmas de métodos encapsulados denominadas delegados, que permiten
notificaciones de eventos con seguridad de tipos.
Propiedades, que actúan como descriptores de acceso para variables
miembro privadas.
Comentarios en línea de documentación XML.
Arquitectura de la plataforma .NET Framework
Los programas de C# se ejecutan en .NET Framework, un componente que forma
parte de Windows y que incluye un sistema de ejecución virtual. El código fuente escrito
en C# se compila en un lenguaje intermedio (IL). El código de lenguaje intermedio, junto
con recursos tales como mapas de bits y cadenas, se almacena en disco en un archivo
ejecutable denominado ensamblado, cuya extensión es .exe o .dll generalmente. Un
ensamblado contiene un manifiesto que ofrece información sobre los tipos, la versión, la
referencia cultural y los requisitos de seguridad del ensamblado.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 27
2. 5 Metodología para Desarrollar Sistemas de Información Basados en
Computadoras (LAGS)
METODOLOGÍA “LAGS”
FASE 1
ANÁLISIS
1.1 Conocimiento
del medio
ambiente
1.2
Análisis y
Diagnóstico del
Sistema Actual
1.3
Propuesta General
de Solución
FASE 2
DISEÑO
2.1 Revisión de la
Propuesta de
Análisis
2.2
Diseño Preliminar
2.3
Diseño Detallado
FASE 3
CONSTRUCCIÓN
3.1 Construcción de
Programas y/o
modelos
3.2
Desarrollo de
procedimientos de
usuario
3.3
Pruebas y
Aceptación del
sistema
FASE 4
IMPLEMENTACIÓN
4.1
Preparación de la
Implementación
4.2
Verificar Condiciones
para la
Implementación
FASE 5
OPERACIÓN
Y
MANTTO
5.1
Proceso de problemas
reportados
5.2
Proceso de solicitudes
de cambios
5.3
Modificaciones
al Sistema
5.4
Revisión y Evaluación
del Comportamiento
5.5
Identificación de nuevas
necesidades Fig. 1.2 Metodología LAG’S
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 28
2.5.1 Análisis, Evaluación y Diagnóstico del Sistema de
Información Actual
¿Qué datos o información se genera?
Los datos que se generan son campos en los cuales se tiene un registro del tipo de
equipo que entra a soporte técnico a mantenimiento, o en su defecto que ingresa debido
algún tipo de problema en su funcionamiento, se obtienen datos tales como :
Número de Ticket.
Fecha de reporte.
Status del Ticket.
Cliente.
Contacto Directo con el Cliente.
Tipo de Equipo que se reporta.
Modelo del Equipo.
Número de Serie del Equipo.
Diagnóstico.
Falla.
Periodo de Garantía.
Fecha de Inicio de la Garantía.
Fecha de Término de la Garantía.
Forma de Recepción de reporte (Teléfono o Correo Electrónico).
Observaciones.
¿Con qué frecuencia se inician las operaciones o procesos?
La frecuencia con la cual se generan las operaciones o procesos para dar de alta el
reporte fluctúa demasiado, sin embargo la empresa NEC de México S.A. de C.V. tiene un
registro en el cual se presenta que en promedio se reciben al día de 10 a 20 reportes de
equipo dañado, equipo que se recibe para mantenimiento correctivo y/o preventivo.
¿Cómo debe presentarse la información?
La información se debe de presentar en forma clara, debe de existir un formulario
comprensible y con los campos requeridos por parte del cliente para que pueda ser
llenado con facilidad y el proceso pueda ser eficiente, al momento de concluir todo el
proceso de recibir el equipo, dar de alta el reporte y posteriormente entregar el equipo al
cliente que solicito ayuda y atención por parte del área de Audiovisual es necesario que se
tenga un reporte para fines estadísticos.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 29
2.5.2 Identificación de los Elementos del Sistema Actual
Para los Procesos:
¿Qué Procesos por separado etapas o funciones conforman la Actividad actual?
Los procesos que conforman la actividad que se analiza, son las órdenes de servicio
que necesita un cliente, son procesos por separado ya que son servicios que se efectúan
en diferente horario y fecha, y cada cliente necesita algún tipo de servicio en específico.
¿Qué inicia la actividad?
La actividad se inicia cada que se recibe una llamada por parte del cliente o en su
defecto se recibe un correo electrónico por parte del cliente, y así se obtienen los campos
necesarios para generar el reporte.
¿Qué demoras ocurren o pueden ocurrir?
En ocasiones el reporte se da alta sin embargo puede ser que no se encuentre
disponible un Ingeniero que pueda atender de inmediato el reporte por lo tanto dicho
reporte puede ser atendido en unas horas o en ocasiones en unos días dependiendo de la
actividad y la carga de trabajo con la cual se encuentren los Ingenieros a cargo de atender
las solicitudes de servicio.
¿Cuánto dura la actividad?
La actividad de dar de alta el reporte dura el tiempo que necesite la persona a
cargo de atender la llamada o el correo electrónico y poder generar el reporte, sin
embargo el tiempo en el cuál se genera la orden de servicio puede fluctuar dependiendo
del tiempo que se tarde el equipo en el Centro de Servicio Autorizado por NEC de México
S.A de C.V (CENSYC).
Para los datos
¿Que datos se introducen al sistema y cuál es su origen?
Los datos que se introducen al sistema son los datos del cliente que solicita el
servicio de mantenimiento , y de igual manera es importante tener los datos del equipo
que necesita de un servicio de mantenimiento. El origen de los datos son via teléfono o vía
correo electrónico.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 30
¿Qué datos se almacenan en el sistema como parte de las actividad del mismo?
Los datos del sistema serán las entradas o registros que contendrá el formulario
para generar un reporte y los datos que entregue el CENSYC a NEC de México.
¿Quién utiliza la información producida por el sistema?
La información que se encuentra en el sistema será utilizada por los Ingenieros que
se encuentra a cargo del Área de Soprte Audiovisual de NEC de México S.A. de C.V.
¿Para qué la utiliza?
La información la utilizan los usuarios para tener conocimiento de la situación
actual de un equipo que haya entrado a algún servicio de mantenimiento o para poder
tener el control estadístico del tipo de fallas mas comúnes generadas por un equipo.
¿Qué otros datos se utilizan?
Se tiene información adicional que presentará el Centro de Servicio Autorizado por
NEC de México el CENSYC.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 31
2.5.3 Tabla Sistémica
SISTEMA ENTRADA PROCESOS SALIDA TIEMPOS VOLÚMENES DATOS CONTROLES
Proyectores Modelos de los diferentes tipos de proyectores.
Si se lanza algún nuevo producto se debe de registrar el nuevo modelo.
Modelo de los proyectores.
Cada que se genera un modelo nuevo.
Indefinido varía dependiendo de la cantidad de modelos nuevos que se lancen al mercado.
ID.
Tipo de equipo.
Modelo del equipo.
Luminosidad (Lúmenes ANSI).
Modelo del equipo.
Luminosidad.
Pantallas Modelo de los diferentes tipos de pantallas.
Si se tiene un nuevo producto en la gama de pantallas se debe de registrar.
Modelo de las pantallas
En el momento que se genera un nuevo modelo de pantalla.
Indefinido ya que depende del tiempo en el cual se lance algún nuevo producto al mercado.
ID.
Tipo de Pantalla.
Modelo de la Pantalla.
Pulgadas de la pantalla.
Modelo de la pantalla.
Reportes Información del reporte en el que se encuentran detalles de algún equipo que presente algún problema.
Al llenar el formulario para capturar los datos.
Reporte para su seguimiento.
Al momento en el que se recibe una llamada telefónica o algún correo electrónico para la atención
Indefinido ya que depende de la cantidad de reportes que se reciban diariamente.
Número de Ticket.
Fecha de Recepción.
Empresa.
Contacto de la Empresa.
Atención.
Tipo de Equipo.
Modelo Proyector.
Modelo Pantalla.
Número de Serie.
Periodo Garantía.
Inicio Garantía.
Número de Ticket.
Empresa.
Status.
Tipo de Equipo.
Modelo Proyector.
Modelo Pantalla.
Número de Serie.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 32
de algún equipo por parte del cliente.
Término Garantía.
Falla.
Diagnóstico.
Observaciones.
Status.
Equipo Tipo de equipo que ingresa.
Al llenar el formulario se especifica el tipo de equipo que se está manejando.
Información para el reporte.
Tipo de equipo que se ingresa al reporte.
Indefinido ya que depende de la cantidad de reportes que se reciban diariamente.
ID.
Equipo.
Equipo.
Recepción Forma en la cual se recibe la solicitud de atención para el equipo.
Al llenar el formulario se especifica la forma en la cual se recibió la solicitud de atención al cliente.
Información para el reporte.
Forma en la cual se recibió el reporte.
Indefinido ya que depende de la cantidad de reportes que se reciban diariamente.
ID.
Recepción.
Recepción.
Status Estado en el cuál se encuentra el reporte.
Al llenar el formulario se especifica el estado en el que se encuentra el reporte.
Información para el reporte.
Estado en el que se encuentra el reporte.
Indefinido ya que depende de la cantidad de reportes que se reciban diariamente.
ID.
Status.
Status.
Empleados Información de los empleados
Antes de dar de alta un reporte o
Acceso a los reportes.
Cada que se genera un reporte
Indefinido ya que depende de la cantidad
ID.
Nombre.
Apellido Paterno.
ID.
Contraseña.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 33
que ingresarán al sistema.
modificarlo se debe de identificar el personal.
es necesario identificarse, así mismo, si hay un nuevo empleado se da de alta.
de reportes que se reciban diariamente.
Apellido Materno.
Puesto.
Contraseña.
Empresas Información de las empresas.
Al llenar el formulario se especifica la empresa que solicita el servicio.
Información para el reporte.
Cada que se genera un reporte es necesario identificarse, así mismo, si hay una nueva empresa se da de alta.
Indefinido ya que depende de la cantidad de reportes que se reciban diariamente.
ID.
Empresa.
Contacto.
Correo Electrónico.
Teléfono.
Empresa.
Contacto.
Correo Electrónico.
Teléfono.
Fig. 1.2 Tabla Sistémica
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 34
2.6 Propuesta General de la Solución
Viendo los datos anteriormente descritos, se propone diseñar un sistema con una
interfaz gráfica atractiva para el usuario y sobre todo que sea de un fácil entendimiento
para su uso.
El usuario que se encuentre utilizando el sistema debe de tener una idea clara de
los registros que se utilizaran en el sistema y los cuales serán la base para poder crear la
base de datos, el sistema debe tener medidas de seguridad, ya que, debido a la
información que se maneja algunos campos del sistema estarán restringidos para evitar
que cualquier persona que se encuentre utilizando el sistema pueda modificar la
información, por tal motivo solo las personas autorizadas serán los únicos usuarios con los
permisos necesarios para dar de alta reportes en su debido caso poder modificar algún
tipo de información.
Los datos obtenidos al dar de alta los reportes podrán ser consultados
posteriormente para su seguimiento, y se contará con secciones en las cuales se podrá
registrar un nuevo producto ya sea un proyectos o una pantalla con la finalidad de tener
actualizada la base de datos y con esto dar una excelente atención por parte del Área de
Soporte Audiovisual.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 35
Capítulo 3:
DISEÑO Y
DESARROLLO
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 36
3.1 Diseño Preliminar
Para entender el funcionamiento del sistema, se presenta el Diagrama General de
del Sistema para poder identificar y presentar las entradas y salidas del mismo.
3.1.1 Diseño de las Salidas
Es muy común que para los usuarios, la característica más importante de un
Sistema, es la salida que produce. Si la salida no es de calidad, pueden pensar que todo el
sistema no es necesario, bueno o adecuado y por lo tanto, eviten la implementación de
dicho sistema.
Para poder presentar de una forma adecuada las salidas ante el usuario se deben
de responder las siguientes preguntas, las cuales indican que el diseño del sistema se
encuentra en buena dirección.
¿Quién recibirá la salida?
La salida servirá para que el personal del Área de Soporte Audiovisual tenga un
control sobre los reportes de los equipos dañados que reciben, con esto se desea tener un
sistema eficiente para la atención del cliente por parte del Área Audiovisual.
¿Cuál es su uso planeado?
El uso planeado de la información es de carácter informativo y también de carácter
estadístico y logístico para el control adecuado de los reportes. Existirán campos
Sistema de
Control de
Reportes de
Equipos Dañados.
Entradas. Salidas.
Diagrama General del Sistema.
Datos de Usuarios.
Datos Empresas.
Solicitud de Servicio. Orden de Servicio.
Consultas de
Seguimiento.
Consulta de Equipos.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 37
exclusivos para personal autorizado ya que el manejo de dicha información es delicada
por consiguiente existirá información de consulta e información clasificada.
¿Cuándo y con qué frecuencia se necesitan las salidas?
El tiempo y la frecuencia con la cual se necesiten las salidas dependerán de la
frecuencia con la cual los reportes se clasifiquen con estado (status) cerrado para poder
entregar una orden de servicio al cliente que solicitó algún tipo de mantenimiento
preventivo o correctivo.
¿Por cuáles medios?
El medio por el cual se mostrará y se consultará la salida de la información será
únicamente de carácter local.
3.1.2 Diseño de las Entradas
El diseño de la entrada será al momento que el personal que reciba una petición
para Soporte Técnico, en este caso existirá dos tipos de entradas mediante interfaz
gráfica. Existirá un tipo de entrada para usuario común el cual consistirá únicamente en la
consulta de la base de datos para poder revisar el estado (status) de algún reporte, y un
tipo de entrada con autorización para poder modificar algún reporte o dar de alta alguna
solicitud de mantenimiento preventivo y/o correctivo.
3.2 Diseño Detallado
3.2.1 Diccionario de Datos
El Diccionario de Datos es una lista y descripción detallada de todos los elementos
de almacenamiento de información, identificados en el conjunto de los diagramas de flujo
de datos que describen a un sistema
El diccionario de datos define los términos asociados con las estructuras de datos,
que se emplean en el desarrollo y empleo de sistemas de información.
Los datos que se almacenarán en la base de datos serán los siguientes:
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 38
Tabla Reportes.
Número de Ticket.
Fecha de Reporte.
Recepción del Reporte.
Empresa (Cliente).
Contacto directo con el Cliente.
Atención.
Tipo de Equipo.
Modelo de Pantalla.
Modelo de Proyector.
Número de Serie del Equipo.
Periodo de Garantía.
Fecha de Inicio de la Garantía.
Fecha de Término de la Garantía.
Falla.
Diagnóstico.
Observaciones.
Status del Ticket.
Tabla Modelo Proyectores.
ID.
Tipo de Proyector.
Modelo del Proyector.
Lúmenes.
Tabla Modelo Pantallas.
ID.
Tipo de Pantalla.
Modelo del Pantalla.
Resolución de la Pantalla.
Dimensión del display LCD.
Tabla de Usuarios (Empleados).
ID.
Nombre.
Apellido Paterno.
Apellido Materno.
Puesto.
Contraseña.
Tabla de Empresas.
ID.
Empresa.
Contacto.
Correo.
Teléfono.
Tabla de Recepción
ID.
Recepción.
Tabla de Tipo Equipo
ID.
Equipo.
Tabla de Estado del Reporte (Status).
ID.
Status.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 39
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
Ticket Número de Ticket. Ticket Int(Auto Increment)(PK)
11 Números (0 – 9)
FechaReporte Fecha de Recepción del Reporte. FechaReporte VarChar 20 Caracteres (A – Z) y Números.
Recepción Forma en que se recibe el Reporte. Recepción VarChar 30 Caracteres (A – Z)
Empresa Nombre de la Empresa (Cliente). Empresa VarChar Sin límite. Caracteres (A – Z)
Contacto Nombre del contacto directo con la Empresa (Cliente)
Contacto VarChar Sin límite. Caracteres (A – Z)
Atención Nombre de la persona que recibe el reporte.
Atención VarChar Sin límite. Caracteres (A – Z)
Equipo Tipo de equipo por el cual se da de alta un reporte.
Equipo VarChar 20 Caracteres (A – Z)
Modelo Modelo del Equipo que se da de alta para el reporte.
Modelo VarChar 15 Caracteres (A – Z y Números
Serie Número de Serie del equipo para el cuál se genera el reporte.
Serie VarChar 30 Caracteres (A – Z) y Números
PeriodoGarantia Periodo de duración de la Garantía el Equipo.
PeriodoGar VarChar 10 Caracteres (A – Z) y Números.
InicioGarantia Fecha de Inicio de la Garantía del Equipo. InicioGar VarChar 30 Caracteres (A – Z) y Números.
FinGarantia Fecha de término de la Garantía del Equipo.
FinGar VarChar 30 Caracteres (A – Z) y Números.
Falla Tipo de Falla que presenta el Equipo. Falla VarChar Sin límite. Caracteres (A – Z)
Diagnostico Primer Diagnóstico que recibe el Equipo. Diagnostico VarChar Sin límite. Caracteres (A – Z)
Observación Observaciones que recibe del equipo. Observación VarChar Sin Límite Caracteres (A – Z)
Status Estado en el que se encuentra el Reporte. Status VarChar 6 Caracteres (A – Z)
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 40
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Proyector Tipo de Equipo. Proyector VarChar 15 Caracteres (A – Z)
Modelo Modelo del Proyector.
ModeloPR VarChar 15 Caracteres (A – Z) y Números.
Lúmenes Intensidad de proyección de la lámpara del Proyector.
Lúmenes Int 8 Números (0 – 9)
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Pantalla Tipo de Equipo. pantalla VarChar 15 Caracteres (A – Z)
Modelo Modelo de la Pantalla.
modeloPA VarChar 15 Caracteres (A – Z) y Números.
Resolución Resolución Nativa de la Pantalla.
resolución Int 8 Números (0 – 9)
Display Medida del display LCD de la pantalla.
LCD VarChar 8 Caracteres y Números
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 41
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Nombre Nombre(s) del Empleado.
nombre VarChar 30 Caracteres (A – Z)
Apellido Paterno Apellido Paterno del Empleado.
apellido_paterno VarChar 30 Caracteres (A – Z)
Apellido Materno Apellido Materno del Empleado.
Resolución VarChar 30 Caracteres (A – Z)
Puesto Puesto que desempeña dentro de la empresa.
puesto VarChar 30 Caracteres (A – Z)
Contraseña Contraseña para el acceso al sistema.
pass VarChar Sin Límite. Caracteres y Números
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Empresa Nombre de la Empresa.
empresa VarChar Sin Límite Caracteres (A – Z) y Números.
Contacto Contacto directo con la empresa.
contacto VarChar 50 Caracteres (A – Z)
Correo Dirección de Correo electrónico del contacto directo con la empresa.
correo VarChar 8 Caracteres y Números
Teléfono Teléfono de la empresa.
telefono Int 20 Números
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 42
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Recepción Forma de recepción del reporte.
recepcion VarChar 15 Caracteres (A – Z)
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Equipo Tipo de Equipo. equipo VarChar 15 Caracteres (A – Z)
NOMBRE DESCRIPCIÓN ALIAS TIPO LONGITUD VALORES
ID Número de identificación dentro de la base de datos.
ID Int(Auto Increment) (PK)
4 Números (0 - 9)
Status Estado del reporte. status VarChar 8 Caracteres (A – Z)
Fig. 1.3 Diccionario de Datos
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 43
3.3 Diagrama Entidad Relación
El diagrama entidad relación es una representación gráfica de la estructura lógica
general de una base de datos, y se integran mediante los siguientes símbolos:
Rectángulos, representan conjunto de entidades o clases.
Elipses, representan atributos.
Rombos, representan conjuntos de relaciones o asociaciones.
Líneas, se utilizan para la conexión de atributos a los conjunto de entidades, y los
conjuntos de entidades a los conjuntos de relaciones.
El diagrama entidad relación que se construyó para el sistema, establece las relaciones
que tienen las tablas para poder dar de alta un reporte. Las relaciones que integran el
diagrama entidad relación son las siguientes:
Acceso.
Empresa.
Contacto.
Estado.
Forma de recepción.
Tipo de Equipo.
Modelo Proyector.
Modelo Pantalla.
Estado.
La relación que existe entre las tablas establece un correcto funcionamiento de la
base de datos con el sistema. Para poder realizar un reporte es necesario que primero se
identifique el usuario mediante la tabla de Empleados, esto con la finalidad de tener
seguridad en el sistema. La tabla reporte depende a su vez de las tablas: status (estado),
recepción, equipo, empresas, pantalla, proyector, empleados. El siguiente esquema
gráfico presenta la relación entre las tablas de la base de datos.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 44
Fig. 1.4 Diagrama Entidad Relación
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 45
3.4 Construcción de Programas y/o Modelos
El sistema está desarrollado completamente en lenguaje C# auxiliándose de la
herramienta Visual Studio 2010.
Un aspecto fundamental del sistema es la conexión con la base de datos la cual
será una base de datos SQL, en ella se almacenará la información de los reportes
generados y se tendrá una tabla en la cual se encontrará una base de todos los distintos
modelos de proyectores y pantallas con los cuales cuenta la empresa.
El sistema deberá ser eficiente y contar con la información detallada y actualizada
de los modelos de equipos con los que cuenta la empresa, así como, una consulta
buscando por empresa, modelo del equipo, tipo de equipo, es decir, por proyector o por
pantalla.
3.5 Desarrollo de Procedimientos del Usuario
El sistema estará diseñado para cualquier usuario, ya que el diseño de la interfaz
deberá ser amigable para el usuario; para que pueda comprender de una forma rápida e
intuitiva el funcionamiento del sistema, por tal motivo, el diseño del sistema de control de
reportes se efectuará de una forma comprensible para cualquier usuario.
El sistema contará con un menú de seis secciones mostrando un contenido claro y
detallado sin ningún tipo de confusión en su exploración. Los formularios para dar de alta
un reporte o en su debido caso dar de alta algún nuevo modelo de equipo deben de ser
formularios fáciles de entender y con una accesibilidad correcta para reducir el tiempo en
el que se registra dicho evento.
La consulta de la base de datos debe de contener información específica pero
sobre todo la información debe de estar bien organizada con la finalidad de que el usuario
pueda comprender la información que está consultando, y pueda dar una atención
inmediata.
El sistema como anteriormente se mencionó está diseñado para cualquier tipo de
usuario, permitiendo una navegación dentro del sistema sencilla, optima y mostrando la
información que el usuario necesita, con esto se busca que el usuario al momento de estar
usando el sistema se encuentre con los características específicas y la información que se
necesitan.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 46
Fig. 2.1 Pantalla de Inicio del Sistema
La pantalla de presentación denominada en inglés (Splash Screen) es una página de
inicio para proporcionar una presentación de sistema. Al iniciar el programa se ejecuta
una pantalla en la que se muestra información del sistema e indica al usuario que el
programa se está ejecutando. La pantalla de presentación es la que se presenta a
continuación:
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 47
Fig. 2.2 Pantalla Principal del Sistema
Fig. 2.3 Menú o Barra de Herramientas del Sistema
Una vez que se inicia el programa y la pantalla de bienvenida se terminó de
ejecutar, el usuario se encuentra en la pantalla principal del sistema. En ésta pantalla el
usuario empieza a interactuar con el sistema. En la pantalla se muestra el menú con el que
cuenta el usuario para realizar sus procesos.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 48
Fig. 2.4 Menú Reportes y sus opciones
Fig. 2.5 Ampliación del menú Reportes y sus opciones
La primer parte del menú se encuentra la sección de Reportes, en la cual el usuario
puede dar de alta un reporte o incluso puede modificar un reporte existente. Aquí el
usuario para poder dar de alta un reporte es necesario que se identifique como empleado
para poder tener acceso a la sección Reporte -> Nuevo. Al modificar un reporte se
presentará cuando se tenga que actualizar información de un reporte existente.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 49
Fig. 2.6 Formulario para dar de Alta un Reporte
La sección consulta no es necesario que se identifique como usuario ya que en ésta
parte del sistema será únicamente para poder realizar búsquedas de los reportes,
estableciendo distintos métodos de búsqueda.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 50
Fig. 2.8 Ampliación menú consulta y sus opciones
Fig. 2.7 Menú consulta y sus opciones
La sección Proyector presenta las opciones de Nuevo y Consultar. En ésta parte del
sistema es para poder ingresar nuevo modelos de proyectores en el caso que sea
necesario actualizar la base de datos de los modelos. La sección Consultar permite revisar
las características del modelo de proyector que se desee conocer.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 51
Fig. 2.10 Ampliación menú Proyector y sus opciones
Fig. 2.9 Menú Proyector y sus opciones
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 52
Fig. 2.10 Formulario para agregar un Proyector
Fig. 2.12 Menú Pantalla y sus opciones
Fig. 2.11 Características de Proyector
La sección Pantalla presenta las opciones de Nuevo y Consultar. En ésta parte del
sistema es para poder ingresar nuevo modelos de pantallas en el caso que sea necesario
actualizar la base de datos de los modelos de pantallas. La sección Consultar permite
revisar las características del modelo de pantalla que se desee conocer.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 53
Fig. 2.13 Ampliación menú Pantalla y sus opciones
Fig. 2.14 Características de Pantalla
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 54
3.6 Pruebas y Aceptación del Sistema
El sistema fue probado en diversos equipos de cómputo para comprobar su
correcto funcionamiento, para realizar esto fue necesario instalar el sistema utilizando
computadoras con diferentes características.
Esto se realizó con la finalidad de comprobar que el sistema sea estable en
cualquier computadora, las pruebas fueron realizadas en equipos de cómputo modernos
con procesadores potentes así como en computadoras con procesadores antiguos con
características que podrían limitar el correcto funcionamiento del sistema.
Algunos procesadores con los cuales fue probado el sistema fueron en
computadoras con procesadores Pentium IV, Atom Inside, Intel Core Duo.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 55
Capítulo 4:
IMPLEMENTACIÓN
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 56
4.1 Preparación de la Implementación
Implementar es la realización de una especificación técnica o algoritmos como un
programa, componente de software, u otro sistema de cómputo. Muchas
implementaciones son dadas según a una especificación o un estándar.
En este caso se pretende implementar un sistema de control de reportes
trabajando localmente con información que se puede encontrar en la base de datos del
sistema, se pretende llamar la atención del usuario mediante un sistema atractivo, con
una interfaz gráfica comprensible y muy llamativa.
4.2 Verificar Condiciones para Implementación
Antes de implementar el sistema, es necesario revisar algunas normas para poder
saber si el sistema puede ser utilizado por la empresa NEC de México. Este tipo de normas
que se debe de realizar son las siguientes:
Tener los permisos por parte de NEC para la utilización de las imágenes
presentadas en el sistema.
Solicitar los permisos por parte de NEC para la implementación del sistema.
Verificar la seguridad de la información manteniéndola de carácter privado para la
empresa.
Sistemas Operativos en los que puede ser ejecutado el Sistema:
Windows XP (x86) Todas las Ediciones.
Windows Vista (x86) Todas las Ediciones.
Windows 7 (x86).
Requisitos de Hardware:
Procesador a 1.6GHz o Superior
512 MB memoria RAM en Sistemas Operativos de 32 Bits.
512 MB para ejecutar en máquina virtual.
1 GB disponible en disco duro.
5400 RPM de disco duro.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 57
Este sistema se ha ido perfeccionando de acuerdo a las adecuaciones necesarias
que han solicitado los encargados del manejo del control de los reportes, la empresa ha
reducido sus costos y sus tiempos. El costo del Sistema para el Control de Reportes es el
siguiente:
Considerando un salario mensual de acuerdo a lo establecido, en los
salarios mínimos de acuerdo a cada profesión de la Ley Federal del Trabajo
se observa que el salario que se percibe es de: $ 12,000 M.N.
Si no existiera un salario se consideraría un costo de $ 150 M.N. por hora de
trabajo invertido.
El tiempo que llevo realizar el sistema fue de 6 meses considerando el
tiempo que llevo realizar el análisis y la investigación en la empresa, así
como, el tiempo que llevo programar el sistema.
La licencia de Microsoft Visual Studio Professional 2010 con MSDN incluye:
Software y servicios para uso en el área de producción.
Herramienta principal para desarrollo/prueba Visual Studio Professional 2010
Visual Studio Team Foundation Server 2010 Visual Studio Team Explorer Everywhere 2010
Visual Studio LightSwitch
Software para desarrollo y pruebas
Windows, Windows Server Microsoft SQL Server
Kits de herramientas, kits de desarrollo de software, kits de desarrollo de controladores
Ventajas Adicionales
Incidentes de soporte técnico Soporte técnico prioritario en los foros de MSDN
Microsoft E-Learningcolecciones de cursos (normalmente de 20 horas cada uno; por año
calendario)
MSDN Magazine Boletín de MSDN Flash
MSDN Online Concierge Ofertas especiales de Microsoft y asociados
El costo de del Microsoft Visual Studio es de: $15,358.35 M.N.
Fig. 2.1 Características Visual Studio 2010
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 58
Por consiguiente el costo total del Sistema para el Control de Reportes es
Costo del Sistema para el Control de Reportes de Equipo Dañado
Salario Mínimo Mensual
$ 12,000 M.N. Tiempo: 6 Meses 6 * 12,000 $ 72,000 M.N.
Licencia $ 15,385.35 M.N. Tiempo: 1 Año $ 15,385.35 M.N.
Total: $ 87,385.35
Costo del Sistema para el Control de Reportes de Equipo Dañado
Cobro por Hora de Trabajo
$ 150 M.N Tiempo: 4 Hrs diarias * 5 días *4 Semanas * 6 Meses
480 Hrs * 150
$ 72,000 M.N.
Licencia $ 15,385.35 M.N. Tiempo: 1 Año $ 15,385.35 M.N.
Total: $ 87,385.35
4.3 Proceso de Problemas Reportados
Los problemas que reporten los usuarios al utilizar el sistema de control de
reportes se analizarán al momento que se reciba esa queja, se verificará que
efectivamente existe el problema que el usuario ha reportado, si es así entonces se
evaluará y se procederá a corregir el problema, en dado caso de que el usuario haya
reportado un problema y dicho evento no sea cierto, se notificará que se ha revisado el
problema que reportó, y se le invitará al usuario a que acceda nuevamente al sistema para
que verifique que no existe problema alguno.
Se tendrá una bitácora, una base de datos con los problemas que los usuarios han
reportado para que así se tenga un control estadístico de cómo está funcionando el
sistema y posteriormente analizar y evaluar, si es necesario realizar una corrección en el
diseño del sistema, y la urgencia con la cual se debe realizar el cambio, así como, se
evaluará la falla más común para corregir rápidamente ese problema.
4.4 Proceso de Solicitudes de Cambio
Una vez que los usuarios han utilizado el sistema de control de reportes y han
realizado sus comentarios, queja y sugerencias, se considerarán todas esas peticiones que
realizan los usuarios para mejorar el ambiente del sistema.
Fig. 2.2 Costo del Sistema por Salario Mínimo
Fig. 2.3 Costo del Sistema por Horas de Trabajo
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 59
Estas peticiones se tomarán en cuenta y se cambiará el diseño del sistema de
control de reportes de acuerdo a lo sugerido por los usuarios y con esto se pretende que
el usuario esté satisfecho y sobre todo pueda trabajar de una forma más eficiente.
4.5 Modificaciones del Sistema
Las modificaciones del sistema que los clientes buscan se realizarán en diversos
lapsos de tiempo, primero se revisará las quejas más comunes y se corregirá de una
manera oportuna dicho problema.
Las modificaciones que los clientes hacen llegar se realizarán periódicamente ya
que primero se necesita realizar una evaluación del nuevo diseño que le propuso el
usuario, ya sea cambiar secciones del menú o incluso agregar más secciones o campos en
las bases de datos, todo esto se debe de analizar y evaluar minuciosamente para que el
sistema tenga todas las características que el usuario desea.
4.6 Identificación de Nuevas Necesidades
Ya que se han realizado las modificaciones necesarias que solicitó el usuario, el
sistema no se deja “olvidado” debe de tener un mantenimiento constante, se tendrá
comunicación continua con el usuario para poder mejorar el sistema de acuerdo a las
futuras necesidades que se presenten en el Área Audiovisual de NEC de México S.A. de
C.V.
La observación por parte del administrador del sistema y sobre todo de las
personas que estarán en el constante uso del sistema deberá mantener contacto con el
diseñador del sistema para presentar sus observaciones y dar un mantenimiento
constante al sistema y así asegurar su óptimo funcionamiento.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 60
Conclusiones
El sistema de control de reportes se mantendrá en un periodo de prueba, pero se
ha observado que el proceso para poder dar de alta un reporte y mantener el control y el
seguimiento del mismo, ha mejorado y la atención que otorga el Área de Soporte
Audiovisual a sus clientes ha sido más eficiente.
Antes de que el sistema estuviera implementado se podía observar que existía un
problema al administrar los reportes, ya que no existía un control de los mismos y en
ocasiones era complicado saber si ya se había dado una atención a cierto reporte, o
simplemente no se tenía un control sobre los reportes que se encontraban con el estado
de abierto (Open). Anteriormente el proceso que el Área seguía para dar de alta un
reporte era poco eficiente ya que se debía realizar de forma manual utilizando diversos
programas lo cual hacía el proceso largo y lento.
Con el sistema actualmente implementado se observa que el proceso es eficiente,
ya que no es necesario abrir diversos programas para dar de alta un reporte, esto hace
que se mantenga un orden en el proceso y sobre todo un control en los reportes
realizados.
Como conclusiones del desarrollo del Sistema de Cómputo para el Control de
Reportes de Equipos Dañados para la Empresa NEC de México S.A. de C.V. en el Área
Audiovisual se pueden listar las siguientes:
Se desarrolló una herramienta capaz de manipular, controlar y gestionar los
reportes del Área Audiovisual.
Se evitó el uso de diferentes programas centralizando todo el proceso en el
Sistema de Control de Reportes.
La información se mantiene de una forma más controlada y organizada.
Se integró el Sistema de Control de Reportes de Equipos Dañados a las
actividades diarias de la empresa.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 61
Recomendaciones
El trabajo que aquí se presenta ofrece oportunidades amplias para su
perfeccionamiento y profundización, pero difícilmente para ser tomado como otro posible
tema de tesis, esto debido a que ya la base y estructura del sistema están completamente
desarrolladas, lo cual indica que la profundización puede ser vista a niveles de nuevos
reportes, actualización de algún campo que requiera el reporte, nueva relación entre las
tablas de la base de datos, automatización de tareas.
A largo plazo se planea el desarrollo de nuevas tareas y procesos, también existe la
posibilidad de extender el sistema al resto de las áreas de la empresa. Éste caso en
particular, el Sistema debe ser implementado en el área de Soporte Audiovisual ya que
constantemente deben de estar atendiendo peticiones y solventando eventos en tiempos
prestablecidos, manipulando toda una serie de datos o elementos los cuales permiten
simplificar el buen desempeño de sus actividades.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 62
Índice de Figuras
FIG. 1.1 PRESENCIA NEC EN TODO EL MUNDO .......................................................................................... 10
FIG. 1.2 VALORES REPRESENTATIVOS DE NEC ........................................................................................... 11
FIG. 1.3 OFICINAS ALREDEDOR DEL MUNDO ............................................................................................. 12
FIG. 1.4 OFICINAS EN MÉXICO ................................................................................................................... 13
FIG. 1.5 ÁREAS NEC DE MÉXICO S.A. DE C.V. ............................................................................................. 13
FIG. 1.6 LÍNEA DE PRODUCTOS DE REDES EMPRESARIALES ....................................................................... 14
FIG. 1.7 LÍNEA DE PRODUCTOS DEL ÁREA AUDIOVISUAL. .......................................................................... 14
FIG. 1.8 DIAGRAMA DE FLUJO ................................................................................................................... 19
FIG. 2.1 PANTALLA DE INICIO DEL SISTEMA ................................................................................................ 46
FIG. 2.2 PANTALLA PRINCIPAL DEL SISTEMA .............................................................................................. 47
FIG. 2.3 MENÚ O BARRA DE HERRAMIENTAS DEL SISTEMA ....................................................................... 47
FIG. 2.4 MENÚ REPORTES Y SUS OPCIONES ............................................................................................... 48
FIG. 2.5 AMPLIACIÓN DEL MENÚ REPORTES Y SUS OPCIONES ................................................................... 48
FIG. 2.6 FORMULARIO PARA DAR DE ALTA UN REPORTE ........................................................................... 49
FIG. 2.7 MENÚ CONSULTA Y SUS OPCIONES ............................................................................................... 50
FIG. 2.8 AMPLIACIÓN MENÚ CONSULTA Y SUS OPCIONES ......................................................................... 50
FIG. 2.9 MENÚ PROYECTOR Y SUS OPCIONES ............................................................................................. 51
FIG. 2.10 AMPLIACIÓN MENÚ PROYECTOR Y SUS OPCIONES ..................................................................... 51
FIG. 2.11 CARACTERÍSTICAS DE PROYECTOR .............................................................................................. 52
FIG. 2.12 MENÚ PANTALLA Y SUS OPCIONES ............................................................................................. 52
FIG. 2.10 FORMULARIO PARA AGREGAR UN PROYECTOR .......................................................................... 52
FIG. 2.13 AMPLIACIÓN MENÚ PANTALLA Y SUS OPCIONES ........................................................................ 53
FIG. 2.14 CARACTERÍSTICAS DE PANTALLA ................................................................................................. 53
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 63
Índice de Tablas
FIG. 1.2 METODOLOGÍA LAG’S ................................................................................................................... 27
FIG. 1.2 TABLA SISTÉMICA ......................................................................................................................... 33
FIG. 1.3 DICCIONARIO DE DATOS ............................................................................................................... 42
FIG. 1.4 DIAGRAMA ENTIDAD RELACIÓN ................................................................................................... 44
FIG. 2.1 CARACTERÍSTICAS VISUAL STUDIO 2010 ....................................................................................... 57
FIG. 2.2 COSTO DEL SISTEMA POR SALARIO MÍNIMO ................................................................................. 58
FIG. 2.3 COSTO DEL SISTEMA POR HORAS DE TRABAJO ............................................................................. 58
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 64
Fuentes Bibliográficas
Ian Sommerville, Ingeniería Del Software, Pearson Educación, 2005.
F. Alonso Amo y Loïc Martínez Normand, Introducción a la Ingeniería del software, Delta
Publicaciones, 2005.
Marco Besteiro y Miguel Rodríguez, Controles de Validación, Libre, 2010.
Jett Ferguson, La biblia de C#, Anaya Multimedia, 2003.
Carlos Muñoz Raso, Cómo elaborar una investigación de tesis, Prentice Hall, 1998.
Nacho Cabanes, Introducción a la programación con C#, Libre, 2006.
Yolanda Cerezo López, Rafael Caballero Roldán, Olga Peñalba Rodríguez, Iniciación a la
programación en C#, 2006.
Pablo Lugo, Roderick Rangel, Sistema de Incidencias MSIS de Mega Soft Computación C.A.
basado en Help Desk y sistemas de ticketing (Issue tracking system o trouble ticketing).
Tesis, Universidad Católica Andrés Bello, 2007.
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 65
Fuentes Electrónicas
http://mygnet.net/manuales/csharp/creacion_de_reportes_en_visual_c_sharp.754
http://msdn.microsoft.com/es-es/library/bb629268(v=vs.90).aspx
http://alarcos.inf-cr.uclm.es/doc/ISOFTWAREI/Tema04.pdf
http://geeks.ms/blogs/lfranco/archive/2010/11/26/howto-crear-una-pantalla-de-inicio-splash-
screen.aspx
http://windowsclient.net/blogs/linkecubeko/archive/2009/05/01/crear-un-instalador-para-
windowsapplication-en-visual-studio-paso-a-paso.aspx
http://msdn.microsoft.com/es-es/library/bb629268(v=vs.90).aspx
http://giovannidotnet.wordpress.com/2011/04/15/creacin-de-reportes-con-crystal-report-con-
visual-studio-2010-en-windows-form/
http://www.onglasses.net/Default.aspx?id=1115
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 66
Anexos
Código Fuente utilizado en el Sistema para el Control de Reportes de Equipo Dañado de la
Empresa NEC de México S.A. de C.V.
Menú Principal
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace NEC_Windows_Form { public partial class Principal : Form { public Principal() { InitializeComponent(); this.Load += new EventHandler(Principal_Load); } private void Principal_Load(object sender, EventArgs e) { showSplashScreen(); } private void showSplashScreen() { using (fSplashScreen fsplash = new fSplashScreen()) { if (fsplash.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) { this.Close(); } else { this.WindowState = FormWindowState.Maximized; } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 67
private void salirDelSistemaToolStripMenuItem_Click(object sender, EventArgs e) { //Salir del Sistema this.Close(); } private void acercaDeToolStripMenuItem_Click(object sender, EventArgs e) { //Informacion del Sistema "Acerca de" Acerca_de Info = new Acerca_de(); Info.Show(this); } private void nuevoToolStripMenuItem_Click(object sender, EventArgs e) { //Agregar Nuevo Reporte Agregar NuevoAgregar = new Agregar(); //Instanciar elemento NuevoAgregar.Show(this); // Mostrar objeto instanciado, método show acompañado de This } private void modificarToolStripMenuItem_Click(object sender, EventArgs e) { //Modificar Reporte Existente Modificar NuevoModificar = new Modificar(); //Instanciar elemento NuevoModificar.Show(this); // Mostrar objeto instanciado, método show acompañado de This } private void Principal_Load_1(object sender, EventArgs e) { } private void empresaToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Empresa Buscar_Empresa Buscar = new Buscar_Empresa(); Buscar.Show(this); } private void modeloDelEquipoToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Reporte Modelo Proyector Buscar_Modelo Buscar = new Buscar_Modelo(); Buscar.Show(this); } private void númeroDeTicketToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Ticket Buscar_Ticket Buscar = new Buscar_Ticket(); Buscar.Show(this); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 68
private void tipoDeEquipoToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Tipo Equipo Buscar_Equipo Buscar = new Buscar_Equipo(); Buscar.Show(this); } private void nuevoToolStripMenuItem1_Click(object sender, EventArgs e) { //Agregar nuevo modelo de proyector Proyector_Nuevo Proyector_Nuevo = new Proyector_Nuevo(); Proyector_Nuevo.Show(this); } private void consultarToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar un Proyector Proyector_Consulta Proyector_Consulta = new Proyector_Consulta(); Proyector_Consulta.Show(this); } private void nuevoToolStripMenuItem2_Click(object sender, EventArgs e) { //Agregar nuevo modelo de proyector Pantalla_Nuevo Pantalla_Nuevos = new Pantalla_Nuevo(); Pantalla_Nuevos.Show(this); } private void consultarToolStripMenuItem1_Click(object sender, EventArgs e) { //Buscar un Proyector Pantalla_Consulta Pantalla_Consultar = new Pantalla_Consulta(); Pantalla_Consultar.Show(this); } private void modeloDePantallaToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Reporte Modelo de Pantalla Buscar_Modelo_Pantalla Buscar = new Buscar_Modelo_Pantalla(); Buscar.Show(this); } private void statusToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Status Busca_Status BuscarSta = new Busca_Status(); BuscarSta.Show(this); } private void númeroDeSerieToolStripMenuItem_Click(object sender, EventArgs e) { //Buscar Serie Buscar_Serie BuscarSe = new Buscar_Serie(); BuscarSe.Show(this); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 69
private void nuevoToolStripMenuItem3_Click(object sender, EventArgs e) { //Nuevo empleado empleado_nuevo nuevoem = new empleado_nuevo(); nuevoem.Show(this); } private void actualizarToolStripMenuItem_Click(object sender, EventArgs e) { //Nuevo empleado empleado_modificar modiem = new empleado_modificar(); modiem.Show(this); } private void nuevoToolStripMenuItem4_Click(object sender, EventArgs e) { Empresa_nuevo emnue = new Empresa_nuevo(); emnue.Show(this); } private void consultarToolStripMenuItem2_Click(object sender, EventArgs e) { Empresa_consulta emcon = new Empresa_consulta(); emcon.Show(this); } private void imprimirToolStripMenuItem_Click(object sender, EventArgs e) { Imprimir_Reporte imp = new Imprimir_Reporte(); imp.Show(this); } } }
Agregar Nuevo Reporte
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 70
using System.Configuration; namespace NEC_Windows_Form { public partial class Agregar : Form { public Agregar() { InitializeComponent(); } private void Agregar_Load(object sender, EventArgs e) { TBEmpleado.Focus(); //Funciones iniciales Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBModeloP.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBModeloP.AutoCompleteMode = AutoCompleteMode.Suggest; TBModeloP.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Pantalla TBModeloPAN.AutoCompleteCustomSource = AutoCompleClassPantalla.Autocomplete(); TBModeloPAN.AutoCompleteMode = AutoCompleteMode.Suggest; TBModeloPAN.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Recepcion TBRecepcion.AutoCompleteCustomSource = AutoCompleClassRecepcion.Autocomplete(); TBRecepcion.AutoCompleteMode = AutoCompleteMode.Suggest; TBRecepcion.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Equipo TBEquipo.AutoCompleteCustomSource = AutoCompleClassEquipo.Autocomplete(); TBEquipo.AutoCompleteMode = AutoCompleteMode.Suggest; TBEquipo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Status TBStatus.AutoCompleteCustomSource = AutoCompleClassStatus.Autocomplete(); TBStatus.AutoCompleteMode = AutoCompleteMode.Suggest; TBStatus.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Empresa TBEmpresa.AutoCompleteCustomSource = AutoCompleClassEmpresas.Autocomplete(); TBEmpresa.AutoCompleteMode = AutoCompleteMode.Suggest; TBEmpresa.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Contacto TBContacto.AutoCompleteCustomSource = AutoCompleClassContacto.Autocomplete(); TBContacto.AutoCompleteMode = AutoCompleteMode.Suggest; TBContacto.AutoCompleteSource = AutoCompleteSource.CustomSource;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 71
//cargar los datos para el autocomplete del textbox Atención TBAtencion.AutoCompleteCustomSource = AutoCompleClassAtencion.Autocomplete(); TBAtencion.AutoCompleteMode = AutoCompleteMode.Suggest; TBAtencion.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private void Interface_Inicial() { TBEmpleado.Focus(); LBEmpleado.Enabled = true; TBEmpleado.Enabled = true; LBContra.Enabled = true; TBContra.Enabled = true; BTNCancelar.Enabled = true; BTNGuardar.Enabled = true; BTNEntrar.Enabled = true; LBTicket.Enabled = false; TBTicket.Enabled = false; LBFecha.Enabled = false; DFecha.Enabled = false; LBRecepcion.Enabled = false; TBRecepcion.Enabled = false; LBEmpresa.Enabled = false; TBEmpresa.Enabled = false; LBContacto.Enabled = false; TBContacto.Enabled = false; LBAtencion.Enabled = false; TBAtencion.Enabled = false; LBEquipo.Enabled = false; TBEquipo.Enabled = false; LBProyector.Enabled = false; TBModeloP.Enabled = false; LBPantalla.Enabled = false; TBModeloPAN.Enabled = false; LBSerie.Enabled = false; TBSerie.Enabled = false; LBGarantia.Enabled = false; TBGarantia.Enabled = false; LBIniGaran.Enabled = false; DInicioGarantia.Enabled = false; LBTermiGara.Enabled = false; DTerminoGarantia.Enabled = false; LBFalla.Enabled = false; TBFalla.Enabled = false; LBDiagnostico.Enabled = false; TBDiagnostico.Enabled = false; LBObservaciones.Enabled = false; TBObservaciones.Enabled = false; LBStatus.Enabled = false; TBStatus.Enabled = false;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 72
BTNGuardar.Enabled = false; TBEmpleado.Focus(); } private void BTNGuardar_Click(object sender, EventArgs e) { SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); if (oreporte.AgregaReporte(DFecha.Text, TBRecepcion.Text, TBEmpresa.Text, TBContacto.Text, TBAtencion.Text, TBEquipo.Text, TBModeloP.Text, TBModeloPAN.Text, TBSerie.Text, TBGarantia.Text, DInicioGarantia.Text, DTerminoGarantia.Text, TBFalla.Text, TBDiagnostico.Text, TBObservaciones.Text, TBStatus.Text)) { MessageBox.Show("Reporte agregado correctamente","Agregado",MessageBoxButtons.OK); } else { MessageBox.Show("Error al agregar el reporte " + oreporte.mensaje,"Error",MessageBoxButtons.OK,MessageBoxIcon.Error); } Limpiar_Formulario(); //Limpia el formulario //Interface_Inicial(); //Prepara la interfaz del formulario inicial*/ } private void Limpiar_Formulario() { TBAtencion.Clear(); TBContacto.Clear(); TBDiagnostico.Clear(); TBEmpresa.Clear(); TBEquipo.Clear(); TBFalla.Clear(); TBGarantia.Clear(); TBModeloP.Clear(); TBModeloPAN.Clear(); TBObservaciones.Clear(); TBRecepcion.Clear(); TBSerie.Clear(); TBStatus.Clear(); TBTicket.Clear(); } private void Interface_Datos() { LBEmpleado.Enabled = false; TBEmpleado.Enabled = false; LBContra.Enabled = false; TBContra.Enabled = false; BTNCancelar.Enabled = true; BTNEntrar.Enabled = false;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 73
TBRecepcion.Focus(); LBTicket.Enabled = true; TBTicket.Enabled = true; LBFecha.Enabled = true; DFecha.Enabled = true; LBRecepcion.Enabled = true; TBRecepcion.Enabled = true; LBEmpresa.Enabled = true; TBEmpresa.Enabled = true; LBContacto.Enabled = true; TBContacto.Enabled = true; LBAtencion.Enabled = true; TBAtencion.Enabled = true; LBEquipo.Enabled = true; TBEquipo.Enabled = true; LBProyector.Enabled = true; TBModeloP.Enabled = true; LBPantalla.Enabled = true; TBModeloPAN.Enabled = true; LBSerie.Enabled = true; TBSerie.Enabled = true; LBGarantia.Enabled = true; TBGarantia.Enabled = true; LBIniGaran.Enabled = true; DInicioGarantia.Enabled = true; LBTermiGara.Enabled = true; DTerminoGarantia.Enabled = true; LBFalla.Enabled = true; TBFalla.Enabled = true; LBDiagnostico.Enabled = true; TBDiagnostico.Enabled = true; LBObservaciones.Enabled = true; TBObservaciones.Enabled = true; LBStatus.Enabled = true; TBStatus.Enabled = true; BTNGuardar.Enabled = true; TBRecepcion.Focus(); } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 74
adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return coleccion; } } public static class AutoCompleClassPantalla { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 75
return coleccion; } } public static class AutoCompleClassRecepcion { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM recepcion"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["recepcion"])); } return coleccion; } } public static class AutoCompleClassEquipo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True";
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 76
reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM equipo"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["equipo"])); } return coleccion; } } public static class AutoCompleClassStatus { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM status"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 77
AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["status"])); } return coleccion; } } public static class AutoCompleClassEmpresas { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM empresas"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["empresa"])); } return coleccion; } } public static class AutoCompleClassContacto { //método para cargar los datos de la base de datos public static DataTable Datos() {
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 78
DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM empresas"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["contacto"])); } return coleccion; } } public static class AutoCompleClassAtencion { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM reporte"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 79
} //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["atencion"])); } return coleccion; } } private bool BuscarReporte(string ticket) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT MAX(ticket)+1 AS ticket FROM reporte"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box TBTicket.Text = ds.Tables[0].Rows[0]["ticket"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 80
private void BTNEntrar_Click(object sender, EventArgs e) { SqlConnection cn = new SqlConnection(); cn.ConnectionString="Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; try { if (BuscarReporte(TBTicket.Text) == true) { //MessageBox.Show("Reporte Encontrado ", "Mensaje"); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje",MessageBoxButtons.OK,MessageBoxIcon.Error); TBTicket.Focus(); } SqlCommand cmd = new SqlCommand("SELECT ID,pass FROM empleados WHERE ID='" + TBEmpleado.Text + "' AND pass='" + TBContra.Text + "' ",cn); cn.Open(); cmd.ExecuteNonQuery(); DataSet ds = new DataSet(); SqlDataAdapter da = new SqlDataAdapter(cmd); da.Fill(ds,"empleados"); DataRow dro; dro = ds.Tables["empleados"].Rows[0]; if((TBEmpleado.Text == dro["ID"].ToString()) || (TBContra.Text == dro["pass"].ToString())) { MessageBox.Show("Bienvenido, puedes dar de alta un reporte","Mensaje",MessageBoxButtons.OK,MessageBoxIcon.Information); Interface_Datos(); } } catch { MessageBox.Show("Los datos son incorrectos. Ingreselos nuevamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); Interface_Inicial(); } finally { cn.Close(); } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 81
Modificar Reporte
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Modificar : Form { public Modificar() { InitializeComponent(); } private void Modificar_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBModeloP.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBModeloP.AutoCompleteMode = AutoCompleteMode.Suggest; TBModeloP.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Pantalla TBModeloPAN.AutoCompleteCustomSource = AutoCompleClassPantalla.Autocomplete(); TBModeloPAN.AutoCompleteMode = AutoCompleteMode.Suggest; TBModeloPAN.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Recepcion TBRecepcion.AutoCompleteCustomSource = AutoCompleClassRecepcion.Autocomplete(); TBRecepcion.AutoCompleteMode = AutoCompleteMode.Suggest; TBRecepcion.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Equipo TBEquipo.AutoCompleteCustomSource = AutoCompleClassEquipo.Autocomplete(); TBEquipo.AutoCompleteMode = AutoCompleteMode.Suggest; TBEquipo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Status
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 82
TBStatus.AutoCompleteCustomSource = AutoCompleClassStatus.Autocomplete(); TBStatus.AutoCompleteMode = AutoCompleteMode.Suggest; TBStatus.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNCANCELAR_Click_1(object sender, EventArgs e) { this.Close(); } private void Interface_Inicial() { TBEmpleado.Focus(); LBEmpleado.Enabled = true; TBEmpleado.Enabled = true; LBContra.Enabled = true; TBContra.Enabled = true; BTNCANCELAR.Enabled = true; BTNGuardar.Enabled = false; BTNEntrar.Enabled = true; LBBUSCATICKET.Enabled = false; TBTICKET.Enabled = false; BTNBUSCAR.Enabled = false; LBTicket.Enabled = false; TBNoTicket.Enabled = false; LBFecha.Enabled = false; DFecha.Enabled = false; LBRecepcion.Enabled = false; TBRecepcion.Enabled = false; LBEmpresa.Enabled = false; TBEmpresa.Enabled = false; LBContacto.Enabled = false; TBContacto.Enabled = false; LBAtencion.Enabled = false; TBAtencion.Enabled = false; LBEquipo.Enabled = false; TBEquipo.Enabled = false; LBProyector.Enabled = false; TBModeloP.Enabled = false; LBPantalla.Enabled = false; TBModeloPAN.Enabled = false; LBSerie.Enabled = false; TBSerie.Enabled = false; LBGarantia.Enabled = false; TBGarantia.Enabled = false; LBInicioGarantia.Enabled = false; DInicioGarantia.Enabled = false; LBTerminoGarantia.Enabled = false; DTerminoGarantia.Enabled = false; LBFalla.Enabled = false; TBFalla.Enabled = false; LBDiagnostico.Enabled = false; TBDiagnostico.Enabled = false; LBObservaciones.Enabled = false; TBObservaciones.Enabled = false; LBStatus.Enabled = false; TBStatus.Enabled = false;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 83
TBEmpleado.Focus(); } private void Interface_Datos() { LBEmpleado.Enabled = false; TBEmpleado.Enabled = false; LBContra.Enabled = false; TBContra.Enabled = false; BTNCANCELAR.Enabled = true; BTNEntrar.Enabled = false; LBBUSCATICKET.Enabled = true; TBTICKET.Enabled = true; BTNBUSCAR.Enabled = true; LBTicket.Enabled = true; TBNoTicket.Enabled = true; LBFecha.Enabled = false; DFecha.Enabled = false; LBRecepcion.Enabled = true; TBRecepcion.Enabled = true; LBEmpresa.Enabled = true; TBEmpresa.Enabled = true; LBContacto.Enabled = true; TBContacto.Enabled = true; LBAtencion.Enabled = true; TBAtencion.Enabled = true; LBEquipo.Enabled = true; TBEquipo.Enabled = true; LBProyector.Enabled = true; TBModeloP.Enabled = true; LBPantalla.Enabled = true; TBModeloPAN.Enabled = true; LBSerie.Enabled = true; TBSerie.Enabled = true; LBGarantia.Enabled = true; TBGarantia.Enabled = true; LBInicioGarantia.Enabled = true; DInicioGarantia.Enabled = true; LBTerminoGarantia.Enabled = true; DTerminoGarantia.Enabled = true; LBFalla.Enabled = true; TBFalla.Enabled = true; LBDiagnostico.Enabled = true; TBDiagnostico.Enabled = true; LBObservaciones.Enabled = true; TBObservaciones.Enabled = true; LBStatus.Enabled = true; TBStatus.Enabled = true; BTNGuardar.Enabled = true; TBRecepcion.Focus(); } private void Interface_Datos_Dos() { LBEmpleado.Enabled = false; TBEmpleado.Enabled = false; LBContra.Enabled = false; TBContra.Enabled = false;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 84
BTNCANCELAR.Enabled = true; BTNGuardar.Enabled = false; BTNEntrar.Enabled = false; LBBUSCATICKET.Enabled = true; TBTICKET.Enabled = true; BTNBUSCAR.Enabled = true; LBTicket.Enabled = false; TBNoTicket.Enabled = false; LBFecha.Enabled = false; DFecha.Enabled = false; LBRecepcion.Enabled = false; TBRecepcion.Enabled = false; LBEmpresa.Enabled = false; TBEmpresa.Enabled = false; LBContacto.Enabled = false; TBContacto.Enabled = false; LBAtencion.Enabled = false; TBAtencion.Enabled = false; LBEquipo.Enabled = false; TBEquipo.Enabled = false; LBProyector.Enabled = false; TBModeloP.Enabled = false; LBPantalla.Enabled = false; TBModeloPAN.Enabled = false; LBSerie.Enabled = false; TBSerie.Enabled = false; LBGarantia.Enabled = false; TBGarantia.Enabled = false; LBInicioGarantia.Enabled = false; DInicioGarantia.Enabled = false; LBTerminoGarantia.Enabled = false; DTerminoGarantia.Enabled = false; LBFalla.Enabled = false; TBFalla.Enabled = false; LBDiagnostico.Enabled = false; TBDiagnostico.Enabled = false; LBObservaciones.Enabled = false; TBObservaciones.Enabled = false; LBStatus.Enabled = false; TBStatus.Enabled = false; TBTICKET.Focus(); } private void Limpiar_Formulario() { TBAtencion.Clear(); TBContacto.Clear(); TBDiagnostico.Clear(); TBEmpresa.Clear(); TBEquipo.Clear(); TBFalla.Clear(); TBGarantia.Clear(); TBModeloP.Clear(); TBModeloPAN.Clear(); TBObservaciones.Clear(); TBRecepcion.Clear(); TBSerie.Clear();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 85
TBStatus.Clear(); TBNoTicket.Clear(); } private void BTNBUSCAR_Click(object sender, EventArgs e) { if (BuscarReporte(TBTICKET.Text) == true) { MessageBox.Show("Reporte Encontrado ", "Mensaje"); Interface_Datos(); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); TBTICKET.Focus(); } } private bool BuscarReporte(string ticket) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM reporte WHERE ticket='" + ticket+"'"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box TBNoTicket.Text = ds.Tables[0].Rows[0]["ticket"].ToString(); DFecha.Text = ds.Tables[0].Rows[0]["fecha_reporte"].ToString(); TBRecepcion.Text = ds.Tables[0].Rows[0]["forma_recepcion"].ToString(); TBEmpresa.Text = ds.Tables[0].Rows[0]["empresa"].ToString(); TBContacto.Text = ds.Tables[0].Rows[0]["contacto"].ToString(); TBAtencion.Text = ds.Tables[0].Rows[0]["atencion"].ToString();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 86
TBEquipo.Text = ds.Tables[0].Rows[0]["tipo_equipo"].ToString(); TBModeloP.Text = ds.Tables[0].Rows[0]["modelo_proyector"].ToString(); TBModeloPAN.Text =ds.Tables[0].Rows[0]["modelo_pantalla"].ToString(); TBSerie.Text = ds.Tables[0].Rows[0]["serie_equipo"].ToString(); TBGarantia.Text = ds.Tables[0].Rows[0]["garantia"].ToString(); DInicioGarantia.Text = ds.Tables[0].Rows[0]["inicio_garantia"].ToString(); DTerminoGarantia.Text = ds.Tables[0].Rows[0]["termino_garantia"].ToString(); TBFalla.Text = ds.Tables[0].Rows[0]["falla"].ToString(); TBDiagnostico.Text = ds.Tables[0].Rows[0]["diagnostico"].ToString(); TBObservaciones.Text = ds.Tables[0].Rows[0]["observaciones"].ToString(); TBStatus.Text = ds.Tables[0].Rows[0]["status"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } private bool ModificarReporte(string fecha_reporte, string forma_recepcion, string empresa, string contacto, string atencion, string tipo_equipo, string modelo_Proyector, string modelo_Pantalla, string serie_equipo, string garantia, string inicio_garantia, string termino_garantia, string falla, string diagnostico, string observaciones, string status) { //CONEXION SqlConnection Conexion = new SqlConnection(); Conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "UPDATE reporte SET "; CadenaSQL = CadenaSQL + "fecha_reporte = '" + fecha_reporte + "',"; CadenaSQL = CadenaSQL + "forma_recepcion = '" + forma_recepcion + "',"; CadenaSQL = CadenaSQL + "empresa = '" + empresa + "',"; CadenaSQL = CadenaSQL + "contacto = '" + contacto + "',"; CadenaSQL = CadenaSQL + "atencion = '" + atencion + "',"; CadenaSQL = CadenaSQL + "tipo_equipo = '" + tipo_equipo + "',"; CadenaSQL = CadenaSQL + "modelo_Proyector = '" + modelo_Proyector + "',"; CadenaSQL = CadenaSQL + "modelo_Pantalla = '" + modelo_Pantalla + "',"; CadenaSQL = CadenaSQL + "serie_equipo = '" + serie_equipo + "',"; CadenaSQL = CadenaSQL + "garantia = '" + garantia + "',"; CadenaSQL = CadenaSQL + "inicio_garantia = '" + inicio_garantia + "',"; CadenaSQL = CadenaSQL + "termino_garantia = '" + termino_garantia + "',"; CadenaSQL = CadenaSQL + "falla = '" + falla + "',"; CadenaSQL = CadenaSQL + "diagnostico = '" + diagnostico + "',"; CadenaSQL = CadenaSQL + "observaciones = '" + observaciones + "',";
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 87
CadenaSQL = CadenaSQL + "status = '" + status + "'"; CadenaSQL = CadenaSQL + "WHERE ticket = " + TBTICKET.Text; //Comando SQL SqlCommand Comando = Conexion.CreateCommand(); Comando.CommandText = CadenaSQL; //Ejecutar la acción consulta Conexion.Open(); Comando.ExecuteNonQuery(); Conexion.Close(); return true; } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return coleccion; } } public static class AutoCompleClassPantalla { //método para cargar los datos de la base de datos
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 88
public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return coleccion; } } public static class AutoCompleClassRecepcion { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM recepcion"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 89
adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["recepcion"])); } return coleccion; } } public static class AutoCompleClassEquipo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM equipo"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["equipo"])); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 90
return coleccion; } } public static class AutoCompleClassStatus { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM status"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["status"])); } return coleccion; } } private void BTNGuardar_Click_1(object sender, EventArgs e) { ModificarReporte(DFecha.Text, TBRecepcion.Text, TBEmpresa.Text, TBContacto.Text, TBAtencion.Text, TBEquipo.Text, TBModeloP.Text, TBModeloPAN.Text, TBSerie.Text, TBGarantia.Text, DInicioGarantia.Text, DTerminoGarantia.Text, TBFalla.Text, TBDiagnostico.Text, TBObservaciones.Text, TBStatus.Text); MessageBox.Show("El reporte ha sido actualizado con éxito.", "Aviso", MessageBoxButtons.OK); Limpiar_Formulario(); Interface_Inicial(); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 91
private void BTNEntrar_Click(object sender, EventArgs e) { SqlConnection cn = new SqlConnection(); cn.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; try { SqlCommand cmd = new SqlCommand("SELECT ID,pass FROM empleados WHERE ID='" + TBEmpleado.Text + "' AND pass='" + TBContra.Text + "' ", cn); cn.Open(); cmd.ExecuteNonQuery(); DataSet ds = new DataSet(); SqlDataAdapter da = new SqlDataAdapter(cmd); da.Fill(ds, "empleados"); DataRow dro; dro = ds.Tables["empleados"].Rows[0]; if ((TBEmpleado.Text == dro["ID"].ToString()) || (TBContra.Text == dro["pass"].ToString())) { MessageBox.Show("Bienvenido, puedes actualizar un reporte", "Mensaje", MessageBoxButtons.OK, MessageBoxIcon.Information); Interface_Datos_Dos(); } } catch { MessageBox.Show("Los datos son incorrectos. Ingreselos nuevamente.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); Interface_Inicial(); } finally { cn.Close(); } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 92
Imprimir Reporte
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes; using System.IO; using Microsoft.Office.Interop.Word; using Microsoft.Office.Interop; using Word = Microsoft.Office.Interop.Word; namespace NEC_Windows_Form { public partial class Imprimir_Reporte : Form { public Imprimir_Reporte() { InitializeComponent(); } private void Imprimir_Reporte_Load(object sender, EventArgs e) { // TODO: esta línea de código carga datos en la tabla 'tesisDataSet1.reporte' Puede moverla o quitarla según sea necesario. this.reporteTableAdapter.Fill(this.tesisDataSet1.reporte); TBBuscar.Focus(); } private void Limpiar_Formulario() { TBNoTicket.Clear(); TBRecepcion.Clear(); TBEmpresa.Clear(); TBContacto.Clear(); TBAtencion.Clear(); TBEquipo.Clear(); TBModeloP.Clear(); TBModeloPAN.Clear(); TBSerie.Clear(); TBGarantia.Clear(); TBFalla.Clear();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 93
TBDiagnostico.Clear(); TBObservaciones.Clear(); TBStatus.Clear(); } private void BTNBuscar_Click(object sender, EventArgs e) { //Si encuentra el reporte genera un documento en Word en base a una plantilla para poder imprimir el archivo if (BuscarReporte(TBBuscar.Text) == true) { MessageBox.Show("Reporte Encontrado ", "Mensaje",MessageBoxButtons.OK,MessageBoxIcon.Asterisk); try { Word.Application MSWord = new Word.Application(); Word.Document documento = new Word.Document(); MessageBox.Show(@"Se guardará en C:\Reportes\Ticket_#" + TBBuscar.Text, "Aviso", MessageBoxButtons.OK,MessageBoxIcon.Information); //El reporte se guardará en la ubicación predefinida en formato Word Directory.CreateDirectory(@"C:\Reportes\Ticket_#" + TBBuscar.Text); File.Copy(@"C:\Documentos\ordenServicio.docx", @"C:\Reportes\Ticket_#" + TBBuscar.Text + @"\Ticket_#" + TBBuscar.Text + ".docx");//Se copia el archivo que es una plantilla predefinida en formato Word y al copiar se llena con los datos solicitados documento = MSWord.Documents.Open(@"C:\Reportes\Ticket_#" + TBBuscar.Text + @"\Ticket_#" + TBBuscar.Text + ".docx"); //Se llena el documento Word utilizando las marcas puestas en la plantilla con los datos cargados desde la base de datos documento.Bookmarks["FechaActual"].Range.Text = FechaActual.Text; documento.Bookmarks["fecha_reporte"].Range.Text = DFecha.Text; documento.Bookmarks["ticket"].Range.Text = TBNoTicket.Text; documento.Bookmarks["empresa"].Range.Text = TBEmpresa.Text; documento.Bookmarks["contacto"].Range.Text = TBContacto.Text; documento.Bookmarks["correo"].Range.Text = TBCorreo.Text; documento.Bookmarks["tipo_equipo"].Range.Text = FechaActual.Text; documento.Bookmarks["modelo_pantalla"].Range.Text = TBModeloPAN.Text; documento.Bookmarks["modelo_proyector"].Range.Text = TBModeloP.Text; documento.Bookmarks["serie_equipo"].Range.Text = TBSerie.Text; documento.Bookmarks["garantia"].Range.Text = TBGarantia.Text; documento.Bookmarks["inicio_garantia"].Range.Text = DInicioGarantia.Text; documento.Bookmarks["termino_garantia"].Range.Text = DTerminoGarantia.Text; documento.Save(); MSWord.Visible = true; MessageBox.Show(@"Reporte Guardado en C:\Reportes\Ticket_#" + TBBuscar.Text,"Aviso",MessageBoxButtons.OK,MessageBoxIcon.Information); Limpiar_Formulario();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 94
} catch (Exception Exc) { MessageBox.Show(@"El reporte ya se encuentra guardado, revise la carpeta C:\Reportes\Ticket_#","Advertencia",MessageBoxButtons.OK,MessageBoxIcon.Error); Limpiar_Formulario(); } } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); TBBuscar.Focus(); } } private bool BuscarReporte(string ticket) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM reporte WHERE ticket='" + ticket + "'"; String CadenaSQL2 = "SELECT * FROM empresas"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); SqlDataAdapter Adaptador2 = new SqlDataAdapter(CadenaSQL2, conexion); //Data Set DataSet ds = new DataSet(); DataSet ds2 = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); Adaptador2.Fill(ds2); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0 || ds2.Tables[0].Rows.Count == 0) { ds.Dispose(); ds2.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box TBNoTicket.Text = ds.Tables[0].Rows[0]["ticket"].ToString(); DFecha.Text = ds.Tables[0].Rows[0]["fecha_reporte"].ToString();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 95
TBRecepcion.Text = ds.Tables[0].Rows[0]["forma_recepcion"].ToString(); TBEmpresa.Text = ds.Tables[0].Rows[0]["empresa"].ToString(); TBContacto.Text = ds.Tables[0].Rows[0]["contacto"].ToString(); TBAtencion.Text = ds.Tables[0].Rows[0]["atencion"].ToString(); TBEquipo.Text = ds.Tables[0].Rows[0]["tipo_equipo"].ToString(); TBModeloP.Text = ds.Tables[0].Rows[0]["modelo_proyector"].ToString(); TBModeloPAN.Text = ds.Tables[0].Rows[0]["modelo_pantalla"].ToString(); TBSerie.Text = ds.Tables[0].Rows[0]["serie_equipo"].ToString(); TBGarantia.Text = ds.Tables[0].Rows[0]["garantia"].ToString(); DInicioGarantia.Text = ds.Tables[0].Rows[0]["inicio_garantia"].ToString(); DTerminoGarantia.Text = ds.Tables[0].Rows[0]["termino_garantia"].ToString(); TBFalla.Text = ds.Tables[0].Rows[0]["falla"].ToString(); TBDiagnostico.Text = ds.Tables[0].Rows[0]["diagnostico"].ToString(); TBObservaciones.Text = ds.Tables[0].Rows[0]["observaciones"].ToString(); TBStatus.Text = ds.Tables[0].Rows[0]["status"].ToString(); TBCorreo.Text = ds2.Tables[0].Rows[0]["correo"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa ds2.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } private void BTNCANCELAR_Click(object sender, EventArgs e) { this.Close(); } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 96
Buscar Reporte Ticket
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Buscar_Ticket : Form { public Buscar_Ticket() { InitializeComponent(); } private void BTNBUSCARTICKET_Click(object sender, EventArgs e) { TBUSCATICKET.Enabled = true; string buscaEm = ""; //TBUSCATICKET.ReadOnly = true; buscaEm = string.Format("SELECT ticket,empresa,tipo_equipo,modelo_Proyector,modelo_Pantalla,falla FROM reporte WHERE ticket = '{0}'", TBUSCATICKET.Text.Trim()); string CONECTAR = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; SqlConnection myConnect = new SqlConnection(CONECTAR); SqlDataAdapter myDataAdapter = new SqlDataAdapter(buscaEm, myConnect); DataTable myTable; myTable = new DataTable(); myDataAdapter.Fill(myTable); DataTicket.DataSource = myTable; TBUSCATICKET.Enabled = true; } private void BTNSalir_Click(object sender, EventArgs e) { this.Close(); } private void Buscar_Ticket_Load(object sender, EventArgs e)
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 97
{ TBUSCATICKET.Focus(); //cargar los datos para el autocomplete del textbox Proyector TBUSCATICKET.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBUSCATICKET.AutoCompleteMode = AutoCompleteMode.Suggest; TBUSCATICKET.AutoCompleteSource = AutoCompleteSource.CustomSource; } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM reporte"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["ticket"])); } return colección; } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 98
Buscar por Número de Serie del Equipo
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Buscar_Serie : Form { public Buscar_Serie() { InitializeComponent(); } private void Buscar_Serie_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Status TBBUSCASTATUS.AutoCompleteCustomSource = AutoCompleClassStatus.Autocomplete(); TBBUSCASTATUS.AutoCompleteMode = AutoCompleteMode.Suggest; TBBUSCASTATUS.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void Interface_Inicial() { LBEMPRESA.Enabled = true; TBBUSCASTATUS.Enabled = true; BTNBUSCARSTATUS.Enabled = true; BTNSalir.Enabled = true; TBBUSCASTATUS.Focus(); } private void BTNBUSCARSTATUS_Click(object sender, EventArgs e) { string buscaEm = ""; //TBBUSCASTATUS.ReadOnly = true; buscaEm = string.Format("SELECT serie_equipo,status,empresa,ticket,fecha_reporte,tipo_equipo,modelo_Proyector,modelo_Pantalla,contacto,atencion FROM reporte WHERE serie_equipo = '{0}'", TBBUSCASTATUS.Text.Trim()); string CONECTAR = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True";
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 99
SqlConnection myConnect = new SqlConnection(CONECTAR); SqlDataAdapter myDataAdapter = new SqlDataAdapter(buscaEm, myConnect); myConnect.Open(); DataTable myTable; myTable = new DataTable(); myDataAdapter.Fill(myTable); DataEmpresa.DataSource = myTable; myConnect.Close(); Interface_Inicial(); } public static class AutoCompleClassStatus { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM reporte"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["serie_equipo"])); } return coleccion; } } private void BTNSalir_Click(object sender, EventArgs e) { this.Close(); } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 100
Buscar por Modelo de Pantalla
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Buscar_Modelo_Pantalla : Form { public Buscar_Modelo_Pantalla() { InitializeComponent(); } private void Buscar_Modelo_Pantalla_Load(object sender, EventArgs e) { //cargar los datos para el autocomplete del textbox Pantalla TBModelo.AutoCompleteCustomSource = AutoCompleClassPantalla.Autocomplete(); TBModelo.AutoCompleteMode = AutoCompleteMode.Suggest; TBModelo.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNSalir_Click(object sender, EventArgs e) { this.Close(); } private void BTNBuscar_Click(object sender, EventArgs e) { TBModelo.Enabled = true; string buscaM = ""; //TBModelo.ReadOnly = true; buscaM = string.Format("SELECT modelo_Pantalla,empresa,tipo_equipo,falla FROM reporte WHERE modelo_Pantalla = '{0}'", TBModelo.Text.Trim()); string CONECTAR = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; SqlConnection myConnect = new SqlConnection(CONECTAR); SqlDataAdapter myDataAdapter = new SqlDataAdapter(buscaM, myConnect);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 101
DataTable myTable; myTable = new DataTable(); myDataAdapter.Fill(myTable); DataModelo.DataSource = myTable; TBModelo.Enabled = true; } public static class AutoCompleClassPantalla { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return colección; } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 102
Buscar por Modelo de Proyector
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Buscar_Modelo : Form { public Buscar_Modelo() { InitializeComponent(); } private void Buscar_Modelo_Load(object sender, EventArgs e) { //cargar los datos para el autocomplete del textbox Proyector TBModelo.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBModelo.AutoCompleteMode = AutoCompleteMode.Suggest; TBModelo.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNBUSCARMODELO_Click(object sender, EventArgs e) { TBModelo.Enabled = true; string buscaM = ""; //TBModelo.ReadOnly = true; buscaM = string.Format("SELECT modelo_Proyector,empresa,tipo_equipo,falla FROM reporte WHERE modelo_Proyector = '{0}'", TBModelo.Text.Trim()); string CONECTAR = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; SqlConnection myConnect = new SqlConnection(CONECTAR); SqlDataAdapter myDataAdapter = new SqlDataAdapter(buscaM, myConnect); DataTable myTable; myTable = new DataTable(); myDataAdapter.Fill(myTable); DataModelo.DataSource = myTable; TBModelo.Enabled = true;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 103
} private void BTNSalir_Click(object sender, EventArgs e) { this.Close(); } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return colección; } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 104
Buscar por Empresa
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Buscar_Empresa : Form { public Buscar_Empresa() { InitializeComponent(); } private void Buscar_Empresa_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBBUSCAEMPRESA.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBBUSCAEMPRESA.AutoCompleteMode = AutoCompleteMode.Suggest; TBBUSCAEMPRESA.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void Interface_Inicial() { LBEMPRESA.Enabled = true; TBBUSCAEMPRESA.Enabled = true; BTNBUSCAREMPRESA.Enabled = true; BTNSalir.Enabled = true; TBBUSCAEMPRESA.Focus(); } private void BTNBUSCAREMPRESA_Click(object sender, EventArgs e) { string buscaEm = ""; //TBBUSCAEMPRESA.ReadOnly = true; buscaEm = string.Format("SELECT empresa,ticket,fecha_reporte,tipo_equipo,modelo_Proyector,modelo_Pantalla,status,contacto,atencion FROM reporte WHERE empresa = '{0}'", TBBUSCAEMPRESA.Text.Trim());
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 105
string CONECTAR = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; SqlConnection myConnect = new SqlConnection(CONECTAR); SqlDataAdapter myDataAdapter = new SqlDataAdapter(buscaEm, myConnect); myConnect.Open(); DataTable myTable; myTable = new DataTable(); myDataAdapter.Fill(myTable); DataEmpresa.DataSource = myTable; myConnect.Close(); Interface_Inicial(); } private void BTNSalir_Click(object sender, EventArgs e) { this.Close(); } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM reporte"; //consulta a la tabla reporte SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["empresa"])); } return colección; } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 106
Agregar Nuevo Modelo de Pantalla al Catálogo
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes; using System.Configuration; namespace NEC_Windows_Form { public partial class Pantalla_Nuevo : Form { public Pantalla_Nuevo() { InitializeComponent(); } private void Pantalla_Nuevo_Load(object sender, EventArgs e) { //cargar los datos para el autocomplete del textbox Proyector TBTipo.AutoCompleteCustomSource = AutoCompleClassTipo.Autocomplete(); TBTipo.AutoCompleteMode = AutoCompleteMode.Suggest; TBTipo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Proyector TBModelo.AutoCompleteCustomSource = AutoCompleClassModelo.Autocomplete(); TBModelo.AutoCompleteMode = AutoCompleteMode.Suggest; TBModelo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Proyector TBResoluciuon.AutoCompleteCustomSource = AutoCompleClassResolucion.Autocomplete(); TBResoluciuon.AutoCompleteMode = AutoCompleteMode.Suggest; TBResoluciuon.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Proyector TBDisplay.AutoCompleteCustomSource = AutoCompleClassDimension.Autocomplete(); TBDisplay.AutoCompleteMode = AutoCompleteMode.Suggest; TBDisplay.AutoCompleteSource = AutoCompleteSource.CustomSource; if (BuscarReporte(ID.Text) == true) {
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 107
//MessageBox.Show("Reporte Encontrado ", "Mensaje"); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); ID.Focus(); } } private void BTNGuardar_Click(object sender, EventArgs e) { SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); if (oreporte.AgregaPantalla(TBTipo.Text, TBModelo.Text, TBResoluciuon.Text, TBDisplay.Text)) { MessageBox.Show("Nuevo modelo de Pantalla agregado correctamente","Agregado",MessageBoxButtons.OK,MessageBoxIcon.Information); } else { MessageBox.Show("Error al agregar el reporte " + oreporte.mensaje,"Error"); } Limpiar_Formulario(); //Limpia el formulario //Interface_Inicial(); //Prepara la interfaz del formulario inicial*/ } private void Limpiar_Formulario() { TBTipo.Clear(); TBModelo.Clear(); TBResoluciuon.Clear(); TBDisplay.Clear(); } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private bool BuscarReporte(string ticket) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT MAX(ID)+1 AS ID FROM pantalla"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 108
//Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box ID.Text = ds.Tables[0].Rows[0]["ID"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } public static class AutoCompleClassTipo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 109
foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["tipo"])); } return coleccion; } } public static class AutoCompleClassModelo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return coleccion; } } public static class AutoCompleClassResolucion { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 110
SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["resolucion"])); } return coleccion; } } public static class AutoCompleClassDimension { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete()
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 111
{ DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["dimension"])); } return colección; } } } }
Consultar Características de una Pantalla
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Pantalla_Consulta : Form { public Pantalla_Consulta() { InitializeComponent(); } private void Pantalla_Consulta_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBBuscar.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBBuscar.AutoCompleteMode = AutoCompleteMode.Suggest; TBBuscar.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNBuscar_Click(object sender, EventArgs e) { if (BuscarPantalla(TBBuscar.Text) == true) {
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 112
//MessageBox.Show("Reporte Encontrado ", "Mensaje");Mensaje opcional mostraría en mensaje en la pantalla al encontrar el reporte Interface_Datos(); } else { MessageBox.Show("El modelo que se buscó NO se encuentra en la Base de Datos ", "Advertencia"); Interface_Inicial(); TBBuscar.Focus(); } } private bool BuscarPantalla(string modelo) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM pantalla WHERE modelo='" + modelo + "'"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box IDTB.Text = ds.Tables[0].Rows[0]["ID"].ToString(); TBTipo.Text = ds.Tables[0].Rows[0]["tipo"].ToString(); TBModelo.Text = ds.Tables[0].Rows[0]["modelo"].ToString(); TBResolucion.Text = ds.Tables[0].Rows[0]["resolucion"].ToString(); TBDisplay.Text = ds.Tables[0].Rows[0]["dimension"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } private void Interface_Inicial() {
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 113
LBBuscarModelo.Enabled = true; TBBuscar.Enabled = true; BTNBuscar.Enabled = true; IDLabel.Enabled = false; IDTB.Enabled = false; LBDisplay.Enabled = false; LBProyector.Enabled = false; LBResolucion.Enabled = false; LBTipo.Enabled = false; TBDisplay.Enabled = false; TBModelo.Enabled = false; TBResolucion.Enabled = false; TBTipo.Enabled = false; TBBuscar.Focus(); } private void Interface_Datos() { LBBuscarModelo.Enabled = true; TBBuscar.Enabled = true; BTNBuscar.Enabled = true; IDLabel.Enabled = true; IDTB.Enabled = true; LBDisplay.Enabled = true; LBProyector.Enabled = true; LBResolucion.Enabled = true; LBTipo.Enabled = true; TBDisplay.Enabled = true; TBModelo.Enabled = true; TBResolucion.Enabled = true; TBTipo.Enabled = true; } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM pantalla"; //consulta a la tabla pantalla SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 114
//método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return coleccion; } } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } } }
Agregar Nuevo Modelo de Proyector al Catálogo
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes; using System.Configuration; namespace NEC_Windows_Form { public partial class Proyector_Nuevo : Form { public Proyector_Nuevo() { InitializeComponent(); } private void Proyector_Nuevo_Load(object sender, EventArgs e) { //cargar los datos para el autocomplete del textbox Proyector
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 115
TBTipo.AutoCompleteCustomSource = AutoCompleClassTipo.Autocomplete(); TBTipo.AutoCompleteMode = AutoCompleteMode.Suggest; TBTipo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Proyector TBModelo.AutoCompleteCustomSource = AutoCompleClassModelo.Autocomplete(); TBModelo.AutoCompleteMode = AutoCompleteMode.Suggest; TBModelo.AutoCompleteSource = AutoCompleteSource.CustomSource; //cargar los datos para el autocomplete del textbox Proyector TBLumenes.AutoCompleteCustomSource = AutoCompleClassLumenes.Autocomplete(); TBLumenes.AutoCompleteMode = AutoCompleteMode.Suggest; TBLumenes.AutoCompleteSource = AutoCompleteSource.CustomSource; if (BuscarReporte(ID.Text) == true) { // MessageBox.Show("Reporte Encontrado ", "Mensaje"); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); ID.Focus(); } } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private void BTNGuardar_Click(object sender, EventArgs e) { SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); if (oreporte.AgregaProyector(TBTipo.Text, TBModelo.Text, TBLumenes.Text)) { MessageBox.Show("Nuevo Modelo de Proyector agregado correctamente", "Agregado",MessageBoxButtons.OK,MessageBoxIcon.Information); } else { MessageBox.Show("Error al agregar el reporte " + oreporte.mensaje, "Error",MessageBoxButtons.OK,MessageBoxIcon.Error); } Limpiar_Formulario(); //Limpia el formulario } private void Limpiar_Formulario() { TBTipo.Clear(); TBModelo.Clear();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 116
TBLumenes.Clear(); } private bool BuscarReporte(string ticket) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT MAX(ID)+1 AS ID FROM proyector"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box ID.Text = ds.Tables[0].Rows[0]["ID"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } public static class AutoCompleClassTipo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 117
SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["Tipo"])); } return coleccion; } } public static class AutoCompleClassModelo { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["Modelo"]));
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 118
} return coleccion; } } public static class AutoCompleClassLumenes { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["Lumenes"])); } return colección; } } } }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 119
Consultar Características de Proyector
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes; using System.Data.OleDb; using System.Data.Common; namespace NEC_Windows_Form { public partial class Proyector_Consulta : Form { public Proyector_Consulta() { InitializeComponent(); } private void Proyector_Consulta_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBBusca.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBBusca.AutoCompleteMode = AutoCompleteMode.Suggest; TBBusca.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private void Interface_Inicial() { LBBuscarModelo.Enabled = true; TBBusca.Enabled = true; BTNBuscar.Enabled = true; IDLabel.Enabled = false; TBID.Enabled = false; LBLumenes.Enabled = false; LBProyector.Enabled = false; LBTipo.Enabled = false; TBLumenes.Enabled = false;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 120
TBModelo.Enabled = false; TBTipo.Enabled = false; TBBusca.Focus(); } private void Interface_Datos() { LBBuscarModelo.Enabled = true; TBBusca.Enabled = true; BTNBuscar.Enabled = true; IDLabel.Enabled = true; TBID.Enabled = true; LBLumenes.Enabled = true; LBProyector.Enabled = true; LBTipo.Enabled = true; TBLumenes.Enabled = true; TBModelo.Enabled = true; TBTipo.Enabled = true; } private void BTNBuscar_Click(object sender, EventArgs e) { if (BuscarProyector(TBBusca.Text) == true) { //MessageBox.Show("Reporte Encontrado ", "Mensaje"); Interface_Datos(); } else { MessageBox.Show("El modelo que se buscó NO se encuentra en la Base de Datos ", "Advertencia"); Interface_Inicial(); TBBusca.Focus(); } } private bool BuscarProyector(string modelo) { //Conexion SqlConnection Conexion = new SqlConnection(); Conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM proyector WHERE Modelo='"+ modelo + "'"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL,Conexion); //Dataset DataSet ds = new DataSet(); //llenar el Dataset Conexion.Open();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 121
Adaptador.Fill(ds); Conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; } else { TBID.Text = ds.Tables[0].Rows[0]["ID"].ToString(); TBTipo.Text = ds.Tables[0].Rows[0]["Tipo"].ToString(); TBModelo.Text = ds.Tables[0].Rows[0]["Modelo"].ToString(); TBLumenes.Text = ds.Tables[0].Rows[0]["Lumenes"].ToString(); ds.Dispose(); return true; } } private static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM proyector"; //consulta a la tabla proyector SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete() { DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["modelo"])); } return colección; }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 122
} } }
Agregar Empresa al Catálogo
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; using System.Data.SqlTypes; namespace NEC_Windows_Form { public partial class Empresa_nuevo : Form { public Empresa_nuevo() { InitializeComponent(); } private void Empresa_nuevo_Load(object sender, EventArgs e) { if (BuscarEmpresa(IDLB.Text) == true) { // MessageBox.Show("Reporte Encontrado ", "Mensaje"); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); } } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private void BTNGuardar_Click(object sender, EventArgs e) { SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); if (oreporte.AgregaEmpresa(TBNombre.Text,TBContacto.Text,TBCorreo.Text,TBTelefono.Text)) {
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 123
MessageBox.Show("Se ha agregado la empresa correctamente.", "Agregado",MessageBoxButtons.OK,MessageBoxIcon.Information); TBNombre.Focus(); if (BuscarEmpresa(IDLB.Text) == true) { // MessageBox.Show("Reporte Encontrado ", "Mensaje"); } else { MessageBox.Show("Reporte NO Encontrado ", "Mensaje"); } } else { MessageBox.Show("Error al agregar el reporte " + oreporte.mensaje, "Error"); } Limpiar_Formulario(); //Limpia el formulario } private void Limpiar_Formulario() { TBNombre.Clear(); TBContacto.Clear(); TBCorreo.Clear(); TBTelefono.Clear(); } private bool BuscarEmpresa(string ID) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT MAX(ID)+1 AS ID FROM empresas"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 124
IDLB.Text = ds.Tables[0].Rows[0]["ID"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } } }
Consultar Contacto Directo con Empresa
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { public partial class Empresa_consulta : Form { public Empresa_consulta() { InitializeComponent(); } private void Empresa_consulta_Load(object sender, EventArgs e) { Interface_Inicial(); //cargar los datos para el autocomplete del textbox Proyector TBBuscar.AutoCompleteCustomSource = AutoCompleClass.Autocomplete(); TBBuscar.AutoCompleteMode = AutoCompleteMode.Suggest; TBBuscar.AutoCompleteSource = AutoCompleteSource.CustomSource; } private void BTNCancelar_Click(object sender, EventArgs e) { this.Close(); } private void BTNBuscar_Click(object sender, EventArgs e) { if (BuscarEmpresa(TBBuscar.Text) == true) { //MessageBox.Show("Reporte Encontrado ", "Mensaje"); Interface_Datos(); }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 125
else { MessageBox.Show("El modelo que se buscó NO se encuentra en la Base de Datos ", "Advertencia"); Interface_Inicial(); TBBuscar.Focus(); } } private bool BuscarEmpresa(string empresa) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM empresas WHERE empresa='" + empresa + "'"; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion); //Data Set DataSet ds = new DataSet(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { ds.Dispose(); return false; //Registro no encontrado } else { //Cargar los campos en Text Box IDLB.Text = ds.Tables[0].Rows[0]["ID"].ToString(); TBNombre.Text = ds.Tables[0].Rows[0]["empresa"].ToString(); TBContacto.Text = ds.Tables[0].Rows[0]["contacto"].ToString(); TBCorreo.Text = ds.Tables[0].Rows[0]["correo"].ToString(); TBTelefono.Text = ds.Tables[0].Rows[0]["telefono"].ToString(); ds.Dispose();//cierra el data set y libera los recursos de memoria que ocupa return true; //Registro Existe } } private void Interface_Inicial() { LBBuscarModelo.Enabled = true; TBBuscar.Enabled = true;
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 126
BTNBuscar.Enabled = true; LBID.Enabled = false; IDLB.Enabled = false; LBNombre.Enabled = false; TBNombre.Enabled = false; LBContacto.Enabled = false; TBContacto.Enabled = false; LBCorreo.Enabled = false; TBCorreo.Enabled = false; LBTelefono.Enabled = false; TBTelefono.Enabled = false; TBBuscar.Focus(); } private void Interface_Datos() { LBBuscarModelo.Enabled = true; TBBuscar.Enabled = true; BTNBuscar.Enabled = true; LBID.Enabled = true; IDLB.Enabled = true; LBNombre.Enabled = true; TBNombre.Enabled = true; LBContacto.Enabled = true; TBContacto.Enabled = true; LBCorreo.Enabled = true; TBCorreo.Enabled = true; LBTelefono.Enabled = true; TBTelefono.Enabled = true; TBBuscar.Focus(); } public static class AutoCompleClass { //método para cargar los datos de la base de datos public static DataTable Datos() { DataTable dt = new DataTable(); SqlConnection SqlDataSource1 = new SqlConnection(); SqlDataSource1.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; reporte oreporte = new reporte(SqlDataSource1.ConnectionString); string consulta = "SELECT * FROM empresas"; //consulta a la tabla empresas SqlCommand comando = new SqlCommand(consulta, SqlDataSource1); SqlDataAdapter adap = new SqlDataAdapter(comando); adap.Fill(dt); return dt; } //método para cargar la colección de datos para el autocomplete public static AutoCompleteStringCollection Autocomplete()
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 127
{ DataTable dt = Datos(); AutoCompleteStringCollection colección = new AutoCompleteStringCollection(); //recorrer y cargar los ítems para el autocompletado foreach (DataRow row in dt.Rows) { coleccion.Add(Convert.ToString(row["empresa"])); } return colección; } } } }
Clases y Funciones utilizadas en el Sistema
/* ==================================================================== * Proyecto: Sistema de Control de Reportes * Escuela Superior de Ingeniería Mecánica y Eléctrica * Unidad Profesional Zacatenco * Ingeniería en Comunicaciones y Electrónica * Especialidad Computación * Desarrollado por Manuel Sánchez Martínez * ==================================================================== */ using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data.SqlClient; using System.Data.Sql; namespace NEC_Windows_Form { class reporte { public string mensaje { get; set; } public string nombreusuario { get; set; } private SqlConnection conexion; public reporte(string Conexion) { // // TODO: Add constructor logic here // //Creación de un objeto conexión a la base de datos //El argumento lo que indica es la cadena de conexión que genera el SQLDATASOURCE conexion = new SqlConnection(Conexion); } //// ------------------ Funciones de Agregar ---------------------------------- //// public bool AgregaReporte(string fecha_reporte, string forma_recepcion, string empresa, string contacto, string atencion, string tipo_equipo, string modelo_Proyector, string modelo_Pantalla, string serie_equipo, string garantia,
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 128
string inicio_garantia, string termino_garantia, string falla, string diagnostico, string observaciones, string status) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO reporte (fecha_reporte, forma_recepcion, empresa, contacto, atencion, tipo_equipo, modelo_Proyector, modelo_Pantalla, serie_equipo, garantia, inicio_garantia, termino_garantia, falla, diagnostico, observaciones, status) VALUES ('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}','{11}','{12}','{13}','{14}','{15}')", fecha_reporte, forma_recepcion, empresa, contacto, atencion, tipo_equipo, modelo_Proyector, modelo_Pantalla, serie_equipo, garantia, inicio_garantia, termino_garantia, falla, diagnostico, observaciones, status); try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexion Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open(); comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; } public bool AgregaPantalla(string tipo, string modelo, string resolucion, string dimension) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO pantalla (tipo, modelo, resolucion, dimension) VALUES ('{0}','{1}','{2}','{3}')", tipo, modelo, resolucion, dimension); try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexión Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open();
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 129
comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; } public bool AgregaProyector(string tipo, string modelo, string lumenes) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO proyector (tipo, modelo, lumenes) VALUES ('{0}','{1}','{2}')", tipo, modelo, lumenes); try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexion Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open(); comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; } public bool AgregaEmpleado(string ID, string nombre,string apellido_paterno,string apellido_materno,string puesto,string pass) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO empleados (ID, nombre, apellido_paterno, apellido_materno, puesto, pass) VALUES ('{0}','{1}','{2}','{3}','{4}','{5}')", ID, nombre, apellido_paterno, apellido_materno, puesto, pass);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 130
try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexion Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open(); comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; } public bool AgregaEmpresa(string empresa, string contacto, string correo, string telefono) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO empresas (empresa, contacto, correo, telefono) VALUES ('{0}','{1}','{2}','{3}')",empresa, contacto, correo, telefono); try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexion Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open(); comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; }
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 131
/////// ------------------ Funciones de Modificar ---------------------------------- public bool ModificarReporte(string fecha_reporte, string forma_recepcion, string empresa, string contacto, string atencion, string tipo_equipo, string modelo_Proyector, string modelo_Pantalla, string serie_equipo, string garantia, string inicio_garantia, string termino_garantia, string falla, string diagnostico, string observaciones, string status) { bool Procesado = false; string inserta = ""; mensaje = ""; //Preparación del comando insert tal como necesitamos que se ejecute en la base de datos inserta = string.Format("INSERT INTO reporte (fecha_reporte, forma_recepcion, empresa, contacto, atencion, tipo_equipo, modelo_Proyector, modelo_Pantalla, serie_equipo, garantia, inicio_garantia, termino_garantia, falla, diagnostico, observaciones, status) VALUES ('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}','{10}','{11}','{12}','{13}','{14}','{15}')", fecha_reporte, forma_recepcion, empresa, contacto, atencion, tipo_equipo, modelo_Proyector, modelo_Pantalla, serie_equipo, garantia, inicio_garantia, termino_garantia, falla, diagnostico, observaciones, status); try { //Creación de un objeto comando //inserta Es la cadena que define el comando que se desea ejecutar //Conexion Es la conexión a la base de datos que ya se realizó anterior SqlCommand comando = new SqlCommand(inserta, conexion); conexion.Open(); comando.ExecuteNonQuery(); conexion.Close(); inserta = ""; Procesado = true; } catch (SqlException Exc) { mensaje = Exc.ToString(); } return Procesado; } /////// ------------------ Funciones de Buscar ---------------------------------- public bool BuscarReporte(string modelo) { //CONEXION SqlConnection conexion = new SqlConnection(); conexion.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=|DataDirectory|\\Data\\Tesis.mdf;Integrated Security=True;User Instance=True"; //Cadena SQL String CadenaSQL = "SELECT * FROM reporte WHERE modelo = " + modelo; //Adaptador SqlDataAdapter Adaptador = new SqlDataAdapter(CadenaSQL, conexion);
Sistema de Cómputo para el Control de Reportes de Equipos Dañados
Manuel Sánchez Martínez Página 132
//Data Set TesisDataSet1 ds = new TesisDataSet1(); //Llenar el Data Set conexion.Open(); Adaptador.Fill(ds); conexion.Close(); //Contar Registros if (ds.Tables[0].Rows.Count == 0) { return false; } else { return true; } } } }