Estructura de Datos y Algoritmos Trabajo Final

UNIVERSIDAD PERUANA DE CIENCIAS
APLICADAS
INGENIERÍA DE SISTEMAS - EPE
ESTRUCTURA DE DATOS
Y ALGORITMOS
PROFESOR:
LUCAS FAJARDO MONTES
CICLO: 2018-01-B
TEMA:
DESARROLLO DE UNA TICKETERA DIGITAL
TRABAJO FINAL
INTEGRANTE:
ÍNDICE
I. PRESENTACIÓN .......................................................................................................................... 3
II. OBJETIVOS DEL TRABAJO .................................................................................................... 3
III. DESCRIPCIÓN DE LA EMPRESA.......................................................................................... 4
3.1. RAZÓN SOCIAL ................................................................................................................... 4
3.2. ACTIVIDAD............................................................................................................................ 4
3.3. PRODUCTOS Y SERVICIOS ............................................................................................. 4
3.4. CANTIDAD DE TRABAJADORES ..................................................................................... 5
3.5. UBICACIÓN ........................................................................................................................... 6
4.6. ESTRUCTURA ORGANIZACIONAL ................................................................................. 6
IV. DESCRIPCIÓN DEL PROBLEMA .......................................................................................... 7
V. DESCRIPCIÓN DE LA SOLUCIÓN PLANTEADA ............................................................... 7
5.1. ANÁLISIS DEL PROBLEMA ............................................................................................... 7
5.1.2. PROPUESTA DE SOLUCIÓN 1 ..................................................................................... 7
5.1.3. PROPUESTA DE SOLUCIÓN 2 ..................................................................................... 8
5.1.4. CONCLUSIONES SOBRE LAS DOS PROPUESTAS ................................................ 9
5.2. DESCRIPCIÓN DE LA SOLUCIÓN A IMPLEMENTAR ................................................. 9
5.2.1. ALCANCE ........................................................................................................................... 9
5.2.2. REQUISITOS FUNCIONALES...................................................................................... 10
5.2.3. ESTRUCTURA DE DATOS ........................................................................................... 12
VI. CÓDIGO FUENTE DE LA SOLUCIÓN ................................................................................ 14
6.1. PROGRAMA “SERVICIO DE TICKETERA DIGITAL” .................................................. 14
6.2. PROGRAMA “TEST DEL SERVICIO” ............................................................................. 24
VII. PANTALLAS PRINCIPALES DE LA SOLUCIÓN ............................................................ 28
7.1. PROGRAMA “SERVICIO DE TICKETERA DIGITAL” .................................................. 28
7.2. PROGRAMA “TEST DEL SERVICIO” ............................................................................. 29
VIII. CONCLUSIONES Y RECOMENDACIONES .................................................................... 33
8.1. CONCLUSIONES ............................................................................................................... 33
8.2. RECOMENDACIONES ...................................................................................................... 33
IX. REFERENCIAS Y BIBLIOGRAFÍA....................................................................................... 35
2
I. PRESENTACIÓN
El trabajo está basado en la necesidad de cubrir funcionalidades que aporten innovación al

proceso actual de la Banca, a través del uso de herramientas o sistemas digitales que
faciliten su utilización y llegada a los clientes generando una experiencia diferenciadora en
el mercado.
Para el desarrollo del presente trabajo se basarán en los objetivos planteados por el curso.
II. OBJETIVOS DEL TRABAJO
 Aplicar los conceptos y técnicas asimilados en el curso y/o resultado de la investigación,

para el desarrollo de aplicaciones.
 Mejorar su habilidad de trabajar en equipo, preparándolo así para formar parte de
entornos laborales diversos.
 Trabajar en base a objetivos y plazos, desarrollando su capacidad para trabajar bajo
presión.
 Preparar presentaciones e informes, incrementando su capacidad de comunicación
orientada al público en general, al igual que exposiciones frente a público especializado.
 Someter a prueba su capacidad de elaboración de entregables y/o informes escritos de
nivel profesional, que sirvan de marco adecuado para trabajos y productos de alta
calidad.
 Preparar informes o resúmenes ejecutivos, desarrollando su capacidad de síntesis y
comunicación con la alta Dirección o Gerencia.
3
III. DESCRIPCIÓN DE LA EMPRESA
3.1. RAZÓN SOCIAL

La razón social de la empresa es BANCO DE CREDITO DEL PERU con número de RUC
20100047218.
3.2. ACTIVIDAD
La actividad que desarrolla la empresa es Financiera.
3.3. PRODUCTOS Y SERVICIOS

Los productos y servicios que brinda son:
Créditos
 Efectivo (Efectivo BCP, Efectivo con Garantía Liquida, Efectivo con Garantía
Hipotecaria, Efectivo con Garantía Hipotecaria Compartido).
 Hipotecario (Hipotecario BCP, Mi Vivienda BCP, Emprendedor BCP, Compartido,
Compra de Deuda).
 Vehiculares (Vehicular, Vehicular Compartido, Compra Inteligente).
 Otros Créditos (Estudios, Compra de Deuda, Adelanta tu Sueldo).
Seguros
 Financieros (Protección de Tarjetas, Seguro de Protección Financiera).

 Vida (Vida Retorno, Vida Lifestyle, Seguro Múltiple).
 Accidentes (Familia Segura, Renta Segura, Transito, Accidentes Retorno).
 Salud (Vida Tranquila, Auxilio Médico, Oncológico).
 Complementarios (Seguro vehicular para autos financiados, Seguro Vehicular,
Seguro Hipotecario, SOAT).
Tarjetas
 VISA Latam Pass (Visa Clásica, Visa Oro, Visa Platinum, Visa Signature).
4
 AMEX Latam Pass (American Express Clásica, American Express Oro, American
Express Platinum)
 Millas Travel (Visa Oro, Visa Platinum)
 Otras (Visa Light, Visa Clásica)
 Débito (Visa Clásica BCP, Visa Oro BCP, Visa Clásica BCP con diseño, Visa
Clásica BCP Latam Pass).
Cuentas
 Cuentas de Ahorro (Cuenta Activa, Cuenta Premio, Primera Cuenta).

 Cuenta Corriente (Cuenta Corriente BCP).
 Cuenta Sueldo (Cuenta Sueldo BCP, Cuenta CTS BCP).
Inversiones
 Depósito a Plazos (Pago de Intereses al Vencimiento, Pago de Intereses

Mensuales, Certificado Bancario).
 Fondos Mutuos (Capital Conservadores Liquidez Soles, Capital Conservadores
Liquidez Dólares, Capital Equilibrado Dólares, Capital Crecimiento VCS).
 Mercado & Asesoría (Registro de Acciones, Ofertas Públicas, Mesa de
Distribución, Inversiones en Bolsa, Fideicomiso).
Otros
 Tipo de Cambio (Dólares, Otras Monedas).

 Envíos Nacionales (Giros Nacionales, Transferencias Interbancarias Diferidas,
Transferencias Interbancarias Inmediatas).
 Envíos Internacionales (Remesas Migratorias, Transferencias al Exterior,
Transferencias del Exterior).
3.4. CANTIDAD DE TRABAJADORES

Actualmente cuenta con aproximadamente 17,000 trabajadores a nivel nacional.
5
3.5. UBICACIÓN
La dirección fiscal de la empresa es Calle Centenario Nro. 156 Urb. Las Laderas de
Melgarejo Lima – Lima - La Molina sin embargo cuenta adicionalmente con las siguientes
sedes:
 Sede OP Lima
 Sede Chorrillos
 Sede San Isidro
4.6. ESTRUCTURA ORGANIZACIONAL

A continuación, se muestra la estructura organizacional de la empresa:
Necesidad de
Plataforma de
Administración de
Citas para Oficinas
6
IV. DESCRIPCIÓN DEL PROBLEMA
Dentro de las iniciativas de innovación se ha identificado la necesidad de contar con un

sistema que permita realizar la gestión de citas para Plataforma generadas por los clientes
a través de medios digitales. Actualmente no se cuenta con un sistema que permita realizar
la gestión y control del proceso de citas para plataforma en agencias. Este proceso es nuevo
y se están realizando pruebas sobre el funcionamiento en un laboratorio del BCP, sin
embargo, si esta iniciativa tiene éxito se realizará un despliegue paulatino hacia toda la red
de agencias.
Los registros de las solicitudes se realizarán a través de un nuevo sistema que permitirá
controlar las reservas en base a la agencia seleccionada, cantidad de servidores de
atención y clientes que pueden ser atendidos de acuerdo con el orden de llegada y
capacidad de atención de cada agencia.
V. DESCRIPCIÓN DE LA SOLUCIÓN PLANTEADA
5.1. ANÁLISIS DEL PROBLEMA
5.1.2. PROPUESTA DE SOLUCIÓN 1
Implementar un servicio con la funcionalidad del registro de citas para plataformas

de manera centralizada y que podrá ser consumido por diversas aplicaciones
digitales (Portal del cliente Homebanking, Banca Móvil, etc.).
La solución contará con diversos servicios tanto para el registro y gestión de las
citas, por ejemplo, expondrá funcionalidad de registro de citas, cancelación de citas,
listado de agencias que cuentan con este servicio, listado de citas creadas, reporte
de estado de atención de citas en plataforma por agencia.
No se requiere instalación local ya que el servicio estará publicado en un Web

Service en la red interna de la empresa. Las aplicaciones solicitantes utilizaran los
servicios de reserva y consulta y a nivel de agencia se utilizará la misma aplicación
7
que muestra el turno asignado de acuerdo con el orden de llegada. La cita se
considerará como una llegada adicional sin necesidad de que el cliente pase su
tarjeta.
Ventajas:
 Centralizado, conectado.
 Lógica de negocio encapsulada, menor esfuerzo de implementación por los
canales dígales.
 No requiere de instalaciones de software local.
Desventajas:
 En caso de problemas de red, la agencia no podría utilizar este servicio de

manera desconectada.
5.1.3. PROPUESTA DE SOLUCIÓN 2
Implementar la funcionalidad requerida en cada aplicación digital que se requiera, la

cual gestionará el registro y control de las citas en cada agencia. El aplicativo será
de instalación local y deberá ser administrado por un usuario de la agencia.
Las aplicaciones digitales dejaran un archivo plano que se cargará con la

información de las citas la cual será gestionado por la aplicación actual de gestión
de colas de la agencia para plataforma.
Ventajas:
 Desconectado.
Desventajas:
 Información no actualizada en línea.

 Requiere implementación de lógica de negocio en cada aplicación digital que
quiera brindar el servicio.
 Requiere distribución de actualizaciones y contar con una base de datos
local en caso de contingencia.
8
5.1.4. CONCLUSIONES SOBRE LAS DOS PROPUESTAS
Al analizar las dos propuestas se puede apreciar ventajas de actualización y

escalabilidad de la solución # 1. La solución # 2 pese a cubrir la necesidad del
usuario no es la más optima ya que implica modificaciones en diversas aplicaciones
no solo para la implementación sino también para cualquier cambio en la lógica de
negocio.
Por lo tanto, se concluye que la solución # 1 es la más recomendable debido a que

ser un servicio centralizado y escalable el cual permite una rápida implementación
al exponer servicios virtualizados que pueden ser consumidos por diversas
aplicaciones.
5.2. DESCRIPCIÓN DE LA SOLUCIÓN A IMPLEMENTAR
5.2.1. ALCANCE
Se implementará un Web Service el cual proveerá de una serie de funciones que

permitirán la gestión de ticket de atención para plataforma que se denominaran citas.
Las citas serán creadas por los clientes a través de las diversas aplicaciones
digitales que expongan esta funcionalidad. Las aplicaciones deberán consumir las
funciones desarrollados por este requerimiento, no forma parte del alcance realizar
las modificaciones en las aplicaciones consumidoras y tampoco en la ticketera física.
El desarrollo contempla la implementación del Servicio, sus funciones de creación,

visualización, cancelación, reportes relacionados a la gestión de citas electrónicas
en agencia para plataforma.
9
A continuación, se muestra un diagrama general de la solución:
AGENCIA 1
Ticketera
Virtual
Banca Movil
Servidor Local
Ticketera
Física Homebanking
Grafico 1: Diagrama general de la solución
5.2.2. REQUISITOS FUNCIONALES
A continuación, se describen los requisitos funcionales para la implementación del

Servicio de Citas que será desarrollado en el lenguaje de programación Ruby:
5.4.2.1. Requisito Funcional 1: Parametrización del servicio
Las reservas se darán en intervalos de T tiempo (por ejemplo, cada 15

minutos), este valor será paramétrico de acuerdo con la capacidad de la
agencia.
Agregar una función que permita agregar Clientes, Agencias, Motivos de Cita
y Calificación de Cita.
Agregar una función que permita definir la cantidad de servidores que
atenderán las Citas.
Agregar una función que permita definir el tiempo que un cliente está
esperando en la cola.
10
5.4.2.2. Requisito Funcional 2: Disponibilidad del Servicio
Las reservas solo estarán disponibles para usuarios registrados como

clientes. Una vez creada la cita el servicio deberá un mensaje de
confirmación indicando el número de ticket asignado.
Las agencias que están registradas en el servicio son las que el cliente podrá
realizar una reserva de una cita. En caso la agencia no esté registrada el
servicio mostrará un mensaje que la agencia no está disponible este servicio.
Dicho mensaje será enviado a la aplicación digital que haya invocado el
servicio de gestión de citas.
5.4.2.3. Requisito Funcional 3: Obtener listado de Agencias
El servicio contará con una función que permitirá obtener la lista de agencias
disponibles para que pueda ser mostrada por el canal.
5.4.2.4. Requisito Funcional 4: Obtener listado de Motivos
El servicio contará con una función que permitirá obtener la lista de Motivos
de Cita disponibles para que pueda ser mostrada por el canal.
5.4.2.5. Requisito Funcional 5: Obtener listado de Calificación
El servicio contará con una función que permitirá obtener la lista de

Calificaciones disponibles para la cita para que pueda ser mostrada por el
canal.
5.4.2.6. Requisito Funcional 6: Generación de Cita
Un cliente puede reservar la cita a través de diversos canales digitales, estos

deberán genera una petición de registro al servicio centralizado.
11
El cliente solo podrá realizar reservas para el día en curso, no se permitirá
reservas para días futuros. Esta condición será paramétrica y se podrá
modificar sin necesidad de cambiar el programa.
5.4.2.7. Requisito Funcional 7: Cancelación de Cita
El cliente puede realizar la cancelación de un ticket ya generado. Para lo cual

el servicio implementará una función de cancelación donde se deberá indicar
el cliente y el número de ticket asignado.
5.4.2.8. Requisito Funcional 8: Listado de Citas
El servicio centralizado es consultado por un aplicativo que se encuentra en

la agencia y deberá proporcionar la siguiente información:
 Código de cita
 Agencia
 Ticket de atención
 DNI del cliente
 Fecha cita
 Hora cita
 Descripción del servicio
 Calificación del servicio
 Estado de la cita
5.2.3. ESTRUCTURA DE DATOS
Para la implementación del servicio se utilizarán listas enlazadas las cuales cargarán
la información de los datos maestros como clientes, agencias, motivo y evaluación.
De igual manera la cita generada será almacenada en listas enlazadas ya que la
cantidad de elementos ira variando de acuerdo con la cantidad de solicitudes
generadas.
12
A continuación, se describen las principales entidades que formaran el modelo de
datos para la solución:
13
VI. CÓDIGO FUENTE DE LA SOLUCIÓN
Para la solución planteada se han elaborado 2 programas Ruby. Uno de ellos funciona
como servicio que provee las funciones de generación de los tickets y el otro programa
permite crear nuevos tickets a través de una interfase de ingreso de datos.
A continuación, mencionaremos las funciones y código fuente implementadas en la

solución.
6.1. PROGRAMA “SERVICIO DE TICKETERA DIGITAL”
Para realizar las pruebas del servicio se implementa un programa que permitirá la
generación de creación de citas.
AppServicio-v2.rb
Librerías utilizadas:
 require 'nokogiri'
 require 'securerandom'
 require 'fileutils'
Función Breve Descripción

parametrizar_Servicio() Implementa la carga de parámetros del servicio.
cargar_Clientes() Implementa la carga de clientes a través de un archivo
CLIENTE.TXT que es enviado desde la aplicación
Legacy.
cargar_Agencias() Implementa la carga de agencias a través de un archivo
AGENCIA.TXT que es enviado desde la aplicación
Legacy.
cargar_Motivos() Implementa la carga de motivos a través de un archivo
MOTIVO.TXT que es enviado desde la aplicación
Legacy.
14
cargar_Calificaciones() Implementa la carga de calificaciones a través de un
archivo CALIFICA.TXT que es enviado desde la
aplicación Legacy.
validar_Cliente() Implementa la validación si un código de cliente esta
creado en el servicio.
validar_Agencia() Implementa la validación si un código de agencia esta
validar_Motivo() Implementa la validación si un código de motivo esta
validar_Cita() Implementa la validación si un código de cita esta creado
en el servicio.
validar_exiteXML() Implementa la validación un mensaje XML ya ha sido
procesado anteriormente.
crear_Solicitud() Implementa la funcionalidad de creación de tickets.
cancelar_Solicitud() Implementa la funcionalidad de cancelación de tickets.
crear_TicketAgencia() Implementa la funcionalidad de generación en envío de
información de los tickets generados en la ticketera
virtual hacia una agencia a través de un archivo TXT.
calificar_Cita() Implementa la funcionalidad de calificación de citas.
listar_Solicitudes() Implementa la funcionalidad de listado de citas por
diversos criterios de selección.
armar_LineaReporte() Implementa la funcionalidad de concatenar la información
para ser mostrada en el reporte.
completar_Campo() Implementa la funcionalidad de completar con espacios
en blancos los campos para que se muestren
correctamente en el reporte.
escribir_Archivo() Implementa la funcionalidad de escribir una cadena de
texto en un archivo TXT.
leer_mensajesXML() Implementa la funcionalidad de leer los mensajes XML
que han sido enviados al servicio para la creación de
nuevas citas a través de los canales digitales.
15
iniciar_Servicio() Implementa la función principal del programa y que
inicializa los valores, así como gestiona las solicitudes de
nuevas citas.
A continuación, se indica el código fuente implementado:

###############################################################################
# PROGRAMA EPE
# CURSO : ESTRUCTURA DE DATOS Y LGORITMOS
# PROFESOR : LUCAS FAJARDO
# CICLO : 2018-I
# ALUMNO : MOISES DANIEL CHANG ARMAS
# CODIGO : U201514128
# SISTEMA : GESTION DE CITAS – SERVICIO
###############################################################################
#encoding: utf-8
require 'nokogiri'
require 'securerandom'
require 'fileutils'
@clientes = []
@agencias = []
@motivos = []
@calificaciones = []
@solicitudes = []
@tiempo_atencion
@ultimaCita=0
@ultimoTicket=0
def parametrizar_Servicio(tiempo)
print "Cargando parametros del servicio"
File.open('parametros.txt','r') do |fichero1|
while linea = fichero1.gets
#puts "linea: #{linea}"
end
end
@tiempo_atencion = tiempo
puts ".........OK!"
end
def cargar_Clientes()
print "Cargando información de clientes"
@clientes.insert(@clientes.size,["C001","Daniel"])
@clientes.insert(@clientes.size,["C002","Juan"])
@clientes.insert(@clientes.size,["C003","Alberto"])
@clientes.insert(@clientes.size,["C004","Claudio"])
@clientes.insert(@clientes.size,["C005","Jose"])
16
@clientes.insert(@clientes.size,["C006","Antonio"])
puts ".........OK!"
end
def cargar_Agencias()
print "Cargando información de agencias"
@agencias.insert(@agencias.size,["AG-1","Agencia Chorrillos",1])
@agencias.insert(@agencias.size,["AG-2","Agencia Miraflores",1])
@agencias.insert(@agencias.size,["AG-3","Agencia La Molina",2])
puts ".........OK!"
end
def cargar_Motivos()
print "Cargando información de motivos"
@motivos.insert(@motivos.size,["MT-1","Producto Nuevo"])
@motivos.insert(@motivos.size,["MT-2","Solicitud de Prestamo"])
@motivos.insert(@motivos.size,["MT-3","Reclamo"])
@motivos.insert(@motivos.size,["MT-4","Consulta"])
@motivos.insert(@motivos.size,["MT-5","Otros"])
puts "..........OK!"
end
def cargar_Calificaciones()
print "Cargando información de calificaciones"
@calificaciones.insert(@calificaciones.size,["EV-0","Sin Calificar"])
@calificaciones.insert(@calificaciones.size,["EV-1","Excelente"])
@calificaciones.insert(@calificaciones.size,["EV-2","Muy buena"])
@calificaciones.insert(@calificaciones.size,["EV-3","Buena"])
@calificaciones.insert(@calificaciones.size,["EV-4","Regular"])
@calificaciones.insert(@calificaciones.size,["EV-5","Mala"])
puts "...OK!"
end
def validar_Cliente(cliente)
encontrado = false
if @clientes.size > -1
for i in 0..@clientes.size-1
if @clientes[i][0] == cliente
encontrado = true
end
end
end
return encontrado
end
def validar_Agencia(agencia)
encontrado = false
if @agencias.size > -1
for i in 0..@agencias.size-1
if @agencias[i][0] == agencia
encontrado = true
end
end
end
return encontrado
end
17
def validar_Motivo(motivo)
encontrado = false
if @motivos.size > -1
for i in 0..@motivos.size-1
if @motivos[i][0] == motivo
encontrado = true
end
end
end
return encontrado
end
def validar_Cita(cliente, agencia, fechaCita, horaCita)

if @solicitudes.size > -1
for i in 0..@solicitudes.size-1
if @solicitudes[i][1] == cliente and @solicitudes[i][8] == fechaCita and
@solicitudes[i][9] == horaCita and @solicitudes[i][2] == agencia
return false
end
end
end
return true
end
def validar_exiteXML(mensaje)
encontrado = false
if @solicitudes[i][12] == mensaje
encontrado = true
end
end
end
return encontrado
end
def crear_Solicitud(cliente, agencia, motivo, canal, fechaCita, horaCita, mensajeXML="")

cita = ""
if validar_Cliente(cliente) and validar_Agencia(agencia) and validar_Motivo(motivo) and

validar_Cita(cliente, agencia, fechaCita, horaCita)
estado = "PENDIENTE"
else
estado = "RECHAZADA"
end
@ultimaCita = @ultimaCita + 1
cita = "CT-#{@ultimaCita}"
@solicitudes.insert(@solicitudes.size,[cita,cliente,agencia,Time.now.strftime("%Y-%m-
%d"),Time.now.strftime("%R"),motivo,canal,"TK-S/N ",fechaCita,horaCita,estado, "EV-0",
mensajeXML])
if estado == "PENDIENTE"
return "-> Cita #{cita} creada con éxito ... OK!"
else
18
return "-> No se pudo crear la cita........ NOK!"
end
end
def cancelar_Solicitud(cliente, ticket)

if @solicitudes[i][0] == ticket and @solicitudes[i][10] != "CANCELADA" and
@solicitudes[i][10] != "CERRADA" and @solicitudes[i][10] != "RECHAZADA"
@solicitudes[i][10] = "CANCELADA"
return "-> Cita CANCELADA #{ticket}........... OK!"
end
end
end
return "-> Cita #{ticket} no existe......... NOK!"
end
def crear_TicketAgencia(agencia)
contador = 0
fechaCreacion = Time.now.strftime("%Y-%m-%d")
horaCreacion = Time.now.strftime("%T")
cadena = ""
cadena = cadena + "-----------------------------------------------------------------------------------
----------------------------------------------------------------"+"\n"
cadena = cadena + "Fecha: #{fechaCreacion} Hora #{horaCreacion}"+"\n"
cadena = cadena + "-----------------------------------------------------------------------------------
----------------------------------------------------------------"+"\n\n"
cadena = cadena + "CITA CLIENTE AGENCIA FECHA REG. HORAREG
MOTIVO CANAL TICKET FECHA CITA HORA CITA CALIFICA ESTADO MENSAJE
"+"\n"
cadena = cadena + "------ ------- ------- ---------- ------- ------ ----- ---------- ---------- --------
- -------- ---------- ----------------------------------------"+"\n"
if @solicitudes[i][2] == agencia and @solicitudes[i][10] != "CANCELADA"
and @solicitudes[i][10] != "GENERADA" and @solicitudes[i][10] != "CERRADA" and
@solicitudes[i][10] != "RECHAZADA"
@ultimoTicket = @ultimoTicket + 1
@solicitudes[i][7] = "TK-"+agencia+"-0"+@ultimoTicket.to_s
@solicitudes[i][10] = "GENERADA"
cadena = cadena + armar_LineaReporte(i)+"\n"
contador = contador + 1
end
end
cadena = cadena + "\n"
#Generando el mensaje para la creación de ticket en ticketera fisica
if contador > 0
horaCreacion = Time.now.strftime("%R")
nombreArchivo = fechaCreacion+"_"+agencia+"_CITAS"+".TXT"
puts escribir_Archivo(nombreArchivo, cadena)
return "-> Citas generadas Agencia #{agencia}.. OK!"
end
end
return "-> No hay citas para generar........... OK!"
19
end
def calificar_Cita(cita, califica)

if @solicitudes[i][0] == cita
if @solicitudes[i][0] == cita and @solicitudes[i][10] !=
"CANCELADA" and @solicitudes[i][10] != "PENDIENTE" and @solicitudes[i][10] != "CERRADA"
and @solicitudes[i][10] != "RECHAZADA"
@solicitudes[i][11] = califica
@solicitudes[i][10] = "CERRADA"
return "-> Cita #{cita} calificada.......... OK!"
end
end
end
end
return "-> No se puede calificar #{cita}... NOK!"
end
def listar_Solicitudes(cliente="", agencia="", fecha="", canal="",

estado="",archivo=false,nombreArchivo="")
cadena = ""
horaCreacion = Time.now.strftime("%T")
cadena = ""
cadena = cadena + "-----------------------------------------------------------------------------------
----------------------------------------------------------------"+"\n"
cadena = cadena + "Fecha: #{fechaCreacion} Hora #{horaCreacion}"+"\n"
cadena = cadena + "-----------------------------------------------------------------------------------
----------------------------------------------------------------"+"\n\n"
cadena = cadena + "CITA CLIENTE AGENCIA FECHA REG. HORAREG
MOTIVO CANAL TICKET FECHA CITA HORA CITA CALIFICA ESTADO MENSAJE
"+"\n"
cadena = cadena + "------ ------- ------- ---------- ------- ------ ----- ---------- ---------- --------
- -------- ---------- ----------------------------------------"+"\n"
if cliente == "" and agencia == "" and fecha == "" and canal == "" and
estado == ""
elsif estado == ""
if cliente == @solicitudes[i][1] and agencia == @solicitudes[i][2] and
fecha == @solicitudes[i][8] and canal == @solicitudes[i][6]
elsif cliente == @solicitudes[i][1] and fecha == @solicitudes[i][8]
elsif cliente == @solicitudes[i][1]
elsif agencia == @solicitudes[i][2]
elsif agencia == @solicitudes[i][2] and fecha == @solicitudes[i][8]
elsif fecha == @solicitudes[i][8]
elsif canal == @solicitudes[i][6]
20
elsif canal == @solicitudes[i][6] and cliente == @solicitudes[i][1]
and fecha == @solicitudes[i][8]
and fecha == @solicitudes[i][8] and agencia == @solicitudes[i][2]
else
#puts "Aqui"
end
else
if estado == @solicitudes[i][10]
end
end
end
cadena = cadena+"\n"
#puts cadena
if archivo == true
if nombreArchivo == ""
nombreArchivo = fechaCreacion+"_OPER_CITAS.TXT"
end
puts escribir_Archivo(nombreArchivo, cadena)
end
else
return "-> No existen Citas creadas...... OK!"
end
return "-> Listado de citas.............. OK!"
end
def armar_LineaReporte(indice)
cadena = ""
cadena = cadena + completar_Campo(@solicitudes[indice][0],6) + " "
cadena = cadena + completar_Campo(@solicitudes[indice][10],10)+ " "
cadena = cadena + @solicitudes[indice][12]
return cadena
end
def completar_Campo(cadena, largo)

if largo > cadena.length
cadena = cadena + " "*(largo-cadena.length)
else
cadena = cadena
21
end
return cadena
end
def escribir_Archivo(archivo, cadena)

File.open(archivo,"a") do |fichero1|
fichero1.puts cadena
end
return "-> Archivo: #{archivo} "+"\n"+"-> (A) generado con éxito........ OK!"
end
def leer_Archivo(archivo)
#contador = 0
#cliente = agencia = motivo = canal = fechaCita = horaCita = ""
#File.open(archivo,"r") do |fichero2|
# while linea = fichero2.gets
# contador = contador + 1
# linea = linea.chomp()
# #puts "#{linea}"
# if contador == 2
# cliente = linea
# elsif contador == 3
# agencia = linea
# motivo = linea
# canal = linea
# elsif contador ==6
# fechaCita = linea
# horaCita = linea
# end
# end
#end
#puts crear_Solicitud(cliente,agencia,motivo,canal,fechaCita,horaCita)
#return "-> #{archivo} procesado con éxito... OK!"
end
def leer_mensajesXML()
contador = 0
nombreArchivo = ""
buscado = ".xml"
mensaje = ""
Dir.glob('*').each do |archivo|
nombreArchivo = archivo.chomp
resp = /#{buscado}/.match(nombreArchivo)
if resp != nil and nombreArchivo.size >= 40 and validar_exiteXML(nombreArchivo) == false
puts nombreArchivo+"\n"
#puts leer_Archivo(nombreArchivo)
name_xml_file = nombreArchivo
f = File.open(name_xml_file)
xml = Nokogiri::XML(f)
body = xml.xpath("//s0:Cita")
cliente = body.xpath("//s0:cliente").text
22
agencia = body.xpath("//s0:agencia").text
motivo = body.xpath("//s0:motivo").text
canal = body.xpath("//s0:canal").text
fechaCita = body.xpath("//s0:fecha").text
horaCita = body.xpath("//s0:hora").text
mensaje = nombreArchivo
puts
crear_Solicitud(cliente,agencia,motivo,canal,fechaCita,horaCita,mensaje)
mensaje = mensaje + "-> #{archivo} procesado con éxito... OK!"+"\n"
#Movemos el archivo XML procesado

#FileUtils.mv(name_xml_file,"/Procesados")
#File.delete(name_xml_file)
contador = contador + 1
end
end
if contador > 0
puts = "-> Se procesaron todos los mensajes XML"
end
end
def iniciar_Servicio(tiempo)
system("cls")
puts "INICIANDO SERVICIO DE TICKETERA DIGITAL"+"\n"

parametrizar_Servicio(15)
cargar_Clientes()
cargar_Agencias()
cargar_Motivos()
cargar_Calificaciones()
puts "-> Servicio inicializado con éxito!"+"\n\n"
puts "VALORES CARGADOS EN EL SERVICIO..."

puts "-> Clientes:"+@clientes.to_s
puts "-> Agencias:"+@agencias.to_s
puts "-> Motivos: "+@motivos.to_s
puts "-> Calificaciones: "+@calificaciones.to_s
puts "-> Solicitudes:"+@solicitudes.to_s
puts ""
tiempoInicial = Time.now()
tiempoFinal = Time.now() + tiempo
while tiempoFinal >= tiempoInicial

#print tiempoInicial.to_s+ "\n"
leer_mensajesXML()
crear_TicketAgencia("AG-1")
tiempoInicial = Time.now()
sleep 0.001
end
puts listar_Solicitudes("","","","","",true)
23
puts "FILTRANDO CITAS POR CRITERIOS DE SELECCION..."
puts listar_Solicitudes("C001","","","","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","AG-1","","","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","2018-07-12","","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","2018-07-11","","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","","NHBK","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","","KIOS","",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","","","CANCELADA",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","","NHBK","PENDIENTE",true,"LISTADO_CITAS-01.TXT")
puts listar_Solicitudes("","","","","",true,"LISTADO_CITAS-01.TXT")
return "FINALIZO SERVICIO DE TICKETERA DIGITAL"+"\n"

end
#INICIANDO SERVICIO
#Inicializamos el servicio en 5 minutos
puts iniciar_Servicio(60*5)
###############################################################################
6.2. PROGRAMA “TEST DEL SERVICIO”
Para realizar las pruebas del servicio se implementa un programa que permitirá la
generación de creación de citas.
Programa: AppTest-v2.rb
Librerías utilizadas:
 require 'securerandom'
Función Breve Descripción

escribir_XML() Implementa la funcionalidad de escribir el contenido de
una cadena de texto en un archivo XML.
armar_mensajeXML() Implementa la funcionalidad de poder crear una cadena
con el contenido del mensaje XML que será escrito en un
archivo y que recibe como entrada los valores ingresados
por el usuario.
24
Main() Implementa la función principal del programa donde se
presentan las opciones de crear una nueva cita y salir del
programa.
A continuación, se indica el código fuente implementado:

###############################################################################
# PROGRAMA EPE
# CURSO : ESTRUCTURA DE DATOS Y LGORITMOS
# PROFESOR : LUCAS FAJARDO
# CICLO : 2018-I
# ALUMNO : MOISES DANIEL CHANG ARMAS
# CODIGO : U201514128
# SISTEMA : GESTION DE CITAS – PROGRAMA TEST
###############################################################################
require 'securerandom'
def escribir_XML(cadena)
archivo = SecureRandom.hex(16)
archivo = archivo.upcase
archivo = archivo + ".xml"
archivo = archivo[0..7]+"-"+archivo[8..11]+"-"+archivo[12..15]+"-"+archivo[16..19]+"-
"+archivo[20..37]
File.open(archivo,"a") do |fichero1|
fichero1.puts cadena
end
return "-> Archivo: #{archivo} "+"\n"+"-> (A) generado con éxito........ OK!"
end
def armar_mensajeXML(cliente, agencia, motivo, canal, fecha, hora)

cadena = ""
cadena = cadena + "<?xml version='1.0' encoding='UTF-8'?>"+"\n"
cadena = cadena + "<senv:Envelope"+"\n"
cadena = cadena + " xmlns:tns='http://otra_url.com/utilities'"+"\n"
cadena = cadena + "
xmlns:senv='http://schemas.xmlsoap.org/soap/envelope/'"+"\n"
cadena = cadena + " xmlns:s0='apps.services.soap.core.views'>"+"\n"
cadena = cadena + " <senv:Body>"+"\n"
cadena = cadena + " <tns:CitaRequest>"+"\n"
cadena = cadena + " <s0:Cita>"+"\n"
cadena = cadena + "
<s0:cliente>#{cliente}</s0:cliente>"+"\n"
cadena = cadena + "
<s0:agencia>#{agencia}</s0:agencia>"+"\n"
cadena = cadena + "
<s0:motivo>#{motivo}</s0:motivo>"+"\n"
cadena = cadena + "
<s0:canal>#{canal}</s0:canal>"+"\n"
cadena = cadena + "
<s0:fecha>#{fecha}</s0:fecha>"+"\n"
cadena = cadena + " <s0:hora>#{hora}</s0:hora>"+"\n"
cadena = cadena + " </s0:Cita>"+"\n"
cadena = cadena + " </tns:CitaRequest>"+"\n"
25
cadena = cadena + " </senv:Body>"+"\n"
cadena = cadena + "</senv:Envelope>"+"\n"
return cadena
end
def main()
@respuesta = "Y"
while @respuesta == "Y"
system("cls")
puts ""
puts "PROGRAMA DE PRUEBAS DEL SERVICIO DE TICKETERA DIGITAL"
puts "-----------------------------------------------------"
puts ""
puts "Indique que operación desea realizar"
puts ""
puts "-> 1. (N)ueva cita, presione la letra.................... 'N'"
puts "-> 2. (E)xit, presione la letra...........................'E'"
puts ""
puts "Seleccione una opción:"
@respuesta = gets.chomp().upcase
if @respuesta == "N"
system("cls")
puts "PROGRAMA DE PRUEBAS DEL SERVICIO DE TICKETERA
DIGITAL - CREAR CITA"
puts "------------------------------------------------------------------"
puts ""
puts "Ingrese un cliente: (C001, C002, C003, C004, C005, C006)"
cliente = gets.chomp().upcase
puts "Ingrese la agencia: (AG-1, AG2, AG3)"
agencia = gets.chomp().upcase
puts "Ingrese el motivo de visita: (MT-1, MT-2, MT-3, MT-4, MT-5)"
motivo = gets.chomp().upcase
puts "Ingrese un canal: (NHBK, KIOS, BMOV)"
canal = gets.chomp().upcase
puts "Ingrese la feha de Cita: (YYYY-MM-DD)"
fecha = gets.chomp()
puts "Ingrese la hora de la cita: (HH:MM)"
hora = gets.chomp()
puts "El cliente es #{cliente}"

puts "La agencia es #{agencia}"
puts "El motivo es #{motivo}"
puts "El canal es #{canal}"
puts "La fecha de la cita es #{fecha}"
puts "La hora de la cita es #{hora}"
if cliente != "" and agencia != "" and motivo != "" and canal != "" and fecha !=
"" and hora != ""
cadena = armar_mensajeXML(cliente, agencia, motivo, canal,
fecha, hora)
puts escribir_XML(cadena)
else
puts "No se han completado todos los datos. No se puede crear el
mensaje!"
26
end
puts ""
puts "Desea registrar otra operación (Y / N)"
@respuesta = gets.chomp().upcase
elsif @respuesta == "E"

@respuesta = "N"
else
@respuesta = "Y"
end
end
end
main()
###############################################################################
27
VII. PANTALLAS PRINCIPALES DE LA SOLUCIÓN
Para iniciar el programa test, se debe ingresar a la ruta del programa y ejecutar la
sentencia:
7.1. PROGRAMA “SERVICIO DE TICKETERA DIGITAL”
Para ejecutar el programa se debe indicar la siguiente sentencia:

“C:\[Directorio del programa]>ruby AppServicio-v2.rb”
Al ejecutar el programa se muestra la siguiente pantalla:
28
En la pantalla anterior se puede visualizar la inicialización del servicio, en la cual se realiza
la carga de información de los maestros: Clientes, Agencias, Motivos de Cita, Calificaciones
y se inicializa una cadena de arreglos vacía que será utilizada para la gestión de citas.
En la pantalla anterior podemos apreciar un log generado en la consola del CMD donde
indica los mensajes que han sido procesados y cuales han sido rechazados.
El servicio al momento de ser inicializado tiene definida una duración de ejecución de 5

minutos, luego de lo cual terminará su ejecución.
7.2. PROGRAMA “TEST DEL SERVICIO”
Para ejecutar el programa se debe indicar la siguiente sentencia:

“C:\[Directorio del programa]>ruby AppTest-v2.rb”
29
Al ejecutar el programa se muestra la siguiente pantalla:
Este programa permite la generación de nuevas citas a través de la creación de mensajes

XML los cuales son grabados en un archivo XML cuyo nombre es un código GUID el cual
no se repite. El mensaje es generado en la misma ruta donde se ejecuta el programa y de
donde es recibido por el servicio para ser procesado.
Al seleccionar la opción de nuevo ingreso, el sistema solicitará los datos necesarios para la
creación de la cita. Una vez ingresado los datos muestra un mensaje de confirmación de la
creación del mensaje.
30
A continuación, se muestra la estructura del archivo XML que permite la creación de una
cita por un canal digital.
31
Al terminar el flujo de creación de una cita, se genera un archivo XML que luego es
interpretado por el servicio.
32
VIII. CONCLUSIONES Y RECOMENDACIONES
8.1. CONCLUSIONES
A continuación, describimos las conclusiones del trabajo realizado:
 El desarrollo de este sistema nos ha permitido utilizar los conocimientos adquiridos

en el curso como la estructuración de algoritmos para el diseño de la solución y su
implementación a través del lenguaje de programación Ruby, el cual es muy versátil
y facilita el desarrollo de las informáticas.
 Al no utilizar bases de datos soluciones en esta solución nos ayuda a comprender

la factibilidad del manejo de información en memoria y su rapidez para el
procesamiento de la información.
 La implementación de capas de servicios que proveen funcionalidad de negocio que

pueden ser consumidas por diversas aplicaciones internas o externas a una
organización facilitan mucho el esquema de integración que hoy necesitan las
empresas para generar procesos innovadores que se constituyan en un factor
diferenciador en el mercado.
8.2. RECOMENDACIONES
A continuación, se describen las recomendaciones del trabajo realizado:
 Implementar la solución con Ruby Rails para poder generar un Web Service y
publicar el servicio en un servidor y desarrollar una web de pruebas que permita
fácilmente realizar pruebas de las funcionalidades.
 Agregar esquemas de seguridad para garantizar que los mensajes sean seguros y
evitar cualquier tipo de vulnerabilidades.
33
 Implementar la persistencia de los datos generados por las operaciones del servicio
en una base de datos.
 Implementar esquemas de ordenamiento y búsqueda a través de árboles que

optimicen los tiempos de búsqueda de información.
34
IX. REFERENCIAS Y BIBLIOGRAFÍA
https://www.viabcp.com/wps/portal/Home/personas/!ut/p/z1/04_Sj9CPykssy0xPLMnMz0v
MAfIjo8ziDQzMTDyNgw18_YOdTQwcg3x9DEMMTQwMDE30wwkpiAJLYweOBkD9UViU
OBo4BRk5GRsYuPsbYVWAYkZBboRBpqOiIgDSDY44/dz/d5/L2dBISEvZ0FBIS9nQSEh/
http://rubytutorial.wikidot.com/lectura-escritura
https://code-examples.net/es/q/110d90
https://ruby-doc.org/core-2.2.0/Array.html
http://www.forosdelweb.com/f105/compilar-programa-ruby-926839/
https://www.comunycarse.com/es/teoria-colas-los-modelos-formulas-problemas-resueltos/
35

Estructura de Datos y Algoritmos Trabajo Final

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Estructura de Datos y Algoritmos Trabajo Final

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD PERUANA DE CIENCIAS

El trabajo está basado en la necesidad de cubrir funcionalidades que aporten innovación al

II. OBJETIVOS DEL TRABAJO

 Aplicar los conceptos y técnicas asimilados en el curso y/o resultado de la investigación,

3.1. RAZÓN SOCIAL

3.3. PRODUCTOS Y SERVICIOS

 Financieros (Protección de Tarjetas, Seguro de Protección Financiera).

 Cuentas de Ahorro (Cuenta Activa, Cuenta Premio, Primera Cuenta).

 Depósito a Plazos (Pago de Intereses al Vencimiento, Pago de Intereses

 Tipo de Cambio (Dólares, Otras Monedas).

3.4. CANTIDAD DE TRABAJADORES

4.6. ESTRUCTURA ORGANIZACIONAL

Dentro de las iniciativas de innovación se ha identificado la necesidad de contar con un

V. DESCRIPCIÓN DE LA SOLUCIÓN PLANTEADA

5.1. ANÁLISIS DEL PROBLEMA

5.1.2. PROPUESTA DE SOLUCIÓN 1

Implementar un servicio con la funcionalidad del registro de citas para plataformas

No se requiere instalación local ya que el servicio estará publicado en un Web

 En caso de problemas de red, la agencia no podría utilizar este servicio de

5.1.3. PROPUESTA DE SOLUCIÓN 2

Implementar la funcionalidad requerida en cada aplicación digital que se requiera, la

Las aplicaciones digitales dejaran un archivo plano que se cargará con la

 Información no actualizada en línea.

Al analizar las dos propuestas se puede apreciar ventajas de actualización y

Por lo tanto, se concluye que la solución # 1 es la más recomendable debido a que

5.2. DESCRIPCIÓN DE LA SOLUCIÓN A IMPLEMENTAR

Se implementará un Web Service el cual proveerá de una serie de funciones que

El desarrollo contempla la implementación del Servicio, sus funciones de creación,

Grafico 1: Diagrama general de la solución

5.2.2. REQUISITOS FUNCIONALES

A continuación, se describen los requisitos funcionales para la implementación del

5.4.2.1. Requisito Funcional 1: Parametrización del servicio

Las reservas se darán en intervalos de T tiempo (por ejemplo, cada 15

Las reservas solo estarán disponibles para usuarios registrados como

5.4.2.3. Requisito Funcional 3: Obtener listado de Agencias

5.4.2.4. Requisito Funcional 4: Obtener listado de Motivos

5.4.2.5. Requisito Funcional 5: Obtener listado de Calificación

El servicio contará con una función que permitirá obtener la lista de

5.4.2.6. Requisito Funcional 6: Generación de Cita

Un cliente puede reservar la cita a través de diversos canales digitales, estos

5.4.2.7. Requisito Funcional 7: Cancelación de Cita

El cliente puede realizar la cancelación de un ticket ya generado. Para lo cual

5.4.2.8. Requisito Funcional 8: Listado de Citas

El servicio centralizado es consultado por un aplicativo que se encuentra en

5.2.3. ESTRUCTURA DE DATOS

A continuación, mencionaremos las funciones y código fuente implementadas en la

6.1. PROGRAMA “SERVICIO DE TICKETERA DIGITAL”

Función Breve Descripción

A continuación, se indica el código fuente implementado:

def validar_Cita(cliente, agencia, fechaCita, horaCita)

def crear_Solicitud(cliente, agencia, motivo, canal, fechaCita, horaCita, mensajeXML="")

if validar_Cliente(cliente) and validar_Agencia(agencia) and validar_Motivo(motivo) and

def cancelar_Solicitud(cliente, ticket)

def calificar_Cita(cita, califica)

def listar_Solicitudes(cliente="", agencia="", fecha="", canal="",

def completar_Campo(cadena, largo)

def escribir_Archivo(archivo, cadena)

#Movemos el archivo XML procesado

puts "INICIANDO SERVICIO DE TICKETERA DIGITAL"+"\n"

puts "VALORES CARGADOS EN EL SERVICIO..."

while tiempoFinal >= tiempoInicial

return "FINALIZO SERVICIO DE TICKETERA DIGITAL"+"\n"

6.2. PROGRAMA “TEST DEL SERVICIO”