residencias profesionales ingeniería mecatrónica informe
TRANSCRIPT
1
Residencias profesionales
Informe Técnico de Residencia Profesional
Sistema de captura para trituración, molienda y concentración (TMC)
Alumna:
Karen Lorena Peralta Cortés
No. De Control:
13460641
Asesor José Luis Rocha Pérez
Villa de Álvarez, Col., a 29 de Mayo de 2018
Departamento de Ingeniería Eléctrica y Electrónica
Ingeniería Mecatrónica
2
Índice
1. Introducción ................................................................................................................. 6
Fénix IETI ........................................................................................................................... 6
Misión ................................................................................................................................. 6
Visión .................................................................................................................................. 6
Generalidades ...................................................................................................................... 6
2. Justificación ................................................................................................................. 9
3. Objetivos .................................................................................................................... 11
3.1 Objetivo general .......................................................................................................... 11
3.2 Objetivo específicos .................................................................................................... 11
4. Problemas a resolver .................................................................................................. 12
5. Procedimientos y descripción de actividades ............................................................ 13
Capacitación ...................................................................................................................... 13
TMC Proyecto ................................................................................................................... 13
TMC Configuración ............................................................................................... 13
o Captura TV ......................................................................................................... 13
o Presupuesto ......................................................................................................... 24
o Factor Extracción ................................................................................................ 38
o Glosario .............................................................................................................. 43
o Configuración pantalla ....................................................................................... 47
o Configuración departamentos ............................................................................. 50
o Catálogos Demoras ............................................................................................. 53
TMC ....................................................................................................................... 59
6. Resultados .................................................................................................................. 60
TMC Configuración .......................................................................................................... 60
Captura TV ............................................................................................................. 61
Factor Extracción ................................................................................................... 62
Glosario .................................................................................................................. 62
Presupuesto ............................................................................................................ 63
Configuración Pantalla ........................................................................................... 63
Configuración departamentos ................................................................................ 64
Catálogo Demoras .................................................................................................. 64
3
TMC .................................................................................................................................. 65
Energía ................................................................................................................... 67
Agua ....................................................................................................................... 69
7. Conclusiones y recomendaciones .............................................................................. 71
8. Competencias desarrolladas y/o aplicadas ................................................................. 72
9. Referencias bibliográficas .......................................................................................... 73
Índice de figuras
Figura 1 Modelo de diseño MVC ........................................................................................... 7
Figura 2 Controlador Captura TV ......................................................................................... 16
Figura 3 Modelos de Captura TV ......................................................................................... 17
Figura 4 Vistas de Captura TV ............................................................................................. 17
Figura 5 Métodos de la clase GuardarTabla ......................................................................... 18
Figura 6 Clase Registros ....................................................................................................... 19
Figura 7 Métodos de la clase CapturaTVDB ........................................................................ 20
Figura 8 Método clase DBTAGC ......................................................................................... 20
Figura 9 Métodos de la clase IdPantallaDB .......................................................................... 21
Figura 10 Combos en la pantalla principal ........................................................................... 21
Figura 11 Variables Controlador .......................................................................................... 21
Figura 12 Acciones Controlador ........................................................................................... 22
Figura 13 controlador creado para el software ..................................................................... 24
Figura 14 Vista de la carpeta con sus modelos ..................................................................... 25
Figura 15 carpeta que contiene a las clases que definen los estilos a utilizar en la vista ..... 26
Figura 16 Vista "Layout" con los estilos que se usan en la vista "index" ............................ 27
Figura 17 Clases agregadas como modelos .......................................................................... 27
Figura 18 Contenido del Modelo PresupuestoT ................................................................... 28
Figura 19 Modelo con la clase Registros. Con sus variables y métodos .............................. 29
Figura 20 Clases en el modelo DBClass ............................................................................... 29
Figura 21 Clase DBTAGC .................................................................................................... 30
Figura 22 Controlador del proyecto "Presupuesto" .............................................................. 31
Figura 23 Estructura del controlador .................................................................................... 31
Figura 24 Función en la vista Layout ................................................................................... 32
Figura 25 Controlador. Variables utilizadas ......................................................................... 35
Figura 26 Controlador. Variables Tipo Objeto ..................................................................... 36
Figura 27 Controlador. Variables Tipo Lista ........................................................................ 36
Figura 28 Controlador. Acción utilizando variables tipo lista y objeto ................................ 36
Figura 29 Controlador. Método recibiendo una variable del controlador ............................ 37
Figura 30 Controlador. Variables generales ......................................................................... 37
Figura 31 Controlador. Acciones realizadas ......................................................................... 38
Figura 32 Modelo de factor extracción ................................................................................. 39
4
Figura 33 Clase Registros ..................................................................................................... 40
Figura 34 Variables Controlador .......................................................................................... 42
Figura 35 Acciones del controlador ...................................................................................... 42
Figura 36 Vistas de Factor Extracción .................................................................................. 43
Figura 37 Modelos Glosario ................................................................................................. 44
Figura 38 DBTAGC Métodos ............................................................................................... 44
Figura 39 DatosActualizar Métodos ..................................................................................... 45
Figura 40 IdPantallaDB Métodos ......................................................................................... 45
Figura 41 Variables controlador de Glosario ........................................................................ 46
Figura 42 Acciones del controlador de Glosario .................................................................. 47
Figura 43 Vistas de Glosario ................................................................................................ 47
Figura 44 Modelos de Configuración pantalla ..................................................................... 48
Figura 45 CP Métodos .......................................................................................................... 49
Figura 46 Variables y acciones de configuración pantalla ................................................... 50
Figura 47 Vistas de Configuración pantalla ......................................................................... 50
Figura 48 Modelos de la pantalla de configuración departamentos (Administrador) .......... 51
Figura 49 Controlador de configuración departamentos (Administrador) ........................... 52
Figura 50 Vistas de configuración departamentos (Administrador) ..................................... 53
Figura 51 Modelos de Catalogo Demoras ............................................................................ 55
Figura 52 Clase "ListasCombo" y sus respectivos métodos de catálogos demoras ............. 55
Figura 53 Clase "RegistroCatDem" y sus respectivos métodos de catálogos demoras ........ 56
Figura 54 Controlador Catálogo Demoras ............................................................................ 57
Figura 55 Variables Controlador de Catálogos Demoras ..................................................... 58
Figura 56 Acciones controlador de Catálogo Demoras ........................................................ 58
Figura 57 Vistas de Catálogos Demoras ............................................................................... 59
Figura 58 Estructura del proyecto de TMC .......................................................................... 59
Figura 59 Pagina de acceso al software ................................................................................ 60
Figura 60 Pagina inicial del software ................................................................................... 61
Figura 61 Primer y segundo módulo de Captura TV ............................................................ 61
Figura 62 Tercer y cuarto módulo de Captura TV ................................................................ 62
Figura 63 Pantalla de Factor Extracción ............................................................................... 62
Figura 64 Pantalla de Glosario .............................................................................................. 63
Figura 65 Pantalla de Presupuesto ........................................................................................ 63
Figura 66 Pantalla de Configuración Pantalla ...................................................................... 64
Figura 67 Pantalla de Configuración departamentos ............................................................ 64
Figura 68 Primer Módulo con sus dos partes de Catálogo Demoras .................................... 65
Figura 69 Segundo y Tercer módulo de Catálogo Demoras ................................................. 65
Figura 70 Pagina de Acceso al software ............................................................................... 66
Figura 71 Página principal del software ............................................................................... 66
Figura 72 Indicadores Iniciales de Energía ........................................................................... 67
Figura 73 Captura de consumos parte 1 ................................................................................ 67
Figura 74 Captura de consumos parte 2 ................................................................................ 67
Figura 75 Resumen Mensual ................................................................................................ 68
Figura 76 Parámetros del mes ............................................................................................... 68
5
Figura 77 Indicadores iniciales de Agua ............................................................................... 69
Figura 78 Captura de Consumos ........................................................................................... 69
Figura 79 Resumen Mensual ................................................................................................ 70
Figura 80 Parámetros ............................................................................................................ 70
6
1. Introducción
Fénix IETI
El nombre comercial de la empresa es “Fénix IETI”, pero su nombre oficial es
“IDEALISTAS CON EXPERIENCIA EN TECNOLOGÍAS DE INFORMACIÓN S.C”.
Tiene un giro comercial en consultoría y desarrollo de soluciones en tecnología de
información, ubicados en la calle Guillermo Prieto número 152 local D en la colonia
Guadalajarita en el estado de Colima.
Misión
Apoyar a nuestros clientes mediante soluciones tecnológicas funcionales de alta calidad y de
inversión equilibrada, que atiendan necesidades de captación, manejo y explotación de la
información generada en su negocio, dando herramientas para una mejor toma de decisiones,
aumentando su competitividad, detonando su crecimiento y posicionamiento.
Visión
Ser una empresa referente dentro del Estado de Colima, comprometida socialmente con el
crecimiento conjunto de nuestros clientes. Ser una empresa incubadora de nuevos talentos
facilitando su profesionalización e incursión al área laboral
Generalidades
ASP.NET es un modelo de desarrollo Web unificado que incluye los servicios necesarios
para crear aplicaciones Web empresariales con el código mínimo. ASP.NET forma parte de
.NET Framework y al codificar las aplicaciones ASP.NET tiene acceso a las clases en .NET
Framework. El código de las aplicaciones puede escribirse en cualquier lenguaje compatible
con el Common Language Runtime (CLR), entre ellos Microsoft Visual Basic, C#, JScript
.NET y J#. Estos lenguajes permiten desarrollar aplicaciones ASP.NET que se benefician del
Common Language Runtime, seguridad de tipos, herencia, etc. (5).
ASP.NET incluye:
Marco de trabajo de página y controles
Compilador de ASP.NET
Infraestructura de seguridad
Funciones de administración de estado
Configuración de las aplicaciones
Supervisión de estado y características de rendimiento
Capacidad de depuración
Marco de trabajo de servicios Web XML
7
Entorno de host extensible y administración del ciclo de vida de las
aplicaciones
Entorno de diseñador extensible
Teniendo esto en cuenta se tiene que el modelo arquitectónico Modelo-Vista-Controlador
(MVC) separa una aplicación en tres componentes principales: el modelo, la vista y el
controlador. El marco de ASP.NET MVC proporciona una alternativa al modelo de
formularios Web Forms de ASP.NET para crear aplicaciones web. El marco de ASP.NET
MVC es un marco de presentación de poca complejidad y fácil de comprobar que (como las
aplicaciones basadas en formularios Web Forms) se integra con las características de
ASP.NET existentes, tales como páginas maestras y la autenticación basada en pertenencia.
El marco de MVC se define en el ensamblado System.Web.Mvc (4).
Figura 1 Modelo de diseño MVC
MVC tiene los siguientes componentes:
Modelos: Los objetos de modelo son las partes de la aplicación que
implementan la lógica del dominio de datos de la aplicación. A menudo, los
objetos de modelo recuperan y almacenan el estado del modelo en una base
de datos. Por ejemplo, un objeto Product podría recuperar información de una
base de datos, trabajar con ella y, a continuación, escribir la información
actualizada en una tabla Productos de una base de datos de SQL Server.
En las aplicaciones pequeñas, el modelo es a menudo una separación
conceptual en lugar de física. Por ejemplo, si la aplicación solo lee un conjunto
de datos y lo envía a la vista, la aplicación no tiene un nivel de modelo físico
ni las clases asociadas. En ese caso, el conjunto de datos asume el rol de un
objeto de modelo.
Vistas: Las vistas son los componentes que muestra la interfaz de usuario de
la aplicación. Normalmente, esta interfaz de usuario se crea a partir de los
datos de modelo. Un ejemplo sería una vista de edición de una tabla Productos
que muestra cuadros de texto, listas desplegables y casillas basándose en el
estado actual de un objeto Product.
8
Controladores: Los controladores son los componentes que controlan la
interacción del usuario, trabajan con el modelo y por último seleccionan una
vista para representar la interfaz de usuario. En una aplicación MVC, la vista
solo muestra información; el controlador administra y responde a los datos
proporcionados por el usuario y su interacción. Por ejemplo, el controlador
administra los valores de la cadena de consulta y pasa estos valores al modelo,
que a su vez podría usarlos para consultar la base de datos.
Se le determina “Pantalla” a cada uno de los softwares que componen un proyecto en MVC,
es decir, cada una de las vistas principales con cada uno de sus métodos.
Por lo tanto, teniendo en cuenta las definiciones anteriores se determinó que MVC es la
opción más factible para desarrollar el proyecto además de que servirá para complementar el
sistema de Visual Flash que posee la empresa y así automatizar completamente el proceso de
captura, almacenamiento y mantenimiento de los indicadores de cada una de sus áreas y
poder visualizarlas de manera gráfica para poder tomar decisiones dependiendo del
rendimiento de cada una de las áreas. Cada una de las “Pantallas” estaría delimitada por una
sesión de usuario, es decir, no cualquiera podrá tener acceso a la información mostrada en el
software. Dependiendo del rango que posean en el organigrama general de la empresa será
la información que podrán visualizar y la que podrán editar o agregar en el caso de que sea
necesario. A lo largo de todo este documento se describirán cada una de las actividades
realizadas para lograr el desarrollo de todo el proyecto, así como los resultados y
conclusiones obtenidas en el tiempo que se desarrollaron dichas actividades.
9
2. Justificación
En el área de Trituración, Molienda y Concentración (TMC) se maneja una gran cantidad de
datos e indicadores, los cuales son capturados por medio de hojas Excel. Al ser capturados
de esa manera los valores pueden contener errores humanos al momento de ser registrados,
además de que su visualización no es muy clara al momento de generar los informes de las
plantas. Por lo tanto, se propone la actualización de este sistema implementando un software
de captura, el cual permitirá optimizar el tiempo de captura. Además, posee validaciones para
que, al momento de capturar, si el encargado del área introdujo una cantidad errónea o se
saltó un campo el software automáticamente le marcará el error antes de guardar los datos.
Además de permitirles visualizar los datos y capturarlos tendrán la opción de modificación
de valores.
Los datos serán subidos a un servidor el cual los guardará en su base de datos
correspondientes. Por otra parte, el software generará estadísticas las cuales serán generadas
cada cierto tiempo definido por la empresa, esto se presentará en el mismo software de
manera gráfica permitiendo mayor compresión al momento de ser analizadas
Cada una de las pantallas a realizar tendrán una visualización grafica de cada una de sus
variables, comparando los resultados obtenidos con los informes anteriores permitiendo a los
encargados decidir qué acciones se tomarán dependiendo del rendimiento mostrado en cada
una de las pantallas, además de que esto les facilitará al momento de presentarlo en manera
gerencial para poder actuar y decidir conforme a lo necesario en cada una de ellas, mejorando
el rendimiento de las plantas. El proyecto se clasificó en dos partes:
TMC Configuración: en este software se permitirá agregar, realizar mantenimiento y
visualizar cada uno de los indicadores. El fin de este software es poder modificar los
valores calculados en cada una de las áreas por si existiera en caso de que se hubiera
cometido algún error al momento de comparar los cálculos con los valores reales en
cada una de las bitácoras de las áreas. Además, se permitirá subir los valores que ya
tenían calculados en los documentos de Excel, pero convirtiendo los documentos en
CSV. Esto se hizo con el fin de que los valores que ya tenían capturados no los
volvieran a subir uno por uno, si no que pudieran subirlos todos y almacenarlos en la
base de datos permitiéndoles revisar cada uno de los valores de manera más clara y
disminuyendo el tiempo de captura de valores de los indicadores. Los cambios
realizados en este software afectarán al de TMC, ya que se podrán cambiar los
nombres de las etiquetas de las gráficas y de los valores que mostrarán al dar los
reportes de cada uno de los periodos.
TMC: en este software se presentarán cada uno de los indicadores, pero en vez de
mostrarlos en tablas se mostrarán en forma gráfica, además de que también se podrán
agregar varias variables en los indicadores de las gráficas. Y todas sus graficas
10
tendrán la comparación de los periodos anteriores para poder visualizar el cambio en
el rendimiento de cada una de sus áreas.
La correcta realización del proyecto beneficiará a la empresa Fénix ya que da paso a que la
empresa Peña Colorada los vuelvan a solicitar para realizar la automatización de otros
procesos que tiene la empresa, así como la actualización de sus sistemas disminuyendo el
tiempo que tomaría realizar cada una de las distintas actividades.
11
3. Objetivos
3.1 Objetivo general
Desarrollar e implementar un software para el área de operación de Trituración, Molienda
y Concentración (TMC) de Peña Colorada, el cual permitirá el registro, modificación y
control de variables e indicadores de las dos plantas de la empresa, así como de las presas
y pozos de agua.
3.2 Objetivo específicos
1. Analizar los datos capturados hasta el momento en la base de datos.
2. Determinar si es necesario modificar las tablas de la base de datos para que se
pueda implementar correctamente el software a realizar.
3. Analizar quienes tendrán acceso a dicho sistema y las áreas en las que se aplicará.
4. Realizar el software tomando en cuenta las validaciones necesarias en cada uno
de los campos que contendrá.
5. Modificar el software dependiendo de las incidencias que sean identificadas en la
fase de testeo.
6. Implementar el software en la empresa una vez que se encuentre sin incidencias
y funcionando correctamente.
7. Capacitar al personal que utilizará el software.
12
4. Problemas a resolver
El sistema de captura, análisis y representación de los valores obtenidos en cada uno de los
indicadores se realizaba mediante tablas de Excel. Dicho sistema era demasiado lento y
propenso a errores, principalmente humanos al momento de capturar. Además, la gran
cantidad de valores manejados dificultaban su análisis y su representación al momento de
querer comprarlos con periodos anteriores, esto se hacía con el fin de poder tomar decisiones
con respecto al rendimiento de cada una de las áreas de peña colorada.
Para poder automatizar dicho sistema se propuso la realización de una aplicación web que
funcionaría con la red interna de la empresa, además de que contaría con un inicio de sesión
para la protección de los valores almacenados de toda la empresa. Con este sistema se
disminuiría el tiempo de captura, además de que su representación se realizaría
automáticamente por medio de graficas las cuales se generaría obteniendo los valores de los
periodos pasados y los compararía con los obtenidos actualmente. Esto permitirá que los
encargados de cada una de las áreas puedan tomar decisiones respecto al rendimiento que
han tenido en cada uno de los indicadores.
El nuevo sistema no solo permitirá capturar valores, si no también permitirá modificarlos en
caso de que algunos de los cálculos realizados no hayan coincidido con los valores obtenidos
directamente del indicador. Y como contará con dos partes se podrá modificar también las
etiquetas identificadoras de cada una de las gráficas para que así puedan ser los nombres
parecidos a los que se le conocen generalmente internamente en la empresa.
13
5. Procedimientos y descripción de actividades
Capacitación
Antes de comenzar el proyecto se me capacitó mediante un curso en línea. El curso se llama
ASP NET MVC 5 (C#): Desarrollando un portafolio profesional, el curso trata sobre cómo
desarrollar un sitio web usando tecnología ASP NET MVC. El tema a tratar fue desarrollar
un sistema de portafolio (Hoja de vida profesional) en la cual se estarán tocando punto por
punto todos los conceptos que conlleva ASP NET MVC. El curso consistió en 32 clases y
está compuesto en 3 partes.
Primera parte: se vieron los conceptos previos, los cuales fueron maquetación
usando Bootstrap3, jquery y un ejemplo con el Entity Framework
Segunda parte: se realizó un aplicativo para gestionar alumnos y así poder
comprender los conceptos de ASP NET MVC
Tercera parte: se desarrolló el proyecto de portafolio profesional, explicando
tanto el Back-Office, así como el Front-Office
El instructor fue Eduardo Patiño un desarrollador web con más de 6 años de experiencia. Ha
participado en proyectos bastantes ambiciosos como el grupo BBVA Continental, AFP
Horizonte, Grossio Group, entre otros haciendo sistemas a medida de comercio electrónico,
inventario, contabilidad, recursos humanos, pmi, etc. Asimismo, destaca a su blog personal
Anexsoft que le permite ayudar a los jóvenes en su crecimiento profesional mediante las
publicaciones que hace todas las semanas y los cursos de formación profesional que ofrece
(3).
TMC Proyecto
Como se explicó anteriormente, el proyecto se dividió en dos partes TMC y TMC
Configuración. A continuación, se explicará cada uno de los componentes de las dos partes
del proyecto.
TMC Configuración
Esta parte del proyecto consistió en 7 pantallas, a continuación, se explicarán cada una de
ellas.
o Captura TV
Los requerimientos de está pantalla fueron 4 módulos.
Primer Módulo:
En el primer módulo se pidió que pudiera leer archivos CSV, validar que los
campos cumplan con las especificaciones y una vez que estén validados
14
guardarlos o modificar sus valores en la base de datos. Este módulo tiene como
título “Seleccione un archivo (CSV)”
La extensión de archivo CSV significa Comma Separated Values (Valores
separados por comas). El formato es utilizado en muchos programas de bases de
datos, hojas de cálculo y gestores de contactos para almacenar listas de
información. Como un archivo de texto, el formato es ampliamente compatible.
(6)
Las columnas que traerá el archivo CSV junto con sus condiciones son
o TAGID:
Debe contener solo número enteros
Debe existir en la tabla de TAG en la base de datos
o Valor:
Solo debe contener números enteros y decimales
o Fecha de captura
Debe seguir el formato de dd/MM/yyyy HH:mm:ss o simplemente
dd/MM/yyyy
Una vez validadas las columnas se procede a su captura o actualización en la base
de datos. Para determinar si se capturará o si se actualizará debe cumplir con la
condición de que TAGID y Fecha de captura existan en la tabla Captura TV en la
base de datos, si existen en la tabla de Captura TV solo se actualizará el valor y
la fecha en la que se actualizó, poniendo en usuario Admin. Si no existen en la
tabla se agregarán como nuevos registros.
Segundo Módulo
Se le dio el nombre de “Ajuste de valores”. En este módulo se pidió lo siguiente:
Pedir un rango de fechas
Pedir un ID pantalla
Un botón que ejecute la función del ajuste
Este módulo realizará la generación de TAG ID en su tabla de la base de datos,
manteniendo la relación con el id pantalla que se seleccionó en el ajuste. Las
validaciones que posee es que se debe seleccionar un id pantalla y una fecha en
el rango de fechas, de lo contrario mostrará un mensaje de error. El mensaje de
error dirá lo que falta llenar para que pueda realizar su función.
15
Tercer Módulo
Se le dio el nombre de “Valores Existentes”. En este módulo se pidió lo siguiente:
Agregar un radio button en el cual se tuvieran dos opciones. Seleccionar
ID Pantalla o ingresar TAG ID
Dependiendo de la opción seleccionada en el radio button habilitar el
cuadro de texto requerido.
Seleccionar ID Pantalla: al seleccionar esta opción se
habilitarán dos combos boxes, los cuales son ID pantalla y
TAG ID. Deshabilitando la caja de texto de TAG ID.
Ingresar TAG ID: en esta opción se habilitará el cuadro de
texto de TAG ID en el cual solo se permitirá que se
introduzcan número enteros. Si está seleccionado se
deshabilitará los dos combo boxes de la opción de
seleccionar ID Pantalla.
Pedir un rango de fechas
Un botón que realice la función de búsqueda de los valores existentes en
la tabla captura tv de la base de datos
La función principal de este módulo es buscar los valores que se encuentran en la
tabla de la base de datos, tomando como delimitantes los valores requeridos. Si
alguno de ellos no es introducido aparecerá un mensaje de error pidiendo que se
introduzca dicho valor.
Cuarto Módulo
Se le dio el nombre de “Mantenimiento de valores”. En este módulo se pidió lo
siguiente:
Agregar un radio button en el cual se tuvieran dos opciones. Seleccionar
ID Pantalla o ingresar TAG ID
Dependiendo de la opción seleccionada en el radio button habilitar el
cuadro de texto requerido.
Seleccionar ID Pantalla: al seleccionar esta opción se
habilitarán dos combos boxes, los cuales son ID pantalla y
TAG ID. Deshabilitando la caja de texto de TAG ID.
Ingresar TAG ID: en esta opción se habilitará el cuadro de
texto de TAG ID en el cual solo se permitirá que se
introduzcan número enteros. Si está seleccionado se
deshabilitará los dos combo boxes de la opción de
seleccionar ID Pantalla.
Pedir una fecha en especifico
Pedir un valor el cual sea número y acepte decimales.
16
Un botón que realice la función de actualización de los valores existentes
en la tabla captura tv de la base de datos
La función principal de este módulo es editar el valor de una fecha en específico
con su TAG id y guardar el valor actualizado en la tabla correspondiente de la
base de datos. No deben encontrarse vacío ningún valor de los requeridos para la
actualización, en el caso de que alguno se encuentre vacío se mostrará un mensaje
de error diciendo que valor fue el que faltó para poder realizar el mantenimiento
de los valores correctamente. Los campos de este módulo también se pueden
llenar automáticamente seleccionado la opción de editar que viene en la parte de
acciones de la tabla. Dicha tabla aparece al momento de realizarse correctamente
la búsqueda de los valores en el módulo de “Valores existentes”.
Estructura
Esta pantalla de Captura TV se conforma de un controlador, sus modelos y sus
respectivas vistas.
En los controladores se le creó su propia carpeta para así poder tener un orden con
cada una de las pantallas. En la carpeta de modelos también se le creó su propia
carpeta, pero esta pantalla también utiliza elementos de la carpeta de “DBClass”
y por consiguiente se le creó su carpeta en las vistas para así poder tener todas sus
vistas en una sola carpeta. En las figuras 2, 3 y 4 se presentan las carpetas a las
cuales corresponde la pantalla de Captura TV.
Figura 2 Controlador Captura TV
17
Figura 3 Modelos de Captura TV
Figura 4 Vistas de Captura TV
En la parte del controlador se asignaron cada una de las acciones que van a utilizar
los métodos desarrollados en los modelos, así como pasar los valores a las vistas
de la pantalla.
En el modelo se agregaron varias clases como se puede apreciar en la figura 3, se
creó una carpeta con el nombre del proyecto “CapturaTV” en el cual se incluyeron
18
dos clases llamadas “GuardarTabla” y “Registros”. En la carpeta creada para
almacenar las clases vinculadas con la tabla de la base de datos se añadieron las
tablas de CapturaTV, TAG y la de IdPantalla.
En estas clases se crearon los métodos a utilizar en el controlador del proyecto
para que pueda realizar cada una de sus funciones correctamente. A continuación,
se explicarán cada uno de los métodos utilizados en el proyecto.
GuardarTabla
En esta clase solo se tiene un método, este tiene el nombre de “InsertarLista”. Su
función es como indica su nombre insertar la lista de los valores obtenidos al
momento de subir el archivo CSV en el software en la tabla correspondiente de
su base de datos. Esto permitirá agregar registros nuevos en caso de que no existan
en la tabla o de actualizarlos en caso de que existan en la tabla de la base de datos.
Figura 5 Métodos de la clase GuardarTabla
Registros
En esta clase se declararon las variables públicas para poder utilizarlas en el
controlador al momento de definir un objeto de la clase registros, en estas
variables se almacenarán los datos obtenidos por el archivo CSV que se subió y
validó. Se declaró un arreglo (array) de la clase registros para poder guardar las
variables declaradas en el controlador en una lista, y está lista poder utilizarla en
las clases que se requieran para su correcto funcionamiento. Un ejemplo de su uso
es en la clase de “GuardarTabla”.
19
Figura 6 Clase Registros
CapturaTVDB
En esta clase se declaran las variables que se utilizarán para poder mostrar la tabla
al realizarse correctamente la búsqueda de los valores en la tabla de la base de
datos de CapturaTV. Estas variables se declaran públicas para poder llamarlas en
la vista en donde se conforma la tabla a mostrar en la pantalla principal. Se
declaran varios métodos a utilizar para poder consultar valores en la base de datos,
esos métodos son:
Conteo: este sirve para poder contabilizar los valores obtenidos al
momento de realizar la búsqueda en la base de datos.
Listar: es una lista del mismo tipo que la clase, este método recibe 3
variables para poder funcionar. Los valores que recibe son fecha inicial,
fecha final y TAGID, estos valores se utilizan para poder delimitar la
búsqueda en la base de datos mediante las herramientas de Linq. La lista
obtenida se regresa en el método y se utiliza en el controlador, con esto
se logra utilizar los datos almacenados en la lista en la vista que contendrá
a la tabla que se visualizará con dichos valores al momento de delimitar
la búsqueda en la vista principal en el módulo de búsqueda de valores.
Buscar: se encarga de buscar los datos con la ayuda de 3 variables que se
solicitan al inicio de la búsqueda en el módulo de búsqueda de valores.
Al momento de encontrar dichos valores regresará una variable de tipo
booleana que determinará si fueron encontrados o no, en caso de no
encontrar dichos valores mandará un mensaje diciendo que el rango de
fechas no contiene registros. Esto ayudará a saber si se ocupa realizar el
registro de dichas fechas y se podrá hacer de una manera más rápida por
medio del módulo de subir un archivo en CSV.
ActualizarT: este se encarga de actualizar un valor en específico mostrado
en la tabla de búsqueda de valores. En caso de no existir se agregará a la
tabla de la base de datos. Este método también recibe 3 variables, fecha
de inicio, fecha final, TAGID y el valor que se le asignará a dicho registro.
Ajuste: se encarga de ejecutar un procedimiento almacenado creado en la
base de datos, y generará nuevos TAG’s dependiendo de lo que se
20
requiera en el sector de Captura TV y de los registros necesarios para su
control en la planta.
Figura 7 Métodos de la clase CapturaTVDB
DBTAGC
En esta clase solo se utiliza el método de Listar, este método se encarga de traer
la lista de todos los TAG que existen en su tabla en la base de datos delimitándolos
ya sea por medio de su id pantalla o simplemente traerlos a todos al momento de
realizar la búsqueda, se hace con el fin de poder obtener su descripción y así tener
una idea clara de cuál es la funcionalidad de dicho TAG.
Figura 8 Método clase DBTAGC
IdPantallaDB
En esta clase se utilizan dos métodos:
Conteo: este solo sirve para contabilizar cuantos registros existen en la
base de datos de la tabla a utilizar
21
Listar: este método trae la lista de los IdPantalla existentes en la base de
datos con sus nombres para poder mostrarlos en el combo de la vista
principal y así poder delimitar los TAGID que serán mostrados en el
Combo que se encuentra a un lado del de ID Pantalla.
Figura 9 Métodos de la clase IdPantallaDB
Figura 10 Combos en la pantalla principal
En la parte del controlador se explicarán las acciones realizadas en el proyecto
de captura tv. En dichas acciones se utilizarán cada uno de los métodos creados
en las clases de los modelos.
Las variables finales que se utilizaron en el controlador son las mostradas en la
figura 11. Se tienen variables tipo objeto, tipo lista y las globales. En los
proyectos (softwares) que se desarrollarán a lo largo de este proyecto siguen el
mismo formato y declaración de variables.
Figura 11 Variables Controlador
22
Las acciones utilizadas en el controlador se pueden apreciar en la figura 12. A
continuación se explicará que función desarrolla cada una de ellas.
Figura 12 Acciones Controlador
Index
En esta acción se manda la lista que compondrá el combo box de las opciones
del combo box de ID Pantalla del módulo de valores existentes y mantenimiento
de valores. Además de que en esta acción se crea la vista principal que tendrá
este software.
ObtLista y ObtLista2
En estas acciones se realiza el llenado del combo box de TAG ID, la primera es
para el módulo de “Valores existentes” y la segunda es para el módulo de
“Mantenimiento de valores”. La función que tiene es como se dijo anteriormente
llenar los combos boxes, pero se delimita dependiendo del ID Pantalla que se
seleccione. Para poder mandar el valor del ID Pantalla seleccionado a las
acciones del controlador se realiza una función de javascript. En dicha función
se declara el llenado del combo box de TAG ID con los valores obtenidos en las
acciones, estos valores se pasan a la función por medio del return que tienen las
acciones declaradas en el controlador. El return puede ser que mande el valor a
la vista (return view()) o que regrese los valores a la función de javascript (return
json()). Los returns dependerán del tipo de acción que se declare, ya sea un
ActionResult o un JsonResult. En este caso son JsonResult.
23
GuardarAdjunto
Está acción realiza el guardado del archivo que se subió en el módulo de “Carga
Archivo CSV”. Los datos que son recibidos por medio del archivo son evaluados
en esta acción, si la validación de dichos valores fue exitosa se guardan en una
variable del tipo lista. Esta variable es utilizada en otra acción para poder
almacenar los datos en la base de datos.
Tabla
En esta acción se pasan los datos almacenados en la variable tipo lista de la acción
“GuardarAdjunto”. Los datos recibidos se mandan a la vista “Tabla” y se
muestran en una tabla para que se pueda dar una última revisada de los datos que
se están subiendo del archivo antes de ser guardados en su tabla en la base de
datos.
GuardarTabla
En esta acción se procede a guardar los valores validados del archivo que se
subió, es decir, de los valores almacenados en la variable tipo lista de la acción
“GuardarAdjunto” en la tabla correspondiente de su base de datos.
BuscarTa
En esta acción se reciben los valores de las delimitaciones del módulo de
“Valores Existentes”. Una vez recibidos los valores de la vista por medio de su
función de javascript se procede a ejecutar el método creado en el modelo por
medio de una variable tipo objeto. Los valores obtenidos de la ejecución de
método se guardan en una variable del tipo lista y se pasan los valores de dicha
variable a la acción de “TablaBusqueda”.
TablaBusqueda
En esta acción se utilizan los valores obtenidos de la acción “BuscarTa” y se
pasan a la vista “TablaBusqueda” para poder mostrarlos en una tabla, junto con
sus acciones de edición.
Actualizar
En esta acción se pasan los valores obtenidos del módulo de “Mantenimiento
Valores” y se ejecuta un método, llamándolo por medio de una variable tipo
objeto. Si la actualización se realizó correctamente mostrará dicho mensaje en la
parte superior del título del módulo, actualizando con ella la tabla del módulo de
“Valores Existentes”.
24
AjusteSP
En esta acción se realiza la generación de TAGS en la tabla de “Captura TV”
dependiendo del rango de fechas y del ID Pantalla seleccionado en el módulo de
“Ajuste de valores”. Si el ajuste no se realizó correctamente se mostrará un
mensaje marcando el error obtenido al tratar de ejecutarlo, en cambio si se realiza
correctamente se mostrará un mensaje mostrando su correcto funcionamiento.
Los valores recibidos del módulo de “Ajuste de valores” son enviados a su
método mediante la misma lógica con su variable tipo objeto, solo con la
diferencia de que no regresa una lista de valores.
o Presupuesto
El siguiente software se realizó para poder leer archivos CSV, se validará que los
campos cumplan con sus condiciones y especificaciones. Una vez validados se
guardarán o se modificarán sus valores en la Base de datos (BD).
La base de datos en la que se basará el software será la misma utilizada en los
softwares anteriores, solo que se usan dos tablas nuevas en las cuales se hacen las
consultas y el guardado de la información. En el proyecto que se había realizado
para juntar las distintas aplicaciones se crea un controlador, en el cual se
agregarán los eventos correspondientes para el correcto funcionamiento del
software.
Figura 13 controlador creado para el software
Las columnas que traerá el archivo CSV junto con sus condiciones y
especificaciones son:
IdPantalla:
o Deberá contener solo números enteros
o Su valor debe ser mayor o igual a 1 y menor o igual a 8
TAGId:
o Deberá contener solo números enteros
25
o Debe existir en la tabla TAG de la base de datos
Tipo:
o Deberá contener solo números enteros
o Debe ser diferente de cero
o Debe existir en la tabla tipo presupuesto de la base de datos
Valor:
o Deberá contener números enteros y decimales
FechaCaptura:
o Deber ser solo la fecha, sin la hora. Pero no marcar error si introduce
la hora, solo quitar la hora al momento de mostrar la tabla en la vista
Para poder decidir si se insertarán o si solo se actualizarán los datos en la tabla
presupuesto de la base de datos con los valores que se introdujeron en el archivo
CSV, se debe tener en cuenta lo siguiente:
Actualizar los datos:
Si el IdPantalla, TAGId, Tipo y FechaCaptura coinciden con algún valor
almacenado en la tabla presupuesto de la base de datos, entonces se actualizará
solo el valor de la columna con el mismo nombre (“valor”) y se pondrá la fecha
en la que se actualizó dicho valor.
Insertarlos como nuevos registros:
Si el IdPantalla, TAGId, Tipo y FechaCaptura NO coinciden con algún valor
almacenado en la tabla presupuesto de la base de datos, entonces se agregarán los
valores obtenidos del archivo CSV como nuevos en la tabla presupuesto de la
base de datos, junto con la fecha en las que se agregaron.
Figura 14 Vista de la carpeta con sus modelos
En la carpeta llamada “Models” se agregarán los modelos a utilizar en el proyecto,
en la imagen se puede apreciar una carpeta llamada “DBClass” en esta carpeta se
26
crearon las distintas clases a utilizar y se les dio un nombre distintivo para poder
saber a qué tabla de la base de datos corresponde.
En la carpeta llamada “PresupuestoT” se agregaron las clases a utilizar con cada
uno de los métodos necesarios para el correcto funcionamiento del software, estas
clases contienen los métodos que se utilizarán la parte del controlador.
Las vistas realizadas se agregaron en una carpeta con el nombre del software que
se está realizando, se debe destacar que las vistas están en html. Además, se
incluyen algunas clases que contienen diferentes estilos, los cuales son necesarios
para el diseño de la vista, así como para poder utilizar algunos de los componentes
que la integran. Algunas de las clases que se agregan son:
Js: scripts de Jquery
Css: estilos de la vista (stylesheet)
Fonts: estilos de letras
Figura 15 carpeta que contiene a las clases que definen los estilos a utilizar en la vista
los estilos que se usan para la vista con el nombre “index” se agregan en la vista
con el nombre de “Layout”
27
Figura 16 Vista "Layout" con los estilos que se usan en la vista "index"
En la siguiente fase del proyecto, me dediqué a realizar las clases que pertenecen
al proyecto “Presupuestos” en donde creé cada uno de los métodos a utilizar en
el controlador de la aplicación.
Figura 17 Clases agregadas como modelos
En la carpeta models como se muestra en la figura 17, se puede apreciar la carpeta
creada para el proyecto llamada “PresupuestoT”, en ella se puede apreciar las dos
clases creadas. A la carpeta que contiene las clases a utilizar se le conoce como
dice el nombre de su carpeta principal como modelos, esto significa que en ellas
se integrarán los métodos a utilizar en el controlador principal del proyecto y en
donde se incluyen las referencias a utilizar en las vistas, ya sea para mostrar una
tabla o simplemente llamar valores y mostrarlos en las vistas deseadas.
GuardarTabla
Esta clase se creó con el fin de crear métodos que servirán para guardar los
valores de la tabla que se han mostrado al cliente. Solo se guardarán los valores
si las validaciones se desarrollaron con éxito, es decir, que todos los campos
requeridos cumplan con las especificaciones mencionadas anteriormente.
Además, de guardar los datos, también realiza una actualización de ellos en caso
de que ya exista y cumpla con lo establecido. Los valores obtenidos que tendrá
la tarea de guardar esté modelos se almacenarán en la base de datos, en la tabla
especificada al inicio del proyecto.
28
Figura 18 Contenido del Modelo PresupuestoT
Como se aprecia en la figura 18, se creó el método para Guardar los valores. Este
método recibe un valor del controlador, el cual se llama lista. Este valor contiene
cada uno de los campos solicitados al inicio de la aplicación, es decir, lo que
contiene el archivo CSV. Teniendo estos valores guardados en una variable del
tipo list se puede proceder a utilizarlos de manera libre y realizarles las acciones
que sean necesarias para el buen funcionamiento de la aplicación y su correcto
almacenamiento en la tabla de la base de datos.
Registros
Esta clase se creó con el fin de crear métodos que servirán para crear variables
generales del modelo, las cuales se mandarán a llamar en el controlador para
poder almacenar la información de las columnas que contendrá el archivo CSV.
Además, contiene un método llamado obtener de tipo Array. Este método servirá
para poder almacenar los valores obtenidos en una lista, la cual se llenará desde
el controlador. Para poder utilizarlo se debe declarar en la parte inicial del
controlador y como se puede apreciar en la figura 19, retorna la estructura de la
lista. Esto quiere decir que la deja preparada para ser utilizada en su controlador.
29
Figura 19 Modelo con la clase Registros. Con sus variables y métodos
DBClass
Como se explicó anteriormente se creó un modelo llamado “DBClass” el cual
contiene las clases pertenecientes a la base de datos, es decir, que cada una de
ellas representa a los valores contenidos en las tablas a utilizar a lo largo de todo
el proyecto.
Figura 20 Clases en el modelo DBClass
Como se puede apreciar en la figura 20 el modelo DBClass solo contiene dos
clases, esto significa que por el momento solo se utilizarán dos tablas de la base
de datos para realizar las consultas necesarias para la validación de los diferentes
campos que se requieren en la aplicación, en caso de requerir una nueva tabla
simplemente se crea la clase con el nombre de la tabla que se utilizará con un
distintivo en el modelo de DBClass y se actualizará la base de datos en todo el
proyecto añadiendo la tabla que se necesite.
30
Figura 21 Clase DBTAGC
En la clase “DBTAGC” se crearon 3 métodos:
o Conteo: sirve para saber cuántos valores contiene en total la tabla
seleccionada y llevar un conteo de ellos.
o Listar: es un método de tipo List que hace referencia a la tabla que
utilizará. Recibe un valor entero del controlador, dicho valor lo
utilizará para poder realizar la búsqueda necesaria para el
funcionamiento de la aplicación y regresará los resultados de su
búsqueda en forma de una lista. Esta lista se podrá mandar a llamar en
las vistas que sea necesaria su información para mostrar los datos
necesarios al cliente.
o Buscar: este método es de tipo booleano, esto quiere decir que
retornará una variable que solo puede tomar dos estados. Estos estados
son de verdadero y falso dependiendo del resultado obtenido en la
búsqueda que realice en la tabla correspondiente. Se puede apreciar
que recibe un valor de tipo String del controlador, este valor es el
principal indicativo para poder realizar la búsqueda de sus datos y
declarar si existe o no. El resultado que se obtenga de la búsqueda se
mandará al controlador y se podrá utilizar una vez que se declare un
objeto del tipo de la clase y se mande en llamar en donde sea necesario
su resultado.
En la siguiente fase del proyecto, me dediqué a realizar el controlador que
pertenecería al proyecto “Presupuestos” en donde creé cada una de las acciones
que se necesitaría para mandar a llamar los métodos creados en las clases del
modelo.
31
Figura 22 Controlador del proyecto "Presupuesto"
En el controlador se declararon 4 acciones principales, las cuales realizan la
implementación de los métodos creados en el modelo. En la figura 2 se puede
apreciar cada una de las acciones creadas, las cuales se explicarán a continuación.
Figura 23 Estructura del controlador
Al inicio del controlador se declaran las variables generales, estás variables son
las que se utilizan en más de una acción.
Index
Es la acción que llama a la vista principal con el mismo nombre que su acción
“Index”. En esta primera etapa del proyecto en la vista principal no es necesario
mandar datos al inicio de la aplicación, esto quiere decir que no se inicializan
componentes que requieran información de tipo lista para poder visualizar la
pantalla principal del software. Esto significa que la acción “Index” se queda
vacía, teniendo solo el return de su vista.
Guardar Adjunto
Como se puede apreciar en la figura 23, esta acción tiene un [HttpPost] y un
[WebMethod (EnableSession = true)] antes de entrar en la acción.
32
[HttpPost]:
HTTP es un protocolo de transferencia de hipertexto, está diseñado para
establecer la comunicación entre el cliente y los servidores. Trabaja como un
protocolo de solicitud y respuesta entre el cliente y el servidor. un ejemplo es un
navegador y una aplicación en una computadora que aloja un sitio web, en ese
caso el navegador sería el cliente y la aplicación con el sitio web sería el servidor.
Uno de los métodos de respuesta de HTTP es el POST, esté método envía datos
para ser procesados por un recurso específico. (10)
Teniendo en cuenta estas definiciones se puede decir que un HttpPost es una
solicitud que envía datos desde el navegador hacia el servidor para poder utilizar
dichos datos en lo que sean requeridos, en este caso en la acción del controlador
de presupuesto.
Para poder utilizarlo en el proyecto se declaró en la función de script creada en
la vista Layout del proyecto que tipo de datos serían los que recibiría la acción
mediante ajax.
Figura 24 Función en la vista Layout
[WebMethod (EnableSession = true)]:
Es un método de servidor el cual se puede llamar desde javascript con el método
Ajax y ser implementado en el controlador de un proyecto .NET. (7)
Por lo tanto, esté método establece que estará activa una sesión de usuario, esto
quiere decir que se pueden inicializar variables y utilizar sus valores almacenados
en otras acciones del controlador.
33
La acción de guardar adjunto es de tipo Json esto quiere decir que regresará un
contenido en formato tipo json. Json (Notación de Objetos de JavaScript) es un
formato ligero de intercambio de datos. Json está constituido por dos estructuras:
• Una colección de pares de nombre/valor. En varios lenguajes esto es
conocido como un objeto, registro, estructura, diccionario, tabla hash,
lista de claves o un arreglo asociativo.
• Una lista ordenada de valores. En la mayoría de los lenguajes, esto se
implementa como arreglos, vectores, listas o secuencias
Por lo tanto, los datos que recibe le son enviados desde un script de javascript en
la vista layout, y regresa ya sea una variable que contiene los mensajes de error
que se presentaron en algunas de las validaciones de dicha acción o un mensaje
de que la validación ocurrió correctamente. (9)
En esta acción se guardarán los datos validados del archivo tipo CSV que se subió
por el cliente en la vista inicial. Y dichos datos se mandarán en forma de lista a
la vista “Tabla”. Los métodos que son llamados en esta acción son:
Lista de la clase registros
Buscar de la clase DBTAGC
Buscar de la clase DBTipoPresupuesto
Guardar tabla
En esta acción se guardan los datos que se obtuvieron en la acción de
“GuardarAdjunto”, los datos que se guardaron en la lista se inicializan por medio
de una sesión en la acción de “GuardarTabla”. Teniendo la lista en la acción se
manda a llamar el método Insertarlista de la clase GuardarTabla y se manda la
lista que se obtuvo. Lo que realiza en si está acción es el guardado de los datos
ya validados en la tabla que le corresponde de su base de datos.
Tabla
La acción tabla solo se encarga de mostrar la tabla con los datos que se obtuvieron
y validaron correctamente del archivo CSV, mandando la lista a su vista “Tabla”.
Para que así se pueda realizar una vista previa de los datos que se insertarán en
la tabla de la base de datos.
En la siguiente fase del proyecto se tuvieron que realizar varios cambios, dichos
cambios fueron los siguientes:
• Se agregaron dos tablas nuevas de la base de datos
34
• En el modelo se crearon dos clases correspondientes a su tabla en la base
de datos
• Se agregaron nuevas variables en la clase registros
• Se crearon 4 acciones nuevas en el controlador y se modificó una de ellas
junto con sus vistas
Los cambios que se realizaron se hicieron con el propósito de mejorar el software
que se tenía previsto al inicio. Las mejoras que se le aplicaron servirán para que
los encargados de las diferentes áreas puedan examinar de una manera
especializada cada uno de los factores generados en el área de presupuestos,
además de que les permite seleccionar una fila de la tabla y corregir algún valor
que se haya capturado incorrectamente al momento de subir su archivo en CSV.
Se agregaron 3 módulos. Para que cada uno de ellos pudieran funcionar de manera
óptima se crearon varios scripts con funciones en javascript, jquery y Ajax para
poder vincularlos con su acción en el controlador y poder obtener los datos que
se mostrarán en cada uno de ellos.
Primer Módulo
En el primer módulo se tiene la selección del archivo CSV del que se desea
guardar los valores en la base de datos. Además, incluye la verificación del
archivo y el botón de guardado no se activa hasta que se verifique correctamente
el archivo seleccionado.
Esté modulo no tuvo muchos cambios, solamente se le aplicó que no apareciera
la tabla al momento de la correcta verificación del archivo. Esto se hizo con el fin
de no sobrecargar con información la vista del software y se pudiera apreciar de
una manera sencilla los valores obtenidos en los siguientes módulos.
Segundo Módulo
Este módulo es una de las modificaciones que se le aplicó al software, en él se
realizará la búsqueda de los presupuestos que existen en dicha tabla. Para poder
traerlos se deberá asignar ciertos filtros, los cuales son:
• Fecha de inicio
• Fecha final
• El nombre de la pantalla que se quiere visualizar
• El nombre del TAG que se requiere
• El nombre del tipo de presupuesto que se necesita visualizar
Una vez asignados esos filtros se puede proceder a realizar la búsqueda, una vez
terminada satisfactoriamente mostrará una tabla con los valores encontrados de
acuerdo a las opciones seleccionadas y el rango de fecha introducida. El número
de elementos a mostrar en las opciones del tag dependerán de la opción
seleccionada en el id pantalla. Se determinó de esta manera para poder reducir el
35
número de elementos mostrados y así no confundir al cliente al momento de
querer seleccionar alguna de las opciones.
Tercer Módulo
Este módulo pertenece a la nueva sección requerida en el software, en él se podrá
realizar la actualización de los datos de una fila en específico y se podrá modificar
su valor. También se podrán agregar registros nuevos si se selecciona una opción
en cada uno de los filtros. Los cambios que se realicen en este módulo no solo se
mostrarán automáticamente en la tabla que se visualizó en el segundo módulo,
dicho valor se actualizará en la tabla de la base de datos correspondiente.
Al final el controlador de “Presupuestos” con algunos cambios realizados después
de la revisión del encargado de pruebas, quedó de la siguiente manera:
Figura 25 Controlador. Variables utilizadas
Como se puede apreciar en la figura 25, se añadieron nuevas variables al
controlador. Esto se hizo con el propósito de poder usar los métodos realizados
en las clases del modelo.
Variables primera sección
En esta sección se declararon variables tipo objeto, estas tienen la finalidad de
poder llamar tanto variables públicas o métodos almacenados en su modelo. Esto
quiere decir que, si en el controlador se ocupa llamar ciertas variables de un
modelo, simplemente se declara la variable tipo objeto después de puede utilizar
dicha variable y seguido de ella un punto (.). Al realizar esto aparecerán las
distintas variables almacenadas en el modelo, así como sus métodos. Su
simplicidad para poder utilizar los elementos de un modelo es que hace a
ASPNET.MVC una herramienta muy útil en proyectos largos o en la
organización de ellos para poder llevar a cabo la retroalimentación de un equipo
de desarrolladores que trabajan en un mismo proyecto.
36
Figura 26 Controlador. Variables Tipo Objeto
Variables segunda sección
En la segunda sección se declararon las variables tipo lista. Estas tienen la
finalidad de poder guardar información en una lista y poder llamarlas en la vista
correspondiente a su acción. Para poder utilizarla debe coincidir su clase con la
clase de la variable tipo objeto que se utilice para almacenar la información en
sus variables públicas o en su defecto poder pasar información obtenida en la
vista por medio de variables declaradas en la acción y mandarlas al método
llamado por la variable tipo objeto.
Figura 27 Controlador. Variables Tipo Lista
Un ejemplo de esto se puede apreciar en la figura 28. Como se puede apreciar se
pone primero la variable tipo lista, después del igual se coloca la variable tipo
objeto y enseguida se llama al método que se necesita aplicar en la acción. Como
se explicó anteriormente y se aprecia en las figuras 26 y 27 la clase de la variable
tipo lista y objeto coinciden, esto es muy importante ya que si no coincidieran se
obtendría un error de compatibilidad entre las variables. También se puede
apreciar en figura 28, como es que se declara una variable del tipo string al inicio
de la acción, esto significa que recibirá un valor de una de las vistas dependiendo
de la función declarada tipo javascript en la vista layout. Una vez recibido el
valor se manda al método llamado por la variable tipo objeto. El método que
recibirá dicha variable también debe recibirla al inicio de la declaración del
método como se aprecia en la figura 29.
Figura 28 Controlador. Acción utilizando variables tipo lista y objeto
37
Figura 29 Controlador. Método recibiendo una variable del controlador
Variables tercera sección
Estas variables se declaran al inicio del controlador con la finalidad de que se
puedan utilizar en cualquiera de las acciones realizadas. Si se desea que se
almacene cierta información en una de estas variables y poder utilizarla en otra
acción con la información almacenada, se puede utilizar un inicio de sesión en
variable, este inicio de sesión se declara primero en donde se asigna el valor a la
variable y después se declara llamándola en la acción que se requiera dicha
información. Para que no genere error al momento de terminar el funcionamiento
total de la aplicación se debe cerrar sesión en la acción en donde terminé el
software.
Figura 30 Controlador. Variables generales
Cuerpo del controlador
En esta sección se crean las acciones a utilizar en el proyecto. Con las
modificaciones realizadas después de la revisión se quedó con un total de 8
acciones en el controlador, con un total de 2 vistas. Estas vistas son las que le dan
la visualización al software, sin contar la de layout en donde se colocan las
librerías y los estilos que contendrán las vistas principales.
38
Figura 31 Controlador. Acciones realizadas
o Factor Extracción
En esta pantalla se solicitó realizar dos módulos:
Valores Existentes: en este módulo se realiza la búsqueda de los
valores que se encuentren almacenados en la tabla con el nombre de
Factor. Para realizar la búsqueda se necesita ingresar un rango de
fechas y oprimir el botón de búsqueda, una vez realizada la búsqueda
mostrará los resultados en forma de tabla mostrando si su valor es
diario o mensual.
Mantenimiento de valores: en este módulo se modificarán cada uno de
los valores que se requieran de la tabla “Factor”, al ser modificados se
guardarán los nuevos valores en la base de datos. Este módulo cuenta
con varias validaciones entre ellas están:
Debe seleccionar una fecha
El valor no puede encontrarse vacío
Se deberá seleccionar una opción, ya sea diario o mensual.
Teniendo esto en cuenta se determinará la acción que realizará el software, es
decir, se tendrán dos escenarios dependiendo de la opción seleccionada (Diario
o Mensual). A continuación, se describen dichos escenarios:
Diario: esta opción permitirá cambiar solo el valor del campo con el
nombre de “Diario” en la tabla mostrada en la búsqueda, tomando en
39
cuenta la fecha que se introduzca en el campo del módulo de
“Mantenimiento Valores”.
Mensual: esta opción permitirá modificar el valor del campo con el
nombre de “Mensual” en la tabla mostrada en la búsqueda, tomando en
cuenta la fecha introducida en dicho campo en el módulo de
“Mantenimiento de valores”. La diferencia que tiene con la opción de
diario es que se modificarán todos los valores de la fecha que sean
menores a la seleccionada teniendo como limite el primer día del mes que
se introdujo al realizar la actualización de valores. Una vez modificados
los valores de las fechas anteriores se modificarán los valores de las
fechas posteriores a la fecha seleccionada hasta el final del mes que se
introdujo dejando a los valores con un valor nulo. Por ejemplo, si se
seleccionó el día 9 de abril del 2018 y al realizar la búsqueda apareció
que poseía la columna con el nombre “mensual” con valores hasta el 11
de abril entonces se modificarán los valores de la columna de “mensual”
desde el 9 de abril del 2018 hasta el 1 de abril del 2018 con el valor que
se designó en la actualización y lo que ya existían después del 9 de abril
se modificará y se dejará en nulo hasta el 30 de abril.
Teniendo esto en cuenta se procedió a crear el modelo con los métodos a utilizar
para realizar el correcto funcionamiento de la pantalla.
Figura 32 Modelo de factor extracción
En la clase de registros se crearon 4 variables generales y 5 métodos, el
funcionamiento de cada uno de estos métodos se explicarán a continuación.
40
Figura 33 Clase Registros
Conteo
En este método se realiza como su nombre lo indica el conteo de todos los
registros almacenados en la tabla factor de la base de datos, su funcionalidad es
llevar ese conteo al método listar para poder visualizar los valores que se están
solicitando.
Listar
Este método tiene la función de listar los valores que se solicitaron en el módulo
de valores existentes, este método pide como variables iniciales la fecha inicial y
la fecha final para que así con la ayuda de Linq se pueda realizar la búsqueda en
la tabla “Factor” de la base de datos. Los valores obtenidos de dicha búsqueda en
la base de datos se almacenan en una variable del tipo lista para que se pueda
llamar desde el controlador y poder mandar los valores a la vista.
Buscar
Este método se encarga de validar si el rango de fechas introducido es correcto y
si existe algún registro en dicho rango, una vez validado se procede a pasar los
valores de la fecha inicial y final al método listar esto se hace con el fin de poder
visualizarlos en la vista y controlador.
41
ActualizarT
Este método se encarga de modificar o agregar los valores que se introduzcan en
el módulo de mantenimiento de valores. Dichos valores se guardarán en la tabla
correspondiente de la base de datos. Los valores que requiere para funcionar son
fecha, valor y si es diario o mensual el valor.
CalFactorMen
Este método se encarga de ejecutar un procedimiento almacenado de la base de
datos para poder calcular el factor mensual de una fecha en específico, en el
entregable oficial se quitó está parte por fallas en el procedimiento almacena y se
optó por realizar el procedimiento desde el código de MVC dependiendo de las
opciones que seleccione el usuario.
Teniendo los métodos se procedió a realizar el controlador de la pantalla. En el
controlador se crearon 5 acciones, una variable tipo objeto, una variable del tipo
lista y 3 variables generales a utilizar en todo el controlador.
Index
En esta acción no se regresó ningún valor a la vista principal, pero compone la
vista inicial de esta pantalla
Tabla
En esta acción se manda a llamar por medio de la variable tipo lista y tipo objeto
al método de Listar y se manda a la vista de tabla para poder visualizar los valores
en un datatable.
BuscarTa
En esta acción por medio de la variable tipo objeto se procede a llamar al método
buscar y se validarán los valores recibidos, una vez validados los pasará a la
acción Tabla para que el método listar pueda realizar su actividad correctamente
Actualizar
En esta acción se procede a llamar al método de ActualizarT, para ello recibe los
valores obtenidos del módulo de mantenimiento de valores y lo pasa al método
42
de ActualizarT para poder realizar las acciones correspondientes, además de
hacer una validación de los valores recibidos para que el método pueda funcionar
correctamente.
CalFactorMensual
Este método se encarga de mandar los datos necesarios para que le método de
CalFactorMen pueda ejecutar el procedimiento almacenado necesario, pero
como daba errores en el procedimiento se procedió a eliminarlo del programa
oficial y realizar el procedimiento internamente en el MVC.
Figura 34 Variables Controlador
Figura 35 Acciones del controlador
En esta pantalla se crearon 4 vistas, se tienen la de “Layout” y “_ViewStart” que
son las generales para poder aplicar los estilos y archivos de Javascript. Después
se tiene la vista “Index” la cual es la principal de la pantalla, en esta vista se
crearon los dos módulos y se les dio el estilo solicitado. En la vista “Tabla” se
agregó el formato de visualización de los datos con el componente datatable,
agregando un ciclo foreach para poder visualizar cada uno de los valores
almacenados en la variable tipo lista del controlador.
43
Figura 36 Vistas de Factor Extracción
o Glosario
La pantalla “Glosario” consiste en dos módulos:
Búsqueda de TAG: en este módulo se debe seleccionar una opción de búsqueda.
En total posee 3 opciones seleccionar ID pantalla, ingresar TAG ID y mostrar
todos los tags. A continuación, se explicará que funcionamiento tendrá el modulo
dependiendo de la opción seleccionada.
Seleccionar ID Pantalla: al seleccionar está opción se habilitarán dos
combos mostrando los TAGs que pertenecen a cierto ID Pantalla
mostrados en el primer combo.
ingresar TAG ID: al seleccionar está opción se activará solamente el
campo de TAG ID en el cual se podrá solo ingresar números enteros, en
caso de que no encuentre el TAG solicitado regresará un mensaje
indicando que no existe en los registros dicho TAG
Mostrar todos los tags: esta opción dejará deshabilitados los combos y el
cuadro de texto que se encuentran en este módulo y mostrará todos los
TAGS almacenados hasta el momento en la base de datos.
Mantenimiento TAG: en este módulo se recibirá el número del TAG que se desea
modificar o agregar a la base de datos, seguido de su descripción. Al tener dichos
datos se podrá dar click en el botón de actualizar validando dichos valores, una
vez validados se procederá a guardarlos en la tabla de “TAG” de la base de datos.
Para la pantalla de glosario se creó una carpeta con su nombre para poder
almacenar los modelos a utilizar en el controlador, se utilizaron las clases de
“DatosActualizar”, “DBTAGC” y “IdPantallaDB”. En estas clases se crearon
los métodos necesarios para poder ejecutar cada una de sus acciones
correctamente.
44
Figura 37 Modelos Glosario
En la clase de DBTAGC se crearon dos métodos:
ListarGlo: en este método se reciben 3 variables del controlador, con los
valores de dichas variables se procede a realizar la búsqueda en la base
de datos delimitando los resultados con la opción que se seleccionó en el
módulo de “Búsqueda de TAG”. Los datos obtenidos se guardan en una
variable del tipo lista para poder visualizarlos en la vista de “Tabla” y
para poder llamarla desde el controlador.
BuscarGlo: esté método se encarga de buscar los TAGs solicitados
dependiendo de la opción que se seleccionó en el módulo de “Búsqueda
de TAG”. Si no existiera ningún TAG que cumpla con las
especificaciones mandadas regresará una variable de tipo booleana en
falso para así desde el controlador poder mandar el mensaje al usuario
indicando que no se encontraron dichos registros.
Figura 38 DBTAGC Métodos
Se declara un método de tipo booleano en la clase “DatosActualizar” en el cual
se regrese un verdadero si es que la actualización se realizó con éxito o un falso
si es que no se realizó correctamente. Este método guardará los nuevos valores
introducidos en el módulo de “Mantenimiento TAG”. Si ya existiera un registro
con el mismo ID entonces se procedería a actualizar su descripción, en caso
contrario se agregaría como un nuevo registro.
45
Figura 39 DatosActualizar Métodos
En la clase de “IdPantallaDB” se declaran dos métodos:
Conteo: su función es regresar el número de registros existentes en la
tabla “CatPantallaProcesos” de la base de datos para poder contabilizarlos
al momento de utilizar el siguiente método llamado Listar.
Listar: mandará la lista con los nombres y con sus respectivos ID de todos
los registros de la tabla “CatPantallaProcesos”, esta lista se utilizará para
llenar el combo box de ID pantalla.
Figura 40 IdPantallaDB Métodos
En el controlador se declararon 3 variables de tipo objeto, una variable del tipo
lista y 5 variables generales. Se realizaron 5 acciones en el controlador.
Index
En la acción con el nombre “Index” se mandó la variable que almacenaba la lista
de los Id Pantallla para poder llenar el combo box principal de la pantalla de
glosario.
46
ObtLista
Esta acción obtiene los tags que correspondan al id pantalla seleccionado en el
primer combo box.
TablaBusqueda
En esta acción se mandan los valores que se obtuvieron en el método de
“ListarGlo” y se pasan a la vista “TablaBusqueda”. Los datos mandados a dicha
vista por medio de esta acción del controlador se mostrarán en forma de tabla.
BuscarTa
En esta acción se mandan los valores obtenidos al seleccionar alguna de las
opciones del primer módulo y se validarán, una vez validados se mandan al
método “BuscarGlo” en el cual se realizará la búsqueda de los TAGS solicitados,
en caso de que no existan se mandará un valor de falso para que se muestre el
mensaje correspondiente en la vista principal indicando por qué no se pudo
obtener la búsqueda solicitada.
Actualizar
En esta acción se mandan los valores ingresados en el segundo módulo de
“Mantenimiento TAG”, al ser validados los valores se mandan al método de
“Actualizar” y se procede a guardarlos en la base de datos o actualizarlos
dependiendo del caso que se presente.
Figura 41 Variables controlador de Glosario
47
Figura 42 Acciones del controlador de Glosario
En total se crearon 3 vistas, como ya se había mencionado antes en todas se creó
la vista Layout. En la vista index se colocó el estilo que tendrían los dos módulos
creados y en la vista TablaBusqueda se creó la tabla que se mostrará cuando se
realicé una búsqueda correctamente.
Figura 43 Vistas de Glosario
o Configuración pantalla
Esta pantalla consiste en dos módulos.
Busqueda Id Pantalla: en este módulo se seleccionará de un combo box un
id pantalla, una vez seleccionado se podrá comenzar la búsqueda
presionando el botón correspondiente.
Mantenimiento ID Pantalla: en este módulo se introducirán valores en 3
campos, se tendrá que introducir un ID pantalla, un TAG ID y una
descripción. Se tiene la opción de una columna con acciones en la cual se
podrá presionar en dicho icono de la fila de valores que se desea modificar
y aparecerán en este módulo. En caso de que se requiera agregar uno
nuevo también se pueden introducir cada uno de estas variables.
48
Como en las demás pantallas se le creó su propia carpeta para guardar los
modelos que se utilizarían en ella. En total se utilizó la clase CP y la clase de
IdPantallaDB. La clase de IdPantallaDB es la misma que se utilizó en la pantalla
de glosario para poder llenar el combo box del primer módulo y del segundo
módulo con el nombre de IdPantalla.
Figura 44 Modelos de Configuración pantalla
En la clase de CP se tienen 4 variables generales y 3 métodos.
BuscarCP: este método se encarga de buscar el id pantalla solicitado en
el primer módulo en su respectiva tabla de la base de datos.
ListarCPC: si la búsqueda se realizó correctamente se procede a guardar
los registros solicitados en una variable del tipo lista para después ser
utilizada en el controlador.
Actualizar: este método se encarga de actualizar los valores que se
seleccionaron o en caso de que no existan de agregarlos como nuevos
registros en la base de datos. Para poder lograrlo recibe 3 variables del
segundo módulo.
49
Figura 45 CP Métodos
En el controlador se declararon 2 variables de tipo objeto, una del tipo lista y una
general. Además de que cuenta con 4 acciones.
Index
En esta acción se manda la lista que llenara los combos boxes de los dos módulos
de ID Pantalla.
TablaCP
En esta acción se manda la lista resultante de la búsqueda realizada en el primer
módulo, utilizando sus variables correspondientes para llamar sus métodos.
BuscarTa
En esta acción se reciben los valores obtenidos en el primer módulo y se validan,
una vez validados se procede a mandar los datos al método de “BuscarCP”.
Actualizar
En esta acción se reciben los datos obtenidos del segundo módulo y se validan,
una vez validados se mandan al método de “Actualizar” y se guardan o se
modifican en la tabla de la base de datos dependiendo del caso que se presente
50
Figura 46 Variables y acciones de configuración pantalla
Se crearon 2 vistas principales aparte de las que ya se explicó anteriormente que
poseen todas las pantallas (Layout y _ViewStart). En la vista Index se creó todo
el estilo y diseño de la pantalla, así como las acciones que realizaría cada uno de
los botones y su acomodo. En la vista de TablaCP se creó una tabla para mostrar
los valores obtenidos del método “ListarCPC”.
Figura 47 Vistas de Configuración pantalla
o Configuración departamentos
Esta pantalla se encuentra a nivel administrador, esto quiere decir que solo la
persona que cuente con los permisos de administrador podrá modificar los datos
que se muestran en está pantalla. Su finalidad es poder asignar los diferentes tag
a los departamentos que corresponden, esto significa que dependiendo del
departamento seleccionado será el que pueda visualizar cierto tipo de información
en las demás pantallas. Para poder saber quién es la persona que ingresó se tiene
51
una pantalla de inicio y de ahí se obtiene su identificación, así como el
organigrama para poder ubicarlo en el departamento correspondiente.
Se creó un modelo llamado Administrador en el cual se crearon los diferentes
métodos a utilizar en el controlador. En total se crearon 3 métodos, así como las
variables a utilizar para poder llamarlas desde el controlador y mandarlas con sus
respectivos datos a la vista solicitada.
Obtener_TagsDepartamentos_General: este método se encarga de obtener
todos los departamentos disponibles de acuerdo al organigrama existente
en la empresa
Obtener_TagsDepartamentos: este método se encarga de obtener los
departamentos correspondientes al unoid que posea el usuario que ingresó
al sistema
guardar_relacion: este método se encarga de guardar los tags que fueron
seleccionados para un departamento en especial.
Figura 48 Modelos de la pantalla de configuración departamentos (Administrador)
En el controlador se creó una variable de tipo objeto y 3 acciones.
Index
Como se ha mencionado en las pantallas anteriores es la principal que manda los
datos que aparecerán al incio de la pantalla.
_tabla
Esta acción imprime los valores de los tags que se necesitan para ser
seleccionados por medio de un check box en forma de tabla y darles el formato
necesario para poder visualizarlos de una manera clara y organizada
52
Guardar_relacion
Esta acción guarda los tags que fueron seleccionados junto con su departamento
en la tabla correspondiente de la base de datos. La relación se guarda
automáticamente en cuanto se seleccionan en check box los tags necesarios para
ese determinado departamento.
Figura 49 Controlador de configuración departamentos (Administrador)
En las vistas se crearon 3 en total, como se había mencionado antes la de Layout
que manda los estilos que se necesitarán para la pantalla. La vista Index que es la
principal, en la que se genera todo el diseño que lleva la pantalla y la vista _tabla
en la cual se coloca el diseño y los datos que se mostrarán en la tabla principal de
la pantalla.
53
Figura 50 Vistas de configuración departamentos (Administrador)
o Catálogos Demoras
Tiene la finalidad de poder modificar y listar los catálogos existentes, así como
los procesos a los que corresponden. Se podrá modificar su descripción, en caso
de que no existan se podrán agregar como nuevos registros tomando en cuenta los
indicadores solicitados en el tercer módulo. Por lo tanto, esta pantalla se decidió
conformarla por 3 módulos.
Catálogos: en este módulo se dividió en dos partes, en la primera se
mostrarán los registros que posean cada uno de los catálogos listados en
el combo box por medio de una tabla. En la segunda parte se podrá agregar
un nuevo registro dependiendo del catálogo seleccionado. Se puede
seleccionar el catalogo en la primera parte o seleccionarlo en el combo de
la segunda parte y poder cambiar su descripción caso de que ya exista o
crearle una nueva.
Catalogo demoras: en este módulo se podrá buscar los diferentes procesos
que están almacenados en la base de datos. Además de que los muestra en
forma de tabla con su respectiva columna de acciones que permite
modificar el registro seleccionado.
Catalogo demoras mantenimiento: en este módulo se podrá modificar un
registro en específico o agregarlo en caso de que sea necesario.
Se crearon dos clases en su modelo para poder crear en ellas los métodos
necesarios para hacer funcionar correctamente la pantalla.
54
ListasCombos
En esta clase se añadieron 8 métodos. Se añadió un conteo por cada tabla a
utilizar, asi como su método de tipo lista para agregar la búsqueda de los registros
existentes en cada tabla y con ellos poder llenar los combos boxes de los módulos.
RegistrosCatDem
En esta clase se añadieron 8 variables generales y 6 métodos.
ListarTabCat: este método recibe los valores seleccionados en el primer
módulo parte 1 y los almacena en una variable de tipo lista permitiendo
que sean llamados en el controlador. Además de que se podrán mostrar
en la parte 1 del primer módulo.
ActualizarCat: este método permitirá actualizar los registros que se
encuentran en cada uno de los catálogos existentes, tomando en cuenta
el catalogo seleccionado en la parte 2 del primer módulo.
BusquedaCG: permite buscar los registros que se encuentran en el
proceso seleccionado en el segundo módulo.
ListaCG: una vez realizada la búsqueda de los registros del proceso
seleccionado, se pasan a una variable del tipo lista para poder mostrar los
valores en una tabla.
ActualizarCG: este método permite actualizar el registro que sea
seleccionado del módulo 2 o agregar uno nuevo en caso de que sea
necesario.
Eliminar: esté método permite eliminar un registro en específico
seleccionado en el segundo módulo, al ser eliminado se retirará de la
tabla en la base de datos.
55
Figura 51 Modelos de Catalogo Demoras
Figura 52 Clase "ListasCombo" y sus respectivos métodos de catálogos demoras
56
Figura 53 Clase "RegistroCatDem" y sus respectivos métodos de catálogos demoras
En el controlador se crearon 2 variables de tipo objeto, una variable del tipo lista
y 4 variables generales. Las acciones creadas fueron 7 en cada una de ellas se
mandó a llamar los métodos creados en las dos clases correspondientes a la
pantalla.
Index
En esta acción se mandaron las listas que llenarían todos los combos boxes de
los módulos
ObtTabla
En esta acción se utilizó el mismo método utilizado en pantallas anteriores para
poder mostrar los diferentes registros que posee cada uno de los catálogos que se
encuentran en el combo box del primer módulo parte 1.
ActualizarCAT
En esta acción se recibieron los valores introducidos en la parte 2 del primer
módulo y los mandan a su método correspondiente para almacenarlos en su base
de datos.
57
BuscarCaDem
Esta acción se encarga de validar los datos introducidos en el segundo módulo,
una vez validados se mandan a su método para comprobar que existan en la base
de datos. Si existen se mostrarán en una tabla, en caso de que no existan se
mostrará un mensaje indicando que dicho proceso seleccionado no posee
registros.
TablaCG
En esta acción se mandan a llamar los registros validados y almacenados en la
variable tipo lista de su respectivo método. Estos valores se mandan a su vista y
se representan en forma de tabla.
ActualizarCaDem
Esta acción permite actualizar los registros existentes en el módulo 2 y en caso
de que sea necesario se podrán agregar nuevos registros a su base de datos.
Eliminar y EliminarReg
Estas acciones se encargan de eliminar los registros que se seleccionen por medio
de la acción de la primera columna del segundo módulo, una vez seleccionados
se pedirá confirmación. En caso de que no se confirme se dejará sin ningún
cambio el registro, pero si se acepta se eliminará de su tabla en la base de datos.
Figura 54 Controlador Catálogo Demoras
58
Figura 55 Variables Controlador de Catálogos Demoras
Figura 56 Acciones controlador de Catálogo Demoras
En esta pantalla se crearon 3 vistas. Index que es la principal, ObtTabla que es
en donde se mandan los valores a mostrar en la tabla de la primera parte del
módulo 1 y TablaCG en la cual se mostrarán los valores obtenidos a partir de la
selección hecha en el segundo módulo.
59
Figura 57 Vistas de Catálogos Demoras
TMC
En este proyecto se siguió otro método para acomodar las clases con los métodos, las
variables a utilizar, su controlador y vistas. Se agregaron dos librerías de clases, la primera
se le llamó Bussines y a la segunda Model. En Bussines se agregaron los métodos a utilizar
y en Model se agregaron las variables de cada una de las tablas a utilizar para que pudieran
ser validadas por medio de Data Annotations.
Como solo se ocupaba dar una demostración de lo que sería el proyecto se crearon solo las
pantallas sin funcionamiento de dos de los indicadores que fueron energía y agua. En la
sección de resultados se presentan dichas pantallas.
Figura 58 Estructura del proyecto de TMC
60
6. Resultados
TMC Configuración
Los cambios que se realicen en cada una de estas pantallas de este software afectarán a
los datos que muestra el proyecto de visual flash y TMC, en si este software está a nivel
administrador para que en los otros softwares se puedan presentar los indicadores de una
manera en la que ellos puedan comprenderlos y sean claros y concisos.
Al inicio del software se tiene una pantalla de inicio de sesión, esto se hizo con el fin de
que se pudiera guardar la privacidad de los datos manejados en todo el software y
delimitar quienes pueden visualizar ciertos tipos de datos dependiendo de su usuario.
Figura 59 Pagina de acceso al software
Una vez que se haya podido ingresar correctamente al software aparecerá una pantalla en
blanco, pero con un menú en la parte superior que redirigirá a la pantalla que se seleccione
61
Figura 60 Pagina inicial del software
Captura TV
Esta pantalla afectará directamente a la tabla con el nombre de “CapturaTV” y servirá
para poder administrar los datos almacenados, así como los reportes que se realizan
en cada una de las áreas solicitadas. A continuación, se mostrarán las imágenes que
demuestran cómo está diseñada la pantalla.
Figura 61 Primer y segundo módulo de Captura TV
62
Figura 62 Tercer y cuarto módulo de Captura TV
Factor Extracción
En esta pantalla se ve afectada la tabla de Factor en la base de datos. Como se puede
apreciar en las siguientes imágenes así quedó el diseño final.
Figura 63 Pantalla de Factor Extracción
Glosario
En esta pantalla se ve afectada la tabla de TAG en la base de datos. A continuación,
se presentan en las imágenes como quedó el diseño final.
63
Figura 64 Pantalla de Glosario
Presupuesto
En esta pantalla se ve afectada la tabla de Presupuesto en la base de datos. A
continuación, se presentan en las imágenes como quedó el diseño final.
Figura 65 Pantalla de Presupuesto
Configuración Pantalla
En esta pantalla se ve afectada la tabla de ConfiguracionPantalla en la base de datos.
A continuación, se presentan en las imágenes como quedó el diseño final.
64
Figura 66 Pantalla de Configuración Pantalla
Configuración departamentos
En esta pantalla se ve afectada la tabla de TagDepartamentos y TAG en la base de
datos. A continuación, se presentan en las imágenes como quedó el diseño final.
Figura 67 Pantalla de Configuración departamentos
Catálogo Demoras
En esta pantalla se ve afectada la tabla de CatalogoDemoras en la base de datos. A
continuación, se presentan en las imágenes como quedó el diseño final.
65
Figura 68 Primer Módulo con sus dos partes de Catálogo Demoras
Figura 69 Segundo y Tercer módulo de Catálogo Demoras
TMC
En este software solo se crearon las pantallas sin funcionamiento con el propósito de que
se pudieran autorizar su creación en la empresa de peña colorada. Posee la misma
pantalla de inicio de sesión.
66
Figura 70 Pagina de Acceso al software
Figura 71 Página principal del software
67
Energía
Figura 72 Indicadores Iniciales de Energía
Figura 73 Captura de consumos parte 1
Figura 74 Captura de consumos parte 2
68
Figura 75 Resumen Mensual
Figura 76 Parámetros del mes
69
Agua
Figura 77 Indicadores iniciales de Agua
Figura 78 Captura de Consumos
70
Figura 79 Resumen Mensual
Figura 80 Parámetros
71
7. Conclusiones y recomendaciones
Gracias a la creación del proyecto de TMC Configuración se pudieron modificar muchos
datos que se encontraban erróneos, además de que permitió disminuir el tiempo de captura
de varios indicadores permitiéndoles subir archivos en formato CSV, dándoles una
visualización del archivo que se subirá validando que los datos introducidos sean correctos
disminuyendo el error que se generaba cuando se utilizaba solo el programa Excel para
capturar los valores.
El software se realizó de una manera que pudiera ser muy comprensible para que el personal
que no tiene mucha experiencia con el manejo de nuevas tecnologías pudiera usarlo y no
tuvieran problemas al momento de comprender su funcionamiento. Esta herramienta fue muy
útil en la empresa de Peña Colorada, tanto así, que dio apertura a la creación de nuevos
proyectos, así como la continuación del software TMC.
La empresa se dio cuenta gracias a este software de que necesitaba automatizar más áreas.
Esto con el fin de optimizar tiempos y poder tomar decisiones basándose en diagramas y
esquemas. Esto les permite realizar una revisión más exacta de los indicadores de cada área
y así poder tomar decisiones basándose en los reportes que muestra el software que se les
desarrolló. Además de que les permitió poder modificar valores que no coinciden con lo que
se tiene físicamente y los que fueron sacados mediante procesos almacenados internamente
en la base de datos.
El proyecto de TMC seguirá creciendo beneficiando la privacidad de los datos y dará la
seguridad de que no se perderán. Se explicó que solo se crearon las pantallas de TMC sin
funcionamiento, pero gracias a su gran éxito se permitió a la empresa de Fénix IETI tener
acceso a un área más restringida de datos en la empresa para lograr el desarrollo óptimo de
esta herramienta.
TMC Configuración fue puesto ya en funcionamiento en la empresa, cerrando el primer ciclo
del proyecto. Se les dio capacitación a los encargados que tendrían acceso al software y se
modificaron incidencias que salieron en el transcurso del funcionamiento del software
dejándolo completamente funcional y aplicable en varias áreas de la empresa de Peña
Colorada.
72
8. Competencias desarrolladas y/o aplicadas
Iniciativa
Análisis y resolución de problemas
Creatividad, emprendimiento y compromiso
Trabajo en equipo
Manejo y desarrollo de software
Utilización y retroalimentación de conocimientos previos
Aprendizaje autodidacta
Búsqueda de información
Obtención y organización de información
Organización de tiempos
Administración de personal
Creación y mantenimiento de proyectos
73
9. Referencias bibliográficas
1. Esposito, D. (2014). Programming Microsoft ASP.NET MVC. Redmon,
Washington: Dianne Russell, Octal Publishing, Inc.
2. Munro, J. (2015). ASP.NET MVC 5 with Bootstrap and Knockout.Js. United
States of America: O'Reilly Media, Inc.
3. Patiño, E. R. (2015). Obtenido de Udemy: https://www.udemy.com/asp-net-mvc-
c-creando-un-portafolio-profesional
4. Microsoft. (2018). Información general sobre ASP.NET MVC. Obtenido de:
https://msdn.microsoft.com/es-es/library/dd381412(v=vs.108).aspx.
5. Microsoft. (2018). Información general sobre ASP.NET. Obtenido de:
https://msdn.microsoft.com/es-es/library/4w3ex9c2(v=vs.100).aspx
6. FileInfo. (2017). .CSV File Extension. Obtenido de:
https://fileinfo.com/extension/csv
7. Ortega, Eduardo. (2012). WebMethods. Obtenido de:
http://www.eduardoortega.me/webmethods/
8. Mudassar, Ahmed Khan. (2013). Calling ASP.Net WebMethod using jQuery
AJAX. Obtenido de: https://www.aspsnippets.com/Articles/Calling-ASPNet-
WebMethod-using-jQuery-AJAX.aspx
9. Microsoft. (2018). Controllers and Action Methods in ASP.NET MVC
Applications. Obtenido de: https://msdn.microsoft.com/en-
us/library/dd410269(v=vs.98).aspx
10. W3schools. (2018). HTTP Request Methods. Obtenido de:
https://www.w3schools.com/tags/ref_httpmethods.asp