ProyectodeGrado_Fabian Cuervo_2008

ANÁLISIS Y DESARROLLO DE UN SISTEMA DE INFORMACIÓN PARA
EL CÁLCULO Y ADMINISTRACIÓN DE CRÉDITOS, EN EL SECTOR
FINANCIERO.
Fabián Andrés Cuervo Fajardo
Código 533012
FUNDACIÓN UNIVERSITARIA KONRAD LORENZ
FACULTAD DE INGENIERÍA DE SISTEMAS
BOGOTÁ
2008
ANÁLISIS Y DESARROLLO DE UN SISTEMA DE INFORMACIÓN PARA
EL CÁLCULO Y ADMINISTRACIÓN DE CRÉDITOS, EN EL SECTOR
FINANCIERO.
PROYECTO DE GRADO PARA OBTENER EL TITULO
DE INGENIERO DE SISTEMAS
Fabián Andrés Cuervo Fajardo
Director:
Ingeniero Gustavo Herazo
FUNDACIÓN UNIVERSITARIA KONRAD LORENZ
FACULTAD DE INGENIERÍA DE SISTEMAS
BOGOTÁ
2008
1
Nota de aceptación
____________________________
____________________________
____________________________
Presidente del jurado
______________________________
Jurado
______________________________
Jurado
Bogotá _____________________
(DD-MM-AAAA)
2
Dedicado a mis padres
Lucio y Rosa Elena por
su apoyo y dedicación
en mi proceso formativo
3
AGRADECIMIENTOS
Agradezco a todas las personas que me han acompañado en todo el proceso
educativo a través de este largo camino de estudio y dedicación,
agradecimiento especialmente a:
Ingeniero Gustavo Herazo Pérez, por su gran colaboración en todo el
proceso de análisis y diseño del presente proyecto de investigación.
Ingeniero Javier Ávila, gracias a su dedicación, experiencia y conocimientos,
que con criterios éticos y profesionales, compartió en estos últimos
semestres.
Ingeniero Germán Vargas, por su entusiasmo, optimismo y su desempeño en
la labor docente, generando en los estudiantes deseos de continuar y gusto
por la carrera.
Paula y Fidgeral, compañeros que en el transcurso de los años fueron apoyo
y compañía en este largo camino.
4
TABLA DE CONTENIDO
1 ASPECTOS DE LA INVESTIGACIÓN ........................................................ 8
1.1 DESCRIPCIÓN DEL PROBLEMA ........................................................... 8
1.2 JUSTIFICACIÓN DEL PROYECTO DE INVESTIGACIÓN ...................... 9
1.2.1 Razones sociales ................................................................................. 9
1.2.2 Razones económicas .......................................................................... 9
1.2.3 Razones técnicas ................................................................................. 9
1.2.4 Razones organizacionales ................................................................ 10
1.2.5 Razones metodológicas .................................................................... 10
1.3 DELIMITACIÓN ...................................................................................... 10
1.3.1 Espacial .............................................................................................. 10
1.3.2 Cronología .......................................................................................... 10
1.3.3 Conceptual ......................................................................................... 11
1.3.4 Financiera ........................................................................................... 11
1.3.5 Metodológica ...................................................................................... 11
1.4 OBJETIVOS ........................................................................................... 13
1.4.1 General ............................................................................................... 13
1.4.2 Específicos ......................................................................................... 13
1.5 PROPÓSITO........................................................................................... 14
2 MARCO TEORICO .................................................................................... 16
2.1 ANTECEDENTES................................................................................... 16
2.1.1 Históricos ........................................................................................... 16
2.1.1.1 Los Inicios: La Roma Imperial ....................................................... 16
2.1.1.2 La Edad Media ................................................................................. 17
2.1.1.3 El renacimiento y el desarrollo del capitalismo ........................... 17
2.1.2 Legales ............................................................................................... 18
2.1.3 Investigativos ..................................................................................... 19
2.2 BASES TEÓRICAS ................................................................................ 22
2.2.1 Definición de Crédito ......................................................................... 22
2.2.2 Tipos de Créditos............................................................................... 23
2.2.2.1 Crédito de libre inversión ............................................................... 23
2.2.2.2 Leasing Habitacional ...................................................................... 23
2.2.2.3 Créditos de estudios ...................................................................... 23
2.2.2.4 Créditos hipotecarios ..................................................................... 24
2.2.3 Interés ................................................................................................. 24
5
2.2.3.1 Interés simple e interés compuesto .............................................. 24
2.2.4 Amortización ...................................................................................... 25
2.2.5 Rentabilidad ....................................................................................... 25
2.3 TEORÍAS GENÉRICAS BASADAS EN LA INGENIERÍA ..................... 25
2.3.1 Productos del Modelo ....................................................................... 27
2.4 MARCO CONCEPTUAL ........................................................................ 28
2.4.1 Metas a alcanzar ................................................................................ 28
2.4.3 Enfoque .............................................................................................. 28
2.4.4 Necesidades a satisfacer .................................................................. 28
2.4.5 Controles ............................................................................................ 29
2.4.5 Servicios ............................................................................................. 29
3 DISEÑO METODOLÓGICO ...................................................................... 30
3.1 TIPO DE INVESTIGACIÓN DESCRIPTIVA ........................................... 30
3.2 ANÁLISIS ............................................................................................... 30
3.2.1 Metodología para el análisis ............................................................. 30
3.2.1.1 Análisis orientado a objetos .......................................................... 30
3.2.1.2 Business Process Management .................................................... 31
3.3 DISEÑO .................................................................................................. 32
3.3.1 Diseño Lógico .................................................................................... 32
3.3.2 Diseño Lógico .................................................................................... 65
3.3.2.1 Diseño base de datos ..................................................................... 65
3.3.2.1.1 Aspectos físicos de la base de datos ........................................ 65
4 ANÁLISIS DE RESULTADOS Y CONCLUSIONES ................................. 71
4.1 CODIFICACIÓN DEL PROGRAMA ....................................................... 71
4.2 BANCO DE PRUEBAS .......................................................................... 71
4.2.1 Pruebas de función............................................................................ 72
4.2.2 Pruebas modulares............................................................................ 73
4.2.3 Pruebas de Documentación y Ayuda ............................................... 74
4.2.4 Pruebas de Seguridad y Control ...................................................... 75
4.2.5 Pruebas de Calidad............................................................................ 75
4.3 INFORME DE PRUEBAS ....................................................................... 76
5 CONCLUSIONES ...................................................................................... 83
6 RECOMENDACIONES.............................................................................. 85
BIBLIOGRAFÍA ............................................................................................ 86
6
INTRODUCCIÓN
Actualmente en la red se encuentra una gran gama de simuladores de
cálculo de Intereses, de calculadoras intereses y software de Créditos, los
cuales están limitados a solo calcular los Créditos dependiendo del interés, la
tasa y desplegar los resultados del monto total a pagar.
Anexo a estas aplicaciones se encontró varios formatos de Excel en los
cuales también se tiene la funcionalidad de calcular los Créditos, los cuales
trabajan con macros y subprogramas realizados en Visual Basic.
Todo este software que se ha encontrado en la búsqueda de aplicaciones
que realicen cálculos y administración de Créditos son software propietario y
demos de programas los cuales tienen funcionalidad limitada y son de alto
costo, excepto las calculadoras las cuales son un servicio que se presta de
forma gratuita.
Ahora en la actualidad existen empresas que comercializan con créditos y no
se posee con el software necesario para el cálculo y la administración de
esto más que en Hojas de cálculo, y aplicaciones que no cubren totalmente
sus necesidades, ya que no acompañan todo el proceso del Crédito, solo el
cálculo de las cuotas y los intereses del Crédito con las limitantes de la hoja
de cálculo y de los conocimientos de la persona que opera estos cálculos.
7
1. ASPECTOS DE LA INVESTIGACIÓN
1.1.
DESCRIPCIÓN DEL PROBLEMA
Las exigencias del mercado y los nuevos modelos económicos que nacen a
diario, exigen de las compañías prestadoras de servicios financiaros, la
utilización de varias clases de software hechos a la medida, dependiendo de
los tipos de crédito que ofrezcan, que les permitan un mejor manejo y
desempeño de los intereses a cobrar, así mismo, que permitan administrar
los pagos que se realizan de la deuda.
En la Internet se pueden encontrar distintas clases de calculadoras de
intereses y plantillas en Excel, sin embargo, estos sistemas no contribuyen a
la elaboración, manejo de datos y clasificación de resultados, necesarios y
vitales para administración eficiente de la información, haciendo difícil la
labor de una empresa, pues las bases de este software son clásicas y
simples.
Presentando este problema, se pudo evidenciar en la investigación, que es
muy poco el software que ofrecen estas facilidades de forma integral,
además, que lo pueda hacer a bajos costos. Esto implica a las empresas que
solicitan este tipo de software, que deban desarrollarlo por sus propios
medios o que lo tengan que comprar ya desarrollado, exponiéndose a
adquirir algo que en un futuro sea obsoleto, o peor, que no ofrezca lo que
realmente necesita la entidad.
El fin del desarrollo de este software, es ofrecer a las empresas prestadoras
de servicios crediticios, la administración eficiente y a la medida, del cálculo
de los créditos otorgados y ejecutados, el porcentaje de los intereses que se
deben cobrar y el monto y tiempo de los pagos.
8
1.2 JUSTIFICACIÓN DEL PROYECTO DE INVESTIGACIÓN
La importancia de este proyecto radica en que ofrece múltiples soluciones
para las entidades prestadoras de servicios financieros, que van desde
administrar eficientemente la lista de clientes, hasta calcular las tasas de
interés a las que están sometidos los créditos.
1.2.1 Razones sociales
Entre las razones sociales que existen para la elaboración de este proyecto,
se encuentran la importancia de suplir las necesidades de las empresas que
ofrecen créditos. También brindar soluciones prácticas, confiables y
eficientes de un modelo novedoso que permitirá gestionar y administrar los
recursos manejados a través de créditos otorgados a los usuarios que los
soliciten.
1.2.2 Razones económicas
Se busca crear el software con el fin de que las compañías que lo soliciten
puedan adquirirlo a bajos costos, ya que entre los pocos sistemas que se
encuentran en el mercado, los precios son elevados comparados con el que
se ofrece en este proyecto.
1.2.3 Razones técnicas
La aplicación podrá ser utilizada en equipos con plataforma Windows, en el
lenguaje Visual Basic .NET 2005 y con bases de datos Microsoft SQL Server
2005 Express Edition, versión freeware, ya que estas herramientas son de la
misma casa de software, son compatibles entre ellas y son populares a nivel
computacional en la actualidad.
9
1.2.4 Razones organizacionales
Las compañías que cuenten con un software como este, tendrán la
posibilidad, de agilizar los procesos, de tener una estricta organización de
sus clientes, de saber con exactitud los créditos otorgados, los montos
cancelados, las tasas de interés a las que están sometidos los créditos, entre
otros aspectos. Así mismo, tendrán la facilidad de adquirirlo, pues los bajos
costos del software, son competitivos frente a los demás que se encuentran
en el mercado.
1.2.5 Razones metodológicas
Realizar un software basándose en el cálculo de intereses y amortización de
cuotas, teniendo como partida la matemática financiera y la teoría de cálculo
de tasas de interés simple, compuesto y nominal, como base fundamental
para cumplir el propósito principal del proyecto.
1.3 DELIMITACIÓN
1.3.1 Espacial
El proyecto se realiza en las instalaciones de la Fundación Universitaria
Konrad Lorenz, bajo la coordinación del área de investigaciones, en donde
se entregaran actas semanales para la asignatura Proyecto de Grado.
1.3.2 Cronología
El proyecto se realiza en un lapso de tiempo de 4 meses, en los cuales se
cumplirá con cada una de las fases a desarrollar en el tiempo determinado
10
para la entrega total del proyecto. Teniendo presente los entregables
periódicos al área de investigación.
1.3.3 Conceptual
En el proyecto se realiza la investigación de matemáticas financieras
enfatizándose en el cálculo de intereses, rentabilidad y amortización de
cuotas, así mismo se realizara un estudio del manejo de la base de datos
Microsoft SQL Server 2005 Express Edition, ya que es una herramienta
nueva para el equipo de trabajo.
1.3.4 Financiera
Para la realización del proyecto se contará con los siguientes recursos físicos
y tecnológicos:
• Equipo de computo
$ 1’500.000
• Conexión Internet
$ 160.000
• Papelería
$ 160.000
• CD’s
$ 20.000
• Servicio público – Luz
$ 48.000
• Otros Gastos personales $100.000
1.3.5 Metodológica
A nivel metodológico se trabajó el modelo de Análisis y Diseño orientado a
Objetos debido a la orientación del proyecto y también por el lenguaje en el
cual se realizará, en todo el CVDS (Ciclo de Vida de Desarrollo de Software),
dado que esta metodología tiene un conjunto de disciplinas que desarrollan y
11
modelan el software y facilitan la construcción de sistemas complejos a partir
de componentes.
Para la construcción y el modelado de todos los componentes del proyecto a
nivel de software se utilizó la herramienta UML, [1] las siglas corresponden a
Lenguaje Unificado de Modelado (Unified Modeling Language), la definición
de UML se puede obtener descomponiendo las palabras que la conforman.
Lenguaje: como todo lenguaje cuenta con una sintaxis y una semántica, por
lo tanto al realizar cualquier modelo es necesario conocer una serie de reglas
de cómo es el manejo de los elemento s en el lenguaje
Modelado: con él se modelan los aspectos del mundo real, los cuales
permiten la correcta interpretación y entendimiento de este.
Unificado: es unificado ya que agrupa varias técnicas de modelado en un
solo modelo.
El proyecto se desarrollo a nivel de programación siguiendo un patrón de
diseño, modelo vista controlador, el cual es bastante acorde con el modelo
de Análisis y diseño orientado a objetos.
Patrón Modelo-Vista-Controlador
[2] Este patrón se utiliza en diseño de aplicaciones con sofisticadas
interfaces. El fin es realizar un diseño que separe la vista del modelo, esto
para aprovechar la reusabilidad de código, de tal forma que el cambio en las
vistas no afecten el modelo del negocio y el modelo de datos, por otra parte
al utilizar la herramienta .Net para el proyecto, en futuro se podrá llevar a la
web por medio de ASP.Net, utilizando la misma controladora y el mismo
modelo, para entender mejor cada uno de los componentes del modelo, se
describen a continuación.
12
El modelo es el responsable de:
Acceder a la capa de almacenamiento de datos. Es ideal que el modelo sea
independiente del sistema de almacenamiento. Define las reglas de negocio.
El controlador es responsable de:
Recibe los eventos de entrada Contiene reglas de gestión de eventos, tanto
de la vista como del modelo.
Las vistas son responsables de:
Recibir datos del modelo y mostrarlos al usuario, así como hacer el proceso
contrario recibir los datos del usuario y registrarlos en el modelo para que
sean procesados y registrados,
1.4 OBJETIVOS
1.4.1 General
Desarrollar un Sistema de Información, para el cálculo y administración de
préstamos monetarios en el sector financiero, utilizando un modelo
metodológico de Ingeniería de Software, que haga más óptimos los procesos
organizacionales en las empresas.
1.4.2 Específicos
1.4.2.1
Realizar el levantamiento de información necesario, para la
gestión del proyecto a nivel conceptual, metodológico, jurídico y
operacional, con respecto al cálculo de intereses y administración de
créditos financieros.
13
1.4.2.2
Elaborar el análisis y diseño respectivo de la aplicación, con los
lineamientos metodológicos tanto de software, como del modelado del
negocio
1.4.2.3
Desarrollar la aplicación con estándares abiertos, utilizando la
metodología adecuada, con fases definidas.
1.4.2.4
Realizar la fase de pruebas de forma adecuada, con los
parámetros necesarios para asegurar el correcto funcionamiento de la
aplicación tanto funcional como operativo.
1.4.2.5
Realizar la documentación respectiva a los manuales de
instalación, técnico y de usuario.
1.4.2.6
Documentar todos los procesos desarrollados en el proyecto de
acuerdo a las normas de investigación que están descritas en el
método científico.
1.5 PROPÓSITO
El propósito de este proyecto, es conseguir que las empresas prestadoras de
servicios financieros en el país, tengan un software hecho a la medida de sus
necesidades, que les permita administrar de forma eficiente los recursos
otorgados a sus clientes por medio de créditos.
Así mismo, se busca consolidar al interior de las compañías, la importancia
de tener una buena administración de sus datos por medio de un programa
económico que ofrece todas las ventajas de un sistema que esté identificado
14
en otro nicho de mercado, y que por supuesto tenga unos costos más
elevados.
15
2. MARCO TEÓRICO
2.1 ANTECEDENTES
2.1.1. Históricos
A través de la Historia se ha realizado todo tipo de manejo e intercambio de
dinero y bienes, siempre orientado a tener una ganancia o una rentabilidad al
realizar esta negociación, aun yendo más atrás en la historia se sabe del
intercambio de elementos perteneciente a las culturas, partiendo de las
necesidades que se presentaban en la época. A continuación se mencionara
algunos hechos principales en el trayecto de los créditos y el manejo de
tasas de Interés.
2.1.1.1
Los inicios: la roma imperial
[3] la historia de las tasas de interés se encuentra relacionada con la
creación del dinero y así mismo de los bancos como segunda medida.
Las tasas de interés desde esta época estuvieron ligadas a realizar un
receso en la actividad económica en el presente para obtener una
recompensa económica a futuro, lo que se conoce en esta época como
ahorro, para la población en esta época era bastante llamativo tener
ganancias de su dinero solo con el hecho de dejar de consumir ahora, desde
la roma imperial, en el tema, hay dos conceptos que son bastante
importantes el capital y el tiempo, aparte de la tasa de interés con la cual se
realiza el préstamo, otro factor primordial es la ganancia que tiene el banco y
los gastos operativos que este representen.
16
En la roma antigua los intereses no se encontraban regulados como en esta
época, pero cabe resaltar que existía la banca comercial y los préstamos a
interés, y retomando lo primero en ocasiones el deudor y su familia
quedaban sumidos a la esclavitud, o estas deudas eran cobradas con la vida,
para satisfacción personal del prestamista, al no tener el dinero de
reembolso. En nuestra época este hecho es el que conocemos como usura y
hay leyes que amparan a las personas que son acreedores de un préstamo,
pero en la época de la roma antigua era practicado de los nobles con los
plebeyos sin ningún tipo de ley que protegiera el plebeyo y si con todos los
derechos sobre el noble.
2.1.1.2
La edad media
[3] Aunque a principios de la edad media la iglesia se vio apática al préstamo
de dinero, llego a considerarlo hasta un pecado y tachaba el oficio de
prestamista como bajo, pero en la época debido a la guerra y los grandes
costos que esta generaba, la iglesia empezó a ceder espacio para los
préstamos, ya que varios de ellos Iban dirigidos a la iglesia, de hecho con el
amparo de la iglesia se hicieron una gran cantidad de fortunas.
De esta forma y con el apoyo de la iglesia surgió la justificación ideológica
para la burguesía, desde ese entonces, prestar dinero y trabajar en industrias
para obtener un beneficio era una actividad digna y con amparo de la ley
2.1.1.3
El renacimiento y el desarrollo del capitalismo
[3] Con el capitalismo, las tasas de interés fueron un papel bastante
importante en las transacciones regulares que se realizaban en esta época,
ya que el crédito y el ahorro funcionaron en torno de la acumulación de
capital, desde este entonces y con los antecedentes de la roma antigua y la
edad media, el estado comenzó a regular las tasas de interés, de esta forma
17
tomo control el gobierno sobre los prestamos y los intereses siendo la primer
potencia en el capitalismo.
2.1.2 Legales
En la actualidad el Gobierno Nacional tiene establecidas varias normas que
hablan sobre el manejo de la captación de dinero de las personas por parte
de las entidades bancarias en Colombia, entre las que se encuentra:
Ley 45 de 1990
[4] Por la cual se expiden normas en materia de intermediación financiera,
se regula la actividad aseguradora, se conceden unas facultades y se dictan
otras disposiciones.
Ley 35 de 1993
[4] Por la cual se dictan normas generales y se señalan en ella los objetivos
y criterios a los cuales debe sujetarse el Gobierno Nacional para regular las
actividades financiera, bursátil y aseguradora y cualquier otra relacionada
con el manejo, aprovechamiento e inversión de recursos captados del
público y se dictan otras disposiciones en materia financiera y aseguradora.
Ley 546 de 1999
[4] Por la cual se dictan normas en materia de vivienda, se señalan los
objetivos y criterios generales a los cuales debe sujetarse el Gobierno
Nacional para regular un sistema especializado para su financiación, se
crean instrumentos de ahorro destinado a dicha financiación, se dictan
medidas relacionadas con los impuestos y otros costos vinculados a la
construcción y negociación de vivienda y se expiden otras disposiciones.
18
Ley 964 de 2005
[4] Por la cual se dictan normas generales y se señalan en ellas los objetivos
y criterios a los cuales debe sujetarse el Gobierno Nacional para regular las
actividades de manejo, aprovechamiento e inversión de recursos captados
del público que se efectúen mediante valores y se dictan otras disposiciones.
Ley 510 de 1999
[5] Por la cual se dictan disposiciones en relación con el sistema financiero y
asegurador, el mercado público de valores, las Superintendencias Bancaria y
de Valores y se conceden unas facultades.
Ley 550 de 1999
[6] Por la cual se establece un régimen que promueva y facilite la
reactivación empresarial y la reestructuración de los entes territoriales para
asegurar la función social de las empresas y lograr el desarrollo armónico de
las regiones y se dictan disposiciones para armonizar el régimen legal
vigente con las normas de esta ley.
2.1.3 Investigativos
Otro software que se encuentran en el mercado a nivel mundial, presentan
características similares a las que en este proyecto se están desarrollando.
[9] Credit2Win Profesional 2007, este paquete de software es bastante
completo para la compañía que requiera llevar el control de los créditos
realizados, No los calcula, se basa en el ingreso de la información al sistema
y la generación de múltiples reportes, en el momento solo está disponible en
el idioma Ingles, la parametrización es bastante compleja. Es bastante
completo en cuanto a los reportes se refiere, posee la opción de crear
reportes personalizados por el usuario, el uso del software es complejo, no
19
es compatible con otros paquetes similares, la base de datos está inmersa
en el paquete, su fin no es solo el manejo de créditos sino generadores de
cartas de crédito, manejo de contactos, tareas de gerencia, planificación
horaria y contactos, por lo cual pierde el énfasis de la amortización y
rendimiento en créditos financieros, la versión gratuita viene completa, pero
solo dura 7 días y es necesario comprarlo para seguirlo usando. Como se ve
en la figura se llevan la parametrización de la compañía los individuos, los
créditos, los contactos, los eventos, las tareas y los usuarios. Anexo a esto la
seguridad es mínima para el usuario
Tipo: Shareware, Costo: $495.00 US, Tamaño: 12415 K.
20
[10] LoanSpread, es un software completo para el cálculo de tasas de
intereses, se acerca bastante al presente proyecto, al tomar diversas tasas
por periodos, según un valor indicado para el cálculo de estos, maneja
diversas tasas de interés, tomando como base el valor de la tasa ingresada
al sistema, es una herramienta bastante completa en cuanto al cálculo de
intereses, pero no administra los créditos que se realizan, ni lleva el control
de los pagos, está disponible solo en ingles, su uso es bastante sencillo, la
versión demo solo da la posibilidad de usarlo 10 veces, luego hay que
comprarlo, no tiene opción de reportes, la información que se obtiene solo se
pude imprimir de forma plana, no tiene ningún tipo de seguridad anexa al
software, en la imagen se realizo un crédito de $ 5000000, tasa de interés de
8,75%, con calculo mensual y para pagos en 10 meses los cual arrojo la
cuota de 520270,59. Y muestra las tasas cercanas ascendente y
descendente, como los valores cercanos en múltiplos de mil, lo cual no es
muy útil para la administración solo para la simulación de un crédito.
Tipo: Shareware, Costo: $29.95 US, Tamaño: 1889 K
21
El proyecto que se está realizando tiene como propósito combinar las
funcionalidades de estos dos y generar las amortizaciones de créditos con
gran cantidad de opciones y la administración de este a futuro y con pagos
completos de cuotas.
2.2
BASES TEÓRICAS
2.2.1 Definición de Crédito
[11] El crédito es un préstamo de dinero que el Banco o una entidad otorga a
su cliente, con el compromiso de que en el futuro, el cliente devolverá dicho
22
préstamo en forma gradual (mediante el pago de cuotas) o en un solo pago y
con un interés adicional que compensa al Banco o a la entidad por todo el
tiempo que no tuvo ese dinero.
2.2.2 Tipos de Créditos
En el proyecto se manejan diversos tipos de créditos y se tiene la ventaja de
poder parametrizarlos según la necesidad de la entidad que este prestando
el servicio. Aunque generalmente se diferencia solamente entre créditos
personales y créditos hipotecarios, también se distinguen los siguientes tipos
de créditos:
2.2.2.1
Crédito de libre inversión
Son utilizados al gusto del solicitante o para suplir una necesidad, no tiene un
fin en común, por lo general la cantidad de dinero no es muy alta debido a
que no siempre es para generar alguna rentabilidad.
2.2.2.2
Leasing Habitacional
Es la opción de financiar la compra de un inmueble o un activo en caso de
las compañías, mediante un contrato de arrendamiento financiero con opción
de compra.
2.2.2.3
Créditos de estudios
Son Créditos dirigidos a estudiantes para financiar matriculas universitarias,
estudios de postgrado o estudio en el extranjero. Por lo general el pago de
estos créditos se realiza al finalizar los estudios y devengar un salario el
aspirante al crédito. También en ocasiones este crédito se renueva
dependiendo de las calificaciones del aspirante.
23
2.2.2.4
Créditos hipotecarios
El Crédito hipotecario se caracteriza porque, aparte de la garantía personal,
se ofrece como garantía la hipoteca de un bien inmueble. En caso de no
devolver el Crédito la entidad financiera pasaría a ser la propietaria de la
vivienda.
2.2.3 Interés
Corresponde a la renta que se paga por el uso de un capital durante un
determinado tiempo.
I=P–F
Donde: P= capital, I= interés, F= cantidad acumulada
Esta cantidad recibe diferente nombres comerciales como interés, utilidad,
variación del dinero en el tiempo, rentabilidad, entre otros.
2.2.3.1
Interés simple e interés compuesto
Para el proyecto el concepto de interés simple y compuesto son
fundamentales para la amortización de las cuotas debido al tiempo y al tipo
de pago que se va a realizar, ya que con esta información se realizara los
cálculos de los interés basándose en estos tipos de interés, El interés simple
es el que se obtiene cuando los intereses producidos, durante todo el tiempo
del crédito, se deben únicamente al capital inicial. Por su parte, el interés
compuesto es el que se obtiene cuando al capital se le suman
periódicamente los intereses producidos. Así al final de cada periodo el
capital que se tiene es el capital anterior más los intereses producidos por
ese capital durante dicho periodo.
24
En el desarrollo se aplica los intereses compuestos para realizar el cálculo de
las cuotas de los créditos por medio de la siguiente formula.
S = P(1+in)
Donde: P= valor crédito, i= tasa de interés, n= numero de cuotas
En el proyecto esta es la formula base para el cálculo de intereses, en la
formula, el valor de n está reflejado en meses, por lo cual para realizar el
cálculo es necesario expresarlo en días
2.2.4 Amortización
[12] Una amortización es una disminución gradual o extinción gradual de
cualquier deuda durante un periodo de tiempo. La amortización de un crédito
se da cuando se realiza al prestamista un reembolso de dinero prestado en
un cierto plazo y con tasas de interés.
2.2.5 Rentabilidad
Cuando se menciona le termino de rentabilidad se hace referencia más a las
ganancias que a las pérdidas generadas por el crédito, en términos del
proyecto son ganancias en dinero o la remuneración recibida por el capital
invertido.
2.3
TEORÍAS GENÉRICAS BASADAS EN LA INGENIERÍA
Para el desarrollo del proyecto se utilizo un motor de base de Microsoft SQL
Server 2005 Express Edition, versión freeware, donde se realizo la base de
datos para el almacenamiento de la información, relacionada con los
25
créditos, los clientes, las cuotas y al parametrización que se realiza en el
sistema.
La aplicación se realizó para plataformas Microsoft. El lenguaje de
programación que se utilizo para el desarrollo de la aplicación es Visual
Basic .NET.
Microsoft SQL Server 2005 Express Edition
El proyecto se realizo con esta base de datos por motivos de compatibilidad
con el lenguaje de programación, por otra parte por motivos de trabajar con
una herramienta poderosa y nueva para el equipo de programación, desde el
comienzo del proyecto se desconocía el manejo de la herramienta. [13] SQL
Server Express es un producto de base de datos gratis y fácil de usar,
basado en tecnología SQL Server 2005. Está diseñado para brindar una
simplicidad de uso, permitiendo instalaciones rápidas. La facilidad de uso
comienza con una instalación robusta de la interface del usuario grafica
(GUI) que guía al usuario a través del proceso de instalación. Las
herramientas GUI que se encuentran incluidas sin cargo con SQL Server
Express, incluyen Express Manager (versión Alfa) y Computer Manager.
Estas herramientas simplifican las operaciones de bases de datos. El diseño
y desarrollo de aplicaciones de bases de datos se vuelve más sencillo con la
integración de Visual Studio. Con todas estas ventajas de interface de
usuario, en el transcurso del proyecto se presentó la necesidad de ejecutar
sentencias en SQL, por complejidad en la realización de procesos.
Visual Studio .NET
[14] Visual Studio .NET es un conjunto completo de herramientas de
desarrollo para la construcción de aplicaciones Web ASP, servicios Web
XML, aplicaciones para escritorio y aplicaciones móviles. Visual Basic .NET,
26
Visual C++ .NET, Visual C# .NET y Visual J# .NET utilizan el mismo entorno
de desarrollo integrado (IDE), que les permite compartir herramientas y
facilita la creación de soluciones en varios lenguajes. Asimismo, dichos
lenguajes aprovechan las funciones de .NET Framework, que ofrece acceso
a tecnologías clave para simplificar el desarrollo de aplicaciones Web ASP y
servicios Web XML.
Visual Basic .NET 2005
El proyecto se desarrollo con este lenguaje de programación, debido a la
metodología de análisis y diseño orientado a objetos, Visual Basic es la
opción más óptima para la realización del proyecto, por su robustez y
documentación dirigida a los desarrolladores. [15] Microsoft Visual Basic
2005 es la evolución del lenguaje Visual Basic que está diseñado para
generar de manera productiva aplicaciones con seguridad y orientado a
objetos. Visual Basic permite centrar el diseño en Windows, el Web y
dispositivos móviles. Como con todos los lenguajes que tienen por objetivo
Microsoft .NET Framework, los programas escritos en Visual Basic se
benefician de la seguridad y la interoperabilidad de lenguajes.
2.3.1 Productos del Modelo
Al finalizar con el proyecto se deben entregar los siguientes productos:
•
Aplicación
•
Documentación del proceso de desarrollo
•
Manual del Usuario
•
Documentación de la herramienta
•
Documentación de las bases de datos
•
Estado del proyecto
•
Aspectos a mejorar
27
2.4 MARCO CONCEPTUAL
2.4.1 Metas a alcanzar
• Lograr el desarrollo de un software completo que permita a las
entidades que tienen como base de su negocio la otorgación de
créditos financieros a usuarios, el completo manejo de datos
importantes como la administración de los créditos, el total de
intereses, entre otros.
• Facilitar la adquisición de un software de bajo costo que cumpla con
todos los requerimientos necesarios para poder administrar de manera
eficiente los recursos que tienen que ver con el otorgamiento de
créditos.
• Ofrecer una opción más en el mercado que pueda competir contra
otros sistemas avanzados, que tenga como valor agregado, el
desarrollo a la medida de las necesidades de la empresa.
2.4.1 Enfoque
El presente proyecto de investigación tiene un enfoque de tipo puntual, ya
que su delimitación solo contempla la gestión de créditos, intereses sobre el
crédito, fechas de pago, administración de clientes y pagos de cuotas
completas.
2.4.2 Necesidades a satisfacer
Este desarrollo solucionará los inconvenientes que tienen las empresas a la
hora de manejar todo lo referente a los créditos, pagos, clientes e intereses.
28
Así mismo, solucionará los inconvenientes que presentan las entidades a la
hora de conseguir un software que supla realmente las necesidades que
tienen al pie de la letra.
2.4.3 Servicios
• Ingresar, actualizar y eliminación de los clientes
• Ingresar, actualizar y eliminar tasas de interés
• Ingresar, actualizar y eliminar requisitos por créditos
• Ingresar, actualizar y eliminar tipos de crédito
• Ingresar, actualizar y eliminar documentación requerida por créditos
• Registrar y eliminación de créditos
• Simulación del crédito
• Visualización del crédito
• Pago de cuota completa
2.4.4 Controles
Para poder acceder al sistema, el software solicitará un usuario y una clave,
al cual valida entre dos perfiles de usuario y el administrador, el
administrador tiene todos los derechos sobre toda la funcionalidad de la
aplicación y el asesor, perfil que no tendrá acceso al formulario de usuarios y
tampoco podrá parametrizar el modulo, pero si podrá consultar la
parametrización existente.
29
3. DISEÑO METODOLÓGICO
3.1 TIPO DE INVESTIGACIÓN DESCRIPTIVA
El Presente proyecto de investigación es de tipo descriptivo, ya que en la
investigación se busca describir y especificar las propiedades más
importantes de los procesos computacionales para lograr requerimientos
óptimos y acordes con las necesidades del cálculo y el manejo de tasas de
interés, la amortización de créditos y la administración de créditos por parte
de la empresa.
Adicionalmente en la investigación, se describirán las características que
identifican los diferentes elementos y componentes de la investigación.
3.2 ANÁLISIS
3.2.1 Metodología para el análisis
3.2.1.1 Análisis orientado a objetos
El presente proyecto de investigación se trabaja con metodología AOO, en
donde se brindan los medios para mejorar la reutilización de los
componentes software. El objetivo de la programación orientada a objetos es
permitir que los sistemas informáticos sean fácilmente extendidos para
mejorar su funcionalidad, o reutilizados en otros sistemas que requieran sus
servicios.
30
Las características que integran la Programación orientada a objetos son la:
abstracción, encapsulación, polimorfismo y herencia.
La herramienta de diseño será UML, Lenguaje de Modelamiento Unificado
(UML - Unified Modeling Language) es un lenguaje gráfico para visualizar,
especificar y documentar cada una de las partes que comprende el
desarrollo de software. La definición de UML se encuentra más detallada en
el numeral 1.3.5 Delimitación metodológica, del presente documento.
Se utilizan los siguientes diagramas para su conceptualización:
•
Diagrama de Casos de Uso: mostrando los procesos relevantes en un
escenario con sus respectivos actores.
•
Diagrama de secuencia: Muestran a los diferentes objetos y las
relaciones que pueden tener entre ellos, los mensajes que se envían
entre ellos.
•
Diagrama de actividades: Es un caso especial
del diagrama de
estados. Muestra el flujo entre los objetos. Se utilizan para modelar el
funcionamiento del sistema y el flujo de control entre objetos.
•
Diagramas de clases: muestran las diferentes clases que componen
un sistema y cómo se relacionan unas con otras. Los diagramas de
clases son diagramas estáticos porque muestran las clases, junto con
sus métodos y atributos, así como las relaciones estáticas entre ella
3.2.1.2
Business Process Management
Para mejor análisis del ciclo de negocio utilizado al realizar créditos
financieros se utilizo la metodología empresarial BMP, así mismo se quiere
representar como es el proceso de créditos en el sistema de información.
[16] Business Process Management es la metodología empresarial cuyo
31
objetivo es mejorar la eficiencia a través de la gestión sistemática de los
procesos de negocio, que se deben modelar, automatizar, integrar,
monitorear y optimizar de forma continúa.
A través del modelado de las actividades y procesos puede lograrse un mejor
entendimiento del negocio y muchas veces esto presenta la oportunidad de
mejorarlos. La administración de los procesos permite asegurar que los
mismos se ejecuten eficientemente, y la obtención de información que luego
puede ser usada para mejorarlos. Es a través de la información que se
obtiene de la ejecución diaria de los procesos, que se puede identificar
posibles ineficiencias en los mismos, y actuar sobre las mismas para
Asesor comercial
administrador
optimizarlos.
Crear usuarios
Parametrizar
aplicacion
Ver disponibilidad
Ejecutar
simulación
Aprobar credito
Registrar pago
Recibir solicitud
Informar
documentación
Consultar cuotas
Reporte a cliente
SI
Cancelar crédito
Cliente
Pagar cuotas
3.3
Aceptar credito
Solicitar crédito
NO
DISEÑO
3.3.1 Diseño Lógico
El sistema a desarrollar va a aplicar el DOO (Diseño Orientado a Objetos).
Para tal fin presentaremos los siguientes diagramas:
32
Diagrama de Casos de Uso: Muestran los casos de uso, actores y sus
relaciones. Muestra quien puede hacer que y relaciones existentes entre
acciones (casos de uso). Son muy importantes para modelar y organizar el
comportamiento del sistema.
Describen qué hace el sistema desde el punto de vista de un observador
externo. Ponen énfasis en qué hace el sistema, no en cómo lo hace.
33
Caso de uso análisis y desarrollo de un sistema de información para le
calculo y la administración de créditos a nivel financiero
34
Caso de Uso: parametrizar aplicación.
Nombre:
Parametrizar aplicación.
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
Representa la parametrización que se debe realizar al modulo, antes de ser
usado por el asesor.
Actores:
Administrador.
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
Flujo Normal:
El administrador parametriza el sistema, según la normalización y las
necesidades del modulo.
Flujo Alternativo:
El sistema realiza la validación de la parametrización, con respecto a los
datos parametrizados.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se puede continuar con el registro de clientes y el registro de los créditos.
35
Caso de Uso: Registrar usuarios
Nombre:
Registrar usuarios
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
Representa el ingreso de usuarios al sistema, los cuales tienen, una
contraseña y un perfil de asesor o de administrador para interactuar con el
sistema.
Actores:
Administrador.
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
Flujo Normal:
El administrador ingresa los usuarios al sistema, según las necesidades del
modulo y los campos a solicitar.
Flujo Alternativo:
El sistema realiza la validación de con respecto a los usuarios ingresados y a
los usuarios que ya están registrados en el sistema para no permitir
duplicidad.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se puede continuar con el registro de clientes y el registro de los créditos.
36
Caso de Uso: Registrar cliente
Nombre:
Registrar cliente
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
Representa el ingreso de clientes al sistema. Con todos los datos necesarios
para la gestión del crédito e información necesaria de un cliente.
Actores:
Asesor comercial
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
Flujo Normal:
El asesor comercial ingresa los clientes al sistema, registrando todos los
campos solicitados por el modulo.
Flujo Alternativo:
El sistema realiza la validación de los campos con respecto al tipo de dato
que se debe registrar.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se puede continuar con el registro de los créditos y la simulación.
37
Caso de Uso: Solicitar Crédito
Nombre:
Solicitar Crédito
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
El cliente solicita el crédito, según las necesidades de este, especificando,
cantidad, numero de cuotas, fecha inicial de pago, tipo de pago, el asesor
comercial le informa las tasas de crédito, verifica disponibilidad e informa al
cliente los documentos necesarios para el crédito
Actores:
Cliente, asesor comercial
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
La aplicación debe estar parametrizada
El cliente debe estar registrado en el sistema
Los documentos del tipo de crédito deben estar registrados en el sistema
Flujo Normal:
El asesor comercial ingresa los datos del crédito para su registro, el crédito
queda en estado registrado.
Flujo Alternativo:
El sistema realiza la validación de los campos con respecto al tipo de dato
que se debe registrar al sistema.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se realizar la simulación y se cambia de estado el crédito.
38
Caso de Uso: Ejecutar simulación
Nombre:
Ejecutar simulación
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
El asesor ejecuta la simulación del crédito para informar al cliente las cuotas
del crédito y las fechas de pago
Actores:
Asesor comercial
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
El crédito debe estar registrado.
Flujo Normal:
El asesor comercial ejecuta la simulación del crédito, si es necesario
especificar el valor de la cuota, la ingresa en el campo
Flujo Alternativo:
El sistema realiza la validación de los campos con respecto al tipo de dato
que se debe registrar y la validación de los datos necesarios para realizar la
simulación.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se realiza la consulta de las cuotas del crédito y la aprobación o rechazo de
este.
39
Caso de Uso: Aprobar cancelar crédito
Nombre:
Aprobar cancelar crédito
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
El asesor comercial realiza la aprobación del crédito, cuando el cliente
entregue los documentos necesarios e informe del interés de tomar el
creidito
Actores:
Asesor comercial
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
El crédito debe estar registrado, simulado.
Flujo Normal:
El asesor comercial realiza el proceso de cabio de estado del crédito
cambiando de estado “registrado” a estado “cancelado” o “aprobado”
Flujo Alternativo:
El sistema realiza la validación de los campos con respecto al tipo de dato
que se debe registrar.
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se realiza el proceso de registrar pago
40
Caso de Uso: Registrar pago
Nombre:
Registrar pago
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
El cliente realiza el pago en la entidad bancaria o directamente del pago e
informa al asesor comercial del pago realizado, el asesor comercial ingresa al
formulario de registrar pago, selecciona el crédito y la cuota y registra el pago
ejecutando el proceso
Actores:
Asesor comercial, cliente
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
El crédito debe estar registrado, simulado y aprobado.
Flujo Normal:
El asesor comercial realiza el proceso de pago de la cuota según la
información del pago por parte del cliente o la realización del pago en la
entidad.
Flujo Alternativo:
El sistema realiza la validación de la cuota a pagar
Pos condiciones:
Los Datos han sido almacenados en el sistema
Se realiza el proceso del pago de cuotas siguientes.
41
Caso de uso parametrizar modulo
Caso de uso: Parametrizar el modulo.
Nombre:
Parametrizar el modulo
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
Muestra la parametrización necesaria antes de usar el modulo para generar
simulaciones de créditos, aprobación de créditos y pago de cuotas. Es
necesario parametrizar los tipos de crédito y la disponibilidad de dinero por
cada crédito, las tasas de interés que se van a manejar y por último todos los
documentos y la cantidad a solicitar para la aprobación de los créditos.
Actores:
Administrador
Pre condiciones:
El sistema debe estar Instalado.
La conexión con la base de datos debe estar correctamente.
Flujo Normal:
42
El administrador parametriza los tipos de créditos.
El administrador parametriza las tasas a calcular.
El administrador parametriza los documentos a solicitar.
Flujo Alternativo:
El sistema debe ser parametrizado con anterioridad por el administrador,
para realizar una correcta simulación del crédito.
Pos condiciones:
La parametrización queda registrada en el sistema.
43
Cado de uso solicitar credito
Solicitar crédito
informar tipo de
credito
«uses»
Solicitar valor
«uses»
verificar
disponibilidad
Asesor comercial
ingresar tasa de
interes anual del creito
«uses»
informar cantidad
de cuotas
Cliente
«uses»
Informar tipo de
pago
«uses»
Ejecutar simulación
Caso de uso: Solicitar crédito
Nombre:
Solicitar crédito
Autor:
Fabián Andrés Cuervo Fajardo
Fecha:
20/03/2008
Descripción:
Muestra la solicitud del crédito, por parte del cliente y el registro del mismo
44
crédito por parte del asesor comercial, quien luego de recibir toda la
información necesaria para el crédito lo procesa para obtener la simulación
de los valores y las fechas de la amortización del crédito solicitado.
Actores:
Asesor comercial, cliente.
Pre condiciones:
El sistema debe estar Parametrizado.
Flujo Normal:
El cliente solicita el crédito.
El asesor comercial ingresa al sistema la información del cliente y del crédito
que está solicitando.
Ejecuta la simulación
Entrega al cliente la información de forma verbal y el reporte del crédito.
Flujo Alternativo:
El sistema debe ser parametrizado con anterioridad por el administrador,
para realizar una correcta simulación del crédito.
La información debe estar completa, para la correcta simulación del crédito
Pos condiciones:
La simulación queda registrada en el sistema, para aprobar el crédito.
El cliente queda registrado en el sistema para futuros trámites.
Diagrama de secuencia: Muestran a los diferentes objetos y las relaciones
que pueden tener entre ellos, los mensajes que se envían entre ellos. Son
dos diagramas diferentes, que se puede pasar de uno a otro sin pérdida de
información, pero que nos dan puntos de vista diferentes del sistema. En
resumen, cualquiera de los dos es un Diagrama de Interacción.
45
Parametrizar tasas
En el diagrama se observa como es el procedimiento para la parametrización
de las tasas en el sistema, el actor encargado de esta parametrización es el
administrador ingresando la información por formulario, recibiéndola
información la clase controladora, evaluando la solicitud y continuando con el
objeto tasas, llenándolo para así llevarlo a la clase tasas_bd insertarlo en la
base de datos a través de la clase conexión_bd, esta clase abre la conexión
ejecuta el comando y cierra la conexión.
46
Parametrizar requisitos
En el diagrama se observa como es el procedimiento para la parametrización
de los requisitos en el sistema, requisitos los cuales dependen de los créditos
y los documentos que deben haber sido ingresados con anterioridad en el
sistema, el actor encargado de esta parametrización es el administrador
ingresando la información por formulario, recibiéndola información la clase
controladora, evaluando la solicitud y continuando con el objeto requisitos,
llenándolo para así llevarlo a la clase requisitos_bd insertarlo en la base de
datos a través de la clase conexión_bd, esta clase abre la conexión ejecuta
el comando y cierra la conexión.
47
Parametrizar documentos
form_parametrizardocumentos
Creditos
documentos
documentos_bd
conexion-bd
iddocumento
descripción
Cantidad
Administrador
BIngresarDocumento_Click_1()
registar_documentos()
setdocumentos()
documento
setdocumentos()
ejecutar()
abrirconexion()
cerrarconexion()
En el diagrama se observa como es el procedimiento para la parametrización
de los documentos en el sistema, el actor encargado de esta parametrización
es el administrador ingresando la información por formulario, recibiéndola
información la clase controladora, evaluando la solicitud y continuando con el
objeto documentos, llenándolo para así llevarlo a la clase documentos_bd
insertarlo en la base de datos a través de la clase conexión_bd, esta clase
abre la conexión, ejecuta el comando y cierra la conexión.
48
Parametrizar clientes
En el diagrama se observa como es el procedimiento para la parametrización
de los clientes en el sistema, el actor encargado de esta parametrización es
el asesor comercial ingresando la información por formulario, recibiéndola
información la clase controladora, evaluando la solicitud y continuando con el
objeto clientes, llenándolo para así llevarlo a la clase clientes_bd insertarlo
en la base de datos a través de la clase conexión_bd, esta clase abre la
conexión, ejecuta el comando y cierra la conexión.
49
Registrar créditos
En el diagrama se observa como es el procedimiento para la el sistema,
para el registro de los créditos el modulo se debe encontrar totalmente
parametrizado, el actor encargado de esta parametrización es el asesor
comercial ingresando la información por formulario, recibiéndola información
la clase controladora, evaluando la solicitud y continuando con el objeto
registrocredito, llenándolo para así llevarlo a la clase registrocredito bd
insertarlo en la base de datos a través de la clase conexión_bd, esta clase
abre la conexión, ejecuta el comando y cierra la conexión.
50
Parametrizar usuarios
En el diagrama se observa como es el procedimiento para la parametrización
de los usuarios en el sistema, el actor encargado de esta parametrización es
el administrador ingresando la información por formulario, recibiéndola
información la clase controladora, evaluando la solicitud y continuando con el
objeto usuarios, llenándolo para así llevarlo a la clase usuarios_bd insertarlo
en la base de datos a través de la clase conexión_bd, esta clase abre la
conexión, ejecuta el comando y cierra la conexión.
51
Validación de usuarios
seguros
form_ingreso
usuarios_bd
conexion bd
usuario
password
BIngresar_Click_1()
usuario
upd_activoNO()
updateactivoNO()
ejecutar()
abrirconexion()
cerrarconexion()
validaringreso()
validaringreso()
getusuarioid()
Consultar
abrirconexion()
1
boolean: ingresar
upd_activo()
boolean: ingresar
dataset
cerrarconexion()
updateactivo()
ejecutar()
abrirconexion()
1: Este procedimiento lo realiza en un maximo 3 veces de no ingresar los datos correctos validadando los datos con el objeto usuario
cerrarconexion()
El usuario al ingresar al sistema ingresa en los campos el usuario y la
contraseña, al ejecutar el botón de “Ingresar”, el sistema actualiza la tabla de
usuarios en el campo activo con el estado “No”, luego valida con el usuario y
la contraseña que el usuario exista o no en el sistema, este ciclo lo realiza 3
veces en el cual se al ingresar el proceso actualiza en la base de datos el
campo activo en estado “SI”.
52
Simular crédito
El diagrama representa la simulación del crédito dependiendo de las cuotas y las tasas.
53
Diagrama de Clases: Un diagrama de clases es un tipo de diagrama estático que
describe la estructura de un sistema mostrando sus clases, atributos y las
relaciones entre ellos. Los diagramas de clases son utilizados durante el proceso
de análisis y diseño de los sistemas, donde se crea el diseño conceptual de la
información que se manejará en el sistema, y los componentes que se encargaran
del funcionamiento y la relación entre uno y otro.
Parametrizar tasas
1
creditos
+tas : tasas
+tas_bd : tasas_bd
+registar_tasas()
+gettasa()
+gettasaid()
+del_tasas()
+udp_tasas()
<<local>>
1
1
1
1
tasas_bd
+conexion : conexion_bd
+settasa()
+gettasa()
+gettasaid() : tasas
+deltasa()
+updatetasa()
<<parametter>>
1
1
<<local>>
1
1
tasas
1
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
frm_parametrizartasas
+idtasa : String
+descripcion : String
+valor : Double
+fecha : Date
+settasas()
+Getidtasa() : String
+Getdescripcion() : String
+Getvalor() : Double
+Getfecha() : Date
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+parametrizartasas_Load()
+BEliminarTasa_Click()
+BActualizar_Click()
+CActualizarTasa_SelectedIndexChanged()
Parametrizar documentos
55
Parametriza requisitos
1
creditos
<<local>>
1
1
+req : requisitos
+req_bd : requisito_bd
+registar_tipocredito()
+getrequisito()
+getrequisitosidcredito()
+getrequisitoid()
+del_requisito()
+udp_requisito()
frm_parametrizarrequisitos
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+parametrizarrequisitos_Load()
+BEliminarrequisitos_Click()
+BIngresarrequisito_Click()
+CActualizarrequisito_SelectedIndexChanged()
+BIngresarrequisitos()
1
1
requisito_bd
+conexion : conexion_bd
+setrequisito()
+getrequisito()
+getrequisitoid() : requisitos
+delrequisito()
+updaterequisito()
1
1
1
<<local>>
requisitos
1
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
<<parametter>>
1
+idrequisito : String
+iddocumento : String
+idcredito : String
+formalaboral : String
+setrequisitos()
+Getiddocumento() : String
+Getidcredito() : String
+Getidrequisito() : String
+getformalaboral() : String
56
Parametrizar tipo crédito
1
creditos
<<local>>
1
+tcr : tipocredito
+tcr_bd : tipocredito_bd
+registar_tipocredito()
+gettipocredito()
+gettipocreditoid()
+del_tipocredito()
+udp_tipocredito()
1
frm_parametrizartipocredito
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+parametrizartipocredito_Load()
+BEliminarrtipocredito_Click()
+BIngresartipocredito_Click()
+CActualizartipocredito_SelectedIndexChanged()
+Bingresartipocredito()
1
1
tipocredito_bd
+conexion : conexion_bd
+settipocredito()
+gettipocredito()
+gettipocreditoid() : tipocredito
+deltipocredito()
+updatetipocredito()
1
1
1
<<local>>
tipocredito
1
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
<<parametter>>
1
+idcredito : String
+descripcion : String
+presupuesto : Double
+setrequisitos()
+Getidcredito() : String
+Getdescripcion() : String
+Getpresupuesto() : Double
57
Simular crédito e Ingresar cuotas
1
creditos
+cuo : cuotas
+cuo_bd : cuota_bd
-sim : simular credito
+registar_cuotas()
+getcuotas()
+getcuotas()
+getcuotasid()
+del_cuotas()
+udp_cuotas()
+simularcredito()
1
frm_simulacion
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+parametrizarcuotas_Load()
+BIngresarcuotas()
1
cuota_bd
1
+conexion : conexion_bd
+setcuotas()
+getcuotas()
+getcuotaid() : cuotas
+delcuota()
+updatecuota()
1
<<parametter>>
<<local>>
1
1
1
1
simular credito
1
cuotas
conexion_bd
+idcredito : String
+pago : String
+capital : Double
+interes : Double
+valcuota : Double
+saldo : Double
+mora : Double
-fecha : Date
+setcuota()
+Getidcredito() : String
+Getpago() : String
+Getcapital() : Double
+GetValcuota() : Double
+Getsaldo() : Double
+Getmora() : Double
+Getfecha() : Date
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
1
<<parametter>>
+cuota : Integer
+dias : Integer
+diasdate : Integer
+capital : Double
+interesperiodo : Double
+intreres : Double
+valcuota : Double
+saldo : Double
+mora : Double
-fechapago : Date
+simualrcredito()
1
1
1
1
tasas
tasas_bd
+conexion : conexion_bd
+settasa()
+gettasa()
+gettasaid() : tasas
+deltasa()
+updatetasa()
1
<<local>>
+idtasa : String
+descripcion : String
+valor : Double
+fecha : Date
+settasas()
+Getidtasa() : String
+Getdescripcion() : String
+Getvalor() : Double
+Getfecha() : Date
58
Parametrizar clientes
1
creditos
<<local>>
1
1
+cli : clientes
+cli_bd : cliente_bd
+registar_clientes()
+getclientes()
+getclientes()
+getclientesid()
+del_clientes()
+udp_clientes()
frm_parametrizarclientes
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+parametrizarclientes_Load()
+BIngresarclientes()
+BActualizarclientes()
+BEliminarclientes()
+CActualizarcliente_SelectedValueChanged()
1
1
cliente_bd
+conexion : conexion_bd
+setcliente()
+getcliente()
+getclienteid() : clientes
+delcliente()
+updatecliente()
1
1
<<local>>
1
1
clientes
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
<<parametter>>
1
+idcliente : String
+nombrebusqueda : String
+primernombre : String
+segundonombre : String
+primerapellido : String
+segundoapellido : String
+direccion : String
+telefono : String
+movil : String
+fax : String
+email : String
+vehiculo : String
+vivienda : String
+profesion : String
+formalaboral : String
+fechanacimiento : Date
+setcliente()
+Getidcliente() : String
+Getnombrebusqueda() : String
+getprimerapellido() : String
+getsegundoapellido() : String
+getprimernombre() : String
+getsegundonombre() : String
+getdireccion() : String
+gettelefono() : String
+getmovil() : String
+getfax() : String
+getemail() : String
+getvehiculo() : String
+getvivienda() : String
+getprofesion() : String
+getformalaboral() : String
+Getfechanacimiento() : Date
59
Registrar Créditos
1
creditos
+rcr : registrocredito
+rcr_bd : registrocredito_bd
+registrocredito()
+getregistrocredito()
+getregistrocreditoid()
+del_registrocredito()
+udp_registrocredito()
<<local>>
1
frm_registrocredito
1
1
1
registrocredito_bd
+conexion : conexion_bd
+setregistrocredito()
+getregistrocredito()
+getregistrocreditoid() : registrocredito
+delregistrocredito()
+updateregistrocredito()
+cred
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+registrocredito_Load()
+Bregistrocredito()
+BActualizarregistrocredito()
+BEliminarregistrocredito()
+Cregistrocredito_SelectedValueChanged()
1
1
registrocredito
1
<<local>>
1
<<parametter>>
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
1
+idcredito : String
+cliente : String
+nombre : String
+tasa : String
+estado : String
+tipocredito : String
+periodo : String
+formapago : String
+valorsolicitado : Integer
+valoraprobado : Integer
+numerocuotas : Integer
+fechainicial : Date
+fechafinal : Date
+fechapresupuesto : Date
+tea : Double
+setregistrarcredito()
+Getidcredito() : String
+Getformapago() : String
+Getcliente() : String
+getnombre() : String
+gettasa() : String
+getperiodo() : String
+gettipocredito() : String
+getestado() : String
+Gettea() : Double
+Getvalorsolicitado() : Integer
+Getvaloraprobado() : Integer
+getnumerocuotas() : Integer
+Getfechafinal() : Date
+Getfechainicial() : Date
+Getfechapresupuesto() : Date
60
Diagrama de clases Usuarios
frm_principal
+cred : creditos
+ClientesToolStripMenuItem_Click()
+ExamenesToolStripMenuItem_Click()
+SoliToolStripMenuItem_Click()
+ExamenesClienteToolStripMenuItem_Click()
+ConsultarExamenesPorPacienteToolStripMenuItem_Click()
+RechazarAprobarSolicitudToolStripMenuItem_Click()
+UsuariosToolStripMenuItem_Click()
+principal_FormClosed()
+ResultadosExamenesToolStripMenuItem_Click()
+ConsultarSolicitudesToolStripMenuItem_Click()
frm_Ingreso
1
1
+cred : creditos
+ingresar : Boolean
-contador : Integer
+BIngreso_Click()
1
1
creditos
1
<<local>>
1
1
+usr : usuarios
+usrbd : usuarios_bd
+registar_usuarios()
+getusuarios()
+getusuairoactivo()
+getusuarioid()
+del_clientes()
+udpactivo()
+udpactivono()
frm_usuario
1
usuarios_bd
1
+conexion : conexion_bd
+setusuario()
+getusuario()
+getusuarioid() : usuarios
+delusuario()
+updateactivo()
+updateactivoNO()
+getusuarioactivo()
<<local>>
1
<<parametter>>
1
1
usuarios
1
conexion_bd
+con : Object
+abrirconexion()
+cerraconexion()
+ejecutar()
+consultar()
+cre : creditos
+cargando : Boolean
+llenardatagrid()
+llenarcombocox()
+usuarios_Load()
+BIngresarusuario()
+BEliminarclientes()
1
+usuario : String
+nombre : String
+apellido : String
+Identificacion : String
+password : String
+perfil : String
+setusuario()
+Getusuario() : String
+Getnombre() : String
+getapellido() : String
+getidentificacion() : String
+getpassword() : String
+getperfil() : String
61
Diagramas de colaboración: Esencialmente es un diagrama que muestra
interacciones organizadas alrededor de los roles. A diferencia de los diagramas de
secuencia, los diagramas de colaboración muestran explícitamente las relaciones
de los roles. Por otra parte, un diagrama de colaboración no muestra el tiempo
como una dimensión aparte, por lo que resulta necesario etiquetar con números
de secuencia tanto la secuencia de mensajes como los hilos concurrentes.
Muestra cómo las instancias específicas de las clases trabajan juntas para
conseguir un objetivo común.
Implementa las asociaciones del diagrama de clases mediante el paso de
mensajes de un objeto a otro. Dicha implementación es llamada "enlace".
62
Diagrama de colaboración simulación del crédito
form simulacion
1.
sim
c
ula
ion
2.1. getregistrocreditoid()
Creditos
2.2
s
3. Consultar
registrarcredito
im
u
lar
c
red
it
o()
. ge
4.1
ai d
ttas
()
Conexion bd
tasasbd
simulacion
4 .3
s
2.
4.
cuotas
as
ot
cu
t
e
.s
etc
uo
tas
cuotasbd
63
Diagrama de colaboración ingreso usuarios
u
us
utar
)
d(
ioi
ar
jec
3.1. e
et
.g
2 .2
64
3.3.2 Diseño lógico
3.2.2.1
Diseño Base de Datos
3.2.2.1.1 Aspectos físicos de la base de datos
clientes
PK
registrocredito
idcliente
PK,FK1
nombrebusqueda
primernombre
segundonombre
primerapellido
segundoapellido
Direccion
telefono
movil
fax
email
vehiculo
vivienda
profesion
fechanacimiento
formalaboral
tasas
idcredito
cliente
nombrebusqueda
valorsolicitado
valoraprobado
fechapresupuesto
fechainicial
fechafinal
tipocredito
numerocuotas
periodo
tea
tasa
estado
formapago
PK
idtasa
FK1
descripcion
fecha
valor
idcredito
tipocreditos
PK,FK1
idcredito
FK2
descripcion
presupuesto
idrequisito
cuotas
usuarios
idcredito
requisitos
documentos
PK
PK
idrequisito
FK1
iddocumento
formalaboral
idcredito
iddocumento
descripcion
cantidad
PK
usuario
password
perfil
activo
nombre
apellido
identificacion
cuota
fechapago
capital
interes
valcuota
saldo
mora
pago
Entidades
Tipos de crédito
tipocreditos
PK,FK1
idcredito
FK2
descripcion
presupuesto
idrequisito
65
Clientes
Registro crédito
registrocredito
PK,FK1
idcredito
cliente
nombrebusqueda
valorsolicitado
valoraprobado
fechapresupuesto
fechainicial
fechafinal
tipocredito
numerocuotas
periodo
tea
tasa
estado
formapago
66
Cuotas
Tasas
Documentos
Requisitos
67
Usuarios
usuarios
PK
usuario
password
perfil
activo
nombre
apellido
identificacion
Tipos de datos y longitud
Clientes
idcliente
nombrebusqueda
primernombre
segundonombre
primerapellido
segundoapellido
Direccion
telefono
Móvil
Fax
Email
vehiculo
vivienda
profesion
fechanacimiento
formalaboral
char(10)
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Text
Datetime
Text
NOT NULL
NULL
NOT NULL
NULL
NOT NULL
NULL
NOT NULL
NOT NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
Cuotas
idcredito
Cuota
fechapago
capital
interes
char(10) NULL
int
NULL
datetime NULL
numeric (18, 2) NULL
numeric (18, 2) NULL
68
valcuota
Saldo
Mora
Pago
numeric
numeric
numeric
Text
(18, 2) NULL
(18, 2) NULL
(18, 2) NULL
NULL
Documentos
Iddocumento
descripcion
Cantidad
char(10)
Text
Int
NOT NULL
NULL
NOT NULL
Registrocredito
Idcredito
Cliente
Nombrebusqueda
Valorsolicitado
Valoraprobado
fechapresupuesto
Fechainicial
Fechafinal
Tipocredito
Numerocuotas
Periodo
Tea
Tasa
Estado
Formapago
char(10)
char(10)
Text
Int
Int
datetime
datetime
datetime
Text
Int
Text
Float
Text
Text
Text
NOT NULL
NOT NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
NULL
Requisitos
Idrequisito
Iddocumento
Formalaboral
Idcredito
char(10)
char(10)
text
char(10)
NOT NULL
NULL
NULL
NULL
69
Tasas
Idtasa
descripcion
Fecha
Valor
char(10)
Text
datetime
Float
NOT NULL
NULL
NULL
NOT NULL
Tipocreditos
idcredito
descripcion
presupuesto
char(10)
Text
Int
NOT NULL
NULL
NOT NULL
Usuarios
usuario
password
Perfil
Activo
nombre
apellido
identificacion
char(10)
Text
Text
char(10)
Text
Text
Text
NOT NULL
NULL
NULL
NULL
NULL
NULL
NULL
70
4. ANÁLISIS DE RESULTADOS Y CONCLUSIONES
4.1 CODIFICACIÓN DEL PROGRAMA
Es el proceso de trascripción del diseño funcional realizado en UML (Diagramas
de Casos de Usos, Diagramas de Secuencia, Diagramas de Actividades,
Diagramas de Colaboración y diagramas de Estado) a Visual Basic .NET, para la
creación de las interfaces, diseño y pruebas del monitoreo del aplicativo.
Anexo al paquete de instalación, en el CD de entrega formal, se encuentra el
código fuente de la aplicación, el instalador de SQL server 2005 Express, el script
en SQL de la base de datos y el archivo .bak para ser instalado e importado en
SQL. También se encuentra en el CD el ejecutable de la aplicación para correrlo
sin necesidad de instalar el paquete.
4.2 BANCO DE PRUEBAS
Las pruebas realizadas al desarrollo al finalizar fueron pruebas de caja negra
debido a la carencia de un agente de pruebas de funcionamiento del desarrollo y
una entidad de implementación del desarrollo, donde se harían pruebas de
integración, pero no se llego a este punto del proceso del ciclo de vida de
desarrollo de software, el formato que se muestra en las pruebas realizadas fue
facilitado por el docente Gustavo Herazo, el cual ha sido aplicado en otros
procesos de investigación y en construcción de software
[17] Las pruebas de caja negra se centran en lo que se espera de un módulo, en
intentan encontrar casos en que el módulo no se atiene a su especificación. Por
71
ello se denominan pruebas funcionales, y el encargado de las pruebas se limita a
suministrarle datos como entrada y estudiar la salida, sin preocuparse de lo que
pueda estar haciendo el módulo por dentro.
Las pruebas de caja negra están especialmente indicadas en aquellos módulos
que van a ser interfaz con el usuario.
4.2.1 Pruebas de función
Objetivo: Verificar que cada una de las funciones cumpla con el propósito para el
cual fueron diseñados.
Criterio de decisión: De acuerdo a los requerimientos internacionales que exige
el modelo del CVDS, dentro de su primera prueba de funcionalidad, exige la
verificación de la validación de los caracteres de digitación, entre ellos están las
letras, los números y los espacios en blanco en cada uno de los campos que se
consideran obligatorios en el diseño de los respectivos formularios.
PRUEBAS
SI
La función de validación de letras es correcta
X
La función de validación de números es correcta
X
La rutina de validación de espacios en blanco es correcta
X
NO
La siguiente pantalla prueba la validación de espacios en blanco, en campos que
son de carácter obligatorios para la base de datos, esta validación se está
realizando desde la aplicación, para no involucrar a la bases de datos en la
generación de mensajes de errores.
72
4.2.2 Pruebas modulares
Objetivo: Detección de errores y verificación de la integración de los menús.
Criterio de decisión: Las pruebas modulares corresponden al segundo item
mencionado en la aplicación de pruebas de la metodología del CVDS, y su función
consiste en evaluar cada una de las rutinas que se integran al todo de la
aplicación y que exista interacción adecuada con el usuario.
MENÚ APLICACIÓN
PRUEBAS
SI
NO
Se generan errores al momento de cargar un Submenú
X
Los Submenús son complejos
X
La interacción con el usuario es fácil
X
La selección de menús y submenús funciona
X
Realiza el proceso de inserción de nuevo entorno
X
Realiza el proceso de salir del entorno actual
X
73
El siguiente pantallazo muestra la funcionalidad de los menús y los submenús los
cuales son de fácil acceso al usuario y divididos según la funcionalidad a solicitar,
anexo a los submenús están un cuadro de botones que tienen un texto de ayuda
para saber a qué funcionalidad se está accediendo al hacer clic en el botón
4.2.3 Pruebas de Documentación y Ayuda
Objetivo: Verificar el contenido de la documentación, manuales y ayudas.
Criterio de decisión: Para las pruebas de documentación, igualmente se tomó la
referencia de la metodología del CVDS, en donde el código debe ser explicativo
como referencia para que el desarrollador se ubique dentro del entorno del análisis
74
de las variables y etiquetas que se muevan en la aplicación. Así mismo denota la
inclusión de manuales y demás soportes escritos que ayuden a la interpretación
del conocimiento del software. Los nombres de las variables deben ser
significativos, dentro de la acción que ejecuta dentro del proceso del caso de uso
que se está generando.
PRUEBAS
SI
Existe una documentación interna (código)
X
Los nombres de las variables y etiquetas son significativas
X
Los comentarios son fáciles de entender
X
Existe una documentación externa
X
La ayuda es fácil de entender y manejar
X
NO
4.2.4 Pruebas de Seguridad y Control
Objetivo: Verificación del control de acceso, validación de información y la
realización correcta de las acciones sobre la aplicación.
PRUEBAS
SI
Existe perfiles de usuario para el funcionamiento del sistema
X
Solicita contraseña al ingresar a la aplicación
X
NO
4.2.5 Pruebas de Calidad
Objetivo: Verificar la capacidad operativa y de adaptación a los cambios en la
aplicación.
75
PRUEBAS
SI
Existe portabilidad
NO
X
El código es reutilizable
X
Existe integridad
X
Es fácil de utilizar
X
4.3 INFORME DE PRUEBAS
Objetivos
•
Comprobar la validación de información.
•
Comprobar la lógica de la aplicación
•
Comprobar el nivel de integración de los menús.
•
Probar el manejo de errores.
76
Material revisado
Formulario principal
Menú configuración
Menú de consultar
77
Menú registro
Menú reportes
Formulario parametrizar tasas
78
Parametrizar documentos
Parametrizar tipos de crédito
79
Parametrizar requisitos
Parametrizar clientes
80
Registrar créditos
Ejecutar simulación
81
Consultar cuotas
82
5. CONCLUSIONES
Es bastante gratificante a nivel personal, realizar un proyecto de investigación
descriptiva con un tema de gran magnitud como lo es el manejo de tasas de
interés y poder crear una aplicación que puede suplir las necesidades principales
del proceso de cálculo y amortización de créditos a nivel financiero.
Para todo tipo de proyecto de desarrollo de software es fundamental trabajar con
metodologías que estén enfocadas desarrollar con ciertos patrones para realizar
un código más estructurado y fácil de utilizar, lo cual se vio plasmado en el
desarrollo al implementar el patrón “modelo, vista controlador” y aunque es mayor
las líneas de código que son necesarias en el modelo, este trabajo se ve
compensado al crear la vista y al tener la intensión de crear nueva funcionalidad o
da la opción de abordar un problema desde diferentes posibles soluciones sin
necesidad de implementar gran cantidad de código.
Es poco el software y las aplicaciones que en Colombia existen para manipular
créditos a nivel financiero, que esté al alcance de cualquier tipo de usuario, en
este momento es más utilizado en bancos y entidades de grandes magnitudes,
donde tienen este software al cual es creado a las necesidades de la entidad, por
diversas casas de software.
La normatividad que existe en el momento con respecto a créditos va enfocada a
entidades del gobierno y a tipos de crédito específicos, las cuales hasta el
momento no especifica cómo es la estructura y los pasos a seguir para la solicitud
de créditos por parte de las personas que lo soliciten y tampoco contempla
normatividad para quienes lo otorgan, este normas son internas de cada
institución, según la entidad y las personas que la conforman.
El uso de UML como lenguaje de modelado es fundamental en todo proyecto de
desarrollo de software, ya que colabora con la documentación y construcción de
los objetos que conforman un sistema de información como el del presente
83
proyecto, con estos modelos se puede dar continuidad al proyecto sin necesidad
que el desarrollador sea la misma persona, sino que puede llegar una persona
nueva que teniendo los modelos como base podrá seguir con el trabajo realizado.
Las herramientas de trabajo Visual Basic .NET 2005 y SQL server 2005 Express,
se interrelacionan y complementan bien en el desarrollo de proyectos de software,
generando confianza en el proceso de construcción, existe buena documentación
con respecto a ambas en Internet y por parte de Microsoft, son de fácil uso y
manejo, el reporte de errores y al documentación de ellos es bastante buena y
hace que el trabajo del desarrollador sea ágil al encontrar solución rápida y
oportuna a los inconvenientes que se puedan presentar.
84
6 RECOMENDACIONES
Si se desea dar continuidad al proyecto se pueden tener las siguientes
consideraciones:
• El software podría ser mejorado, abarcando el tema de pagos, en el
momento se puede realizar un tipo de pago completo de la cuota.
• Funcionalidad de congelamiento de los créditos.
• Gestionar con una entidad bancaria, los pagos a este banco y que el banco
los reporte a través de archivos planos, los cuales puedan ser ingresados al
sistema y que el sistema actualice los pagos.
• El usuario pueda consultar su estado de crédito a través de internet,
implementando está funcionalidad en ASP.NET, ya que las clases del
proyectos seria utilizables con este lenguaje.
• Debido a que la base de datos se trabaja a nivel de código y no con objetos
de visual Basic, y también a través de sentencias SQL, que son de
estándares en bases de datos, poder ejecutar la aplicación con diversas
bases de datos según el gusto del usuario.
85
BIBLIOGRAFÍA
[1] Introduccion a UML 2.0. Dsponible:
http://www.epidataconsulting.com/tikiwiki/tiki-read_article.php?articleId=15 [Citado
Mayo 3 de 2008]
[2] Patrón "Modelo-Vista-Controlador". Disponible: http://www.proactivacalidad.com/java/patrones/mvc.html [Citado Mayo 3 de 2008]
[3] Una breve historia de las tasas de interés Disponible:
http://www.monografias.com/trabajos24/tasas-de-interes/tasas-de-interes.shtml
[Citado Abril 5 de 2008]
[4] Legislación Financiera Disponible.
http://www.asobancaria.com/categorias.jsp?id=147&sup=2 [Citado Mayo 10 de
2008]
[5] LEY 510 DE 1999. Disponible:
http://web.minjusticia.gov.co/normas/1999/l5101999.htm [Citado Mayo 10 de 2008]
[6] LEY 550 DE 1999. Disponible:
http://web.minjusticia.gov.co/normas/1999/l5501999.htm [Citado Mayo 10 de 2008]
[9] CreditWin Profesional (CreditWin Pro) 1.0. Disponible:
http://www.freedownloadmanager.org/es/downloads/disputa_de_cr%C3%A9dito_g
ratis [Citado Mayo 17 de 2008]
[10] LoanSpread Loan Calculator 4.6.0. Disponible:
http://www.freedownloadscenter.com/es/Negocio/Herramientas_Financieras_Varia
s/LoanSpread_Loan_Calculator.html [Citado Mayo 17 de 2008]
[11] Definición de crédito documentario. Disponible
http://www.proyectosfindecarrera.com/definicion/credito-documentario.htm [Citado
Mayo 17 de 2008]
86
[12] Que es amortización. Disponible:
http://www.businesscol.com/foros/index.php?topic=2797 [Citado Mayo 17 de 2008]
[13] Panorama de SQL Server 2005 Express Edition. Disponible:
http://www.microsoft.com/spanish/msdn/articulos/archivo/100904/voices/10Panora
maSQLServer2005ExpressEdition.mspx [Citado Mayo 17 de 2008]
[14] Introducción a Visual Studio. Disponible: http://msdn.microsoft.com/eses/library/fx6bk1f4(VS.80).aspx [Citado Mayo 17 de 2008]
[15] Visual Basic. Disponible: http://msdn.microsoft.com/eses/library/2x7h1hfk(VS.80).aspx [Citado Mayo 17 de 2008]
[16] Business Process Management. Disponible:
http://es.wikipedia.org/wiki/Business_Process_Management [Citado Mayo 24 de
2008]
[17] Prueba de programas. Disponible:
http://www.lab.dit.upm.es/~lprg/material/apuntes/pruebas/testing.htm#s22 [Citado
Mayo 31 de 2008]
87
ANEXOS
88
Código fuente
Cliente
Public Class cliente
Dim idcliente, nombrebusqueda, primernombre, segundonombre,
primerapellido, segundoapellido, direccion, telefono, movil, fax, email,
vehiculo, vivienda, profesion, formalaboral As String
Dim fechanacimiento As Date
Public Sub setcliente(ByVal idc As String, ByVal nom As String, ByVal
prn As String, ByVal segn As String, ByVal pra As String, ByVal sega As
String, ByVal dir As String, ByVal tel As String, ByVal mov As String,
ByVal fax As String, ByVal ema As String, ByVal veh As String, ByVal viv
As String, ByVal pro As String, ByVal fla As String, ByVal fec As Date)
idcliente = idc
nombrebusqueda = nom
primernombre = prn
segundonombre = segn
primerapellido = pra
segundoapellido = sega
direccion = dir
telefono = tel
movil = mov
fax = fax
email = ema
vehiculo = veh
vivienda = viv
profesion = pro
formalaboral = fla
fechanacimiento = fec
End Sub
Public Function Getidcliente() As String
Getidcliente = idcliente
End Function
Public Function Getnombrebusqueda() As String
Getnombrebusqueda = nombrebusqueda
End Function
Public Function getprimerapellido() As String
getprimerapellido = primerapellido
End Function
Public Function getsegundoapellido() As String
getsegundoapellido = segundoapellido
End Function
Public Function getprimernombre() As String
getprimernombre = primernombre
End Function
Public Function getsegundonombre() As String
getsegundonombre = segundonombre
End Function
Public Function getdireccion() As String
getdireccion = direccion
End Function
Public Function gettelefono() As String
gettelefono = telefono
End Function
89
Public Function getmovil() As String
getmovil = movil
End Function
Public Function getfax() As String
getfax = fax
End Function
Public Function getemail() As String
getemail = email
End Function
Public Function getvehiculo() As String
getvehiculo = vehiculo
End Function
Public Function getvivienda() As String
getvivienda = vivienda
End Function
Public Function getprofesion() As String
getprofesion = profesion
End Function
Public Function getformalaboral() As String
getformalaboral = formalaboral
End Function
Public Function Getfechanacimiento() As Date
Getfechanacimiento = fechanacimiento
End Function
End Class
Clientebd
Public Class cliente_bd
Dim conexion As New conexion_bd
Public Sub setrcliente(ByVal cli As cliente)
Dim insert_sql As String
Dim tfec, feci As String
Try
If (cli.Getidcliente = "") Then
Throw New Exception("Debe ingresar el id del cliente")
End If
If (cli.getprimerapellido = "") Then
Throw New Exception("Debe ingresar el primer apellido del
cliente")
End If
If (cli.getprimernombre = "") Then
Throw New Exception("Debe ingresar el primer nombre del
cliente")
End If
tfec = cli.Getfechanacimiento.Date.ToString()
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
insert_sql = "insert into clientes(idcliente, nombrebusqueda,
primernombre, segundonombre, primerapellido, segundoapellido, direccion,
telefono, movil, fax, email, vehiculo, vivienda, profesion,
formalaboral,fechanacimiento) values('"
insert_sql = insert_sql & cli.Getidcliente & "','" &
cli.Getnombrebusqueda & "','" & cli.getprimernombre & "','" &
cli.getsegundonombre & "','" & cli.getprimerapellido & "','" &
90
cli.getsegundoapellido & "','" & cli.getdireccion & "','" &
cli.gettelefono & "','" & cli.getmovil & "','" & cli.getfax & "','" &
cli.getemail & "','" & cli.getvehiculo & "','" & cli.getvivienda & "','"
& cli.getprofesion & "','" & cli.getformalaboral & "','" & feci & "')"
conexion.ejecutar(insert_sql)
MessageBox.Show("El cliente ha sido ingresado")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getcliente() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from clientes"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getclienteid(ByVal idc As String) As cliente
Dim objalma As New DataSet()
Dim cl As New cliente
Dim select_sql As String
Try
select_sql = "select * from clientes where idcliente = '" &
idc & "'"
objalma = conexion.consultar(select_sql)
cl.setcliente(objalma.Tables("tabla").Rows(0).Item("idcliente"),
objalma.Tables("tabla").Rows(0).Item("nombrebusqueda"),
objalma.Tables("tabla").Rows(0).Item("primernombre"),
objalma.Tables("tabla").Rows(0).Item("segundonombre"),
objalma.Tables("tabla").Rows(0).Item("primerapellido"),
objalma.Tables("tabla").Rows(0).Item("segundoapellido"),
objalma.Tables("tabla").Rows(0).Item("direccion"),
objalma.Tables("tabla").Rows(0).Item("telefono"),
objalma.Tables("tabla").Rows(0).Item("movil"),
objalma.Tables("tabla").Rows(0).Item("fax"),
objalma.Tables("tabla").Rows(0).Item("email"),
objalma.Tables("tabla").Rows(0).Item("vehiculo"),
objalma.Tables("tabla").Rows(0).Item("vivienda"),
objalma.Tables("tabla").Rows(0).Item("profesion"),
objalma.Tables("tabla").Rows(0).Item("formalaboral"),
objalma.Tables("tabla").Rows(0).Item("fechanacimiento"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return cl
End Function
Public Sub delcliente(ByVal idc As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
91
delete_sql = "delete from clientes where idcliente = '" & idc
& "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updatecliente(ByVal cli As cliente)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Dim tfec, feci As String
Try
If (cli.Getidcliente = "") Then
Throw New Exception("Debe ingresar el id del cliente")
End If
If (cli.getprimerapellido = "") Then
Throw New Exception("Debe ingresar el primer apellido del
cliente")
End If
If (cli.getprimernombre = "") Then
Throw New Exception("Debe ingresar el primer nombre del
cliente")
End If
tfec = cli.Getfechanacimiento.Date.ToString()
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
update_sql = "update clientes set idcliente = '" &
cli.Getidcliente & "',nombrebusqueda = '" & cli.Getnombrebusqueda &
"',primernombre = '" & cli.getprimernombre & "',primerapellido = '" &
cli.getprimerapellido & "',segundoapellido = '" & cli.getsegundoapellido
& "',direccion = '" & cli.getdireccion & "',telefono = '" &
cli.gettelefono & "',movil = '" & cli.getmovil & "',fax = '" & cli.getfax
& "',email = '" & cli.getemail & "',vehiculo = '" & cli.getvehiculo &
"',vivienda = '" & cli.getvivienda & "',profesion = '" & cli.getprofesion
& "',fechanacimiento = '" & feci & "',formalaboral = '" &
cli.getformalaboral & "' where idcliente = '" & cli.Getidcliente & "'"
conexion.ejecutar(update_sql)
MessageBox.Show("El cliente ha sido actualizado")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
Cuota
Public Class cuota
Dim idcredito, pago As String
Dim cuota As Integer
Dim capital, interes, valcuota, saldo, mora As Double
Dim fechapago As Date
92
Public Sub setcuotas(ByVal idc As String, ByVal pag As String, ByVal
cuo As Integer, ByVal cap As Double, ByVal int As Double, ByVal vcuo As
Double, ByVal sal As Double, ByVal fec As Date)
idcredito = idc
pago = pag
cuota = cuo
capital = cap
interes = int
saldo = sal
valcuota = vcuo
fechapago = fec
End Sub
Public Function Getidcredito() As String
Getidcredito = idcredito
End Function
Public Function Getcuota() As Integer
Getcuota = cuota
End Function
Public Function getpago() As String
getpago = pago
End Function
Public Function getsaldo() As Double
getsaldo = saldo
End Function
Public Function Getcapital() As Double
Getcapital = capital
End Function
Public Function getinteres() As Double
getinteres = interes
End Function
Public Function Getvalcuota() As Double
Getvalcuota = valcuota
End Function
Public Function Getfechapago() As Date
Getfechapago = fechapago
End Function
End Class
Cuotabd
Public Class cuotas_bd
Dim conexion As New conexion_bd
Public Sub setcuota(ByVal cuo As cuota)
Dim insert_sql As String
Dim tfec, feci As String
Try
tfec = cuo.Getfechapago.Date.ToString()
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
insert_sql = "insert into
cuotas(idcredito,cuota,fechapago,capital,interes,valcuota,saldo,pago)
values('" & cuo.Getidcredito & "'," & cuo.Getcuota & ",'" & feci & "'," &
cuo.Getcapital & "," & cuo.getinteres & "," & cuo.Getvalcuota & "," &
cuo.getsaldo & ",'" & cuo.getpago & "')"
conexion.ejecutar(insert_sql)
93
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getcuotas() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from cuotas"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getcuotascredito(ByVal idc As String) As DataSet
Dim objalma As New DataSet()
Dim select_sql As String
Try
select_sql = "select * from cuotas where idcredito = '" & idc
& "'"
objalma = conexion.consultar(select_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return objalma
End Function
Public Function getcuotascreditoSinpago(ByVal idc As String) As
DataSet
Dim objalma As New DataSet()
Dim select_sql As String
Try
select_sql = "select * from cuotas where idcredito = '" & idc
& "' AND pago = 'NO'"
objalma = conexion.consultar(select_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return objalma
End Function
Public Sub delcredito(ByVal idc As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
delete_sql = "delete from cuotas where idcredito = '" & idc &
"'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub pagarcuota(ByVal id As String, ByVal cuo As Integer)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
94
Try
update_sql = "update cuotas set pago = 'SI' where idcredito =
'" & id & "'and cuota = " & cuo
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
documentos
Public Class documentos
Dim iddocumento, descripcion As String
Dim cantidad As Integer
Public Sub setdocumentos(ByVal idd As String, ByVal des As String,
ByVal can As Integer)
iddocumento = idd
descripcion = des
cantidad = can
End Sub
Public Function Getiddocumento() As String
Getiddocumento = iddocumento
End Function
Public Function Getdescripcion() As String
Getdescripcion = descripcion
End Function
Public Function Getcantidad() As Integer
Getcantidad = cantidad
End Function
End Class
Documentosbd
Public Class documentos_bd
Dim conexion As New conexion_bd
Public Sub setdocumento(ByVal doc As documentos)
Dim insert_sql As String
Try
If (doc.Getiddocumento = "") Then
Throw New Exception("Debe ingresar el id del documento")
End If
If (doc.Getcantidad >= 0) Then
Throw New Exception("Debe ingresar la cantidad de
documentos a solicitar")
End If
insert_sql = "insert into
documentos(iddocumento,descripcion,cantidad) values('" &
doc.Getiddocumento & "','" & doc.Getdescripcion & "'," & doc.Getcantidad
& ")"
conexion.ejecutar(insert_sql)
95
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getdocumentos() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from documentos"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getdocumentosid(ByVal idd As String) As documentos
Dim objalma As New DataSet()
Dim docu As New documentos
Dim select_sql As String
Try
select_sql = "select * from documentos where iddocumento = '"
& idd & "'"
objalma = conexion.consultar(select_sql)
docu.setdocumentos(objalma.Tables("tabla").Rows(0).Item("iddocumento"),
objalma.Tables("tabla").Rows(0).Item("descripcion"),
objalma.Tables("tabla").Rows(0).Item("cantidad"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return docu
End Function
Public Sub updatedocumentos(ByVal doc As documentos)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If (doc.Getiddocumento = "") Then
Throw New Exception("Debe ingresar el id del documento")
End If
If (doc.Getcantidad = 0) Then
Throw New Exception("Debe ingresar la cantidad de
documentos a solicitar")
End If
update_sql = "update documentos set iddocumento = '" &
doc.Getiddocumento & "',descripcion = '" & doc.Getdescripcion &
"',cantidad = " & doc.Getcantidad & "where iddocumento = '" &
doc.Getiddocumento & "'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub deldocumentos(ByVal idd As String)
Dim objconexion As New OleDb.OleDbCommand
96
Dim delete_sql As String
Try
delete_sql = "delete from documentos where iddocumento = '" &
idd & "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
Registrocredito
Public Class registrocredito
Dim idcredito, cliente, nombre, tasa, estado, tipocredito, periodo,
formapago As String
Dim valorsolicitado, valoraprobado, numerocuotas As Integer
Dim tea As Double
Dim fechainicial, fechafinal, fechapresupuesto As Date
Public Sub setregitrocredito(ByVal idc As String, ByVal cli As
String, ByVal nom As String, ByVal tas As String, ByVal est As String,
ByVal tcr As String, ByVal per As String, ByVal vap As Integer, ByVal vso
As Integer, ByVal ncu As Integer, ByVal te As Double, ByVal fin As Date,
ByVal ffi As Date, ByVal fpr As Date, ByVal fpa As String)
formapago = fpa
idcredito = idc
cliente = cli
nombre = nom
tasa = tas
estado = est
tipocredito = tcr
periodo = per
valorsolicitado = vso
valoraprobado = vap
numerocuotas = ncu
tea = te
fechainicial = fin
fechafinal = ffi
fechapresupuesto = fpr
End Sub
Public Function Getformapago() As String
Getformapago = formapago
End Function
Public Function Getidcredito() As String
Getidcredito = idcredito
End Function
Public Function Getcliente() As String
Getcliente = cliente
End Function
Public Function getnombre() As String
getnombre = nombre
End Function
Public Function gettasa() As String
97
gettasa = tasa
End Function
Public Function getperiodo() As String
getperiodo = periodo
End Function
Public Function gettipocredito() As String
gettipocredito = tipocredito
End Function
Public Function getestado() As String
getestado = estado
End Function
Public Function Gettea() As Double
Gettea = tea
End Function
Public Function getvalorsolicitado() As Integer
getvalorsolicitado = valorsolicitado
End Function
Public Function getvaloraprobado() As Integer
getvaloraprobado = valoraprobado
End Function
Public Function Getnumerocuotas() As Integer
Getnumerocuotas = numerocuotas
End Function
Public Function Getfechafinal() As Date
Getfechafinal = fechafinal
End Function
Public Function Getfechainicial() As Date
Getfechainicial = fechainicial
End Function
Public Function Getfechapresupuesto() As Date
Getfechapresupuesto = fechapresupuesto
End Function
End Class
Registrocredito_bd
Public Class registrocredito_bd
Dim conexion As New conexion_bd
Public Sub setregistrocredito(ByVal rcr As registrocredito)
Dim insert_sql As String
Dim tfecini, fecini, tfecfin, fecfin, tfecpr, fecpr As String
Try
If (rcr.Getidcredito = "") Then
Throw New Exception("Debe ingresar el identificador del
credito")
End If
If (rcr.getperiodo = "") Then
Throw New Exception("Debe selecionar un periodo de pago")
End If
If (rcr.Getformapago = "") Then
Throw New Exception("Debe seleccionar una forma de pago")
End If
tfecini = rcr.Getfechainicial.Date.ToString()
98
fecini = Mid(tfecini, 7, 4) & Mid(tfecini, 4, 2) &
Mid(tfecini, 1, 2)
tfecfin = rcr.Getfechafinal.Date.ToString()
fecfin = Mid(tfecfin, 7, 4) & Mid(tfecfin, 4, 2) &
Mid(tfecfin, 1, 2)
tfecpr = rcr.Getfechapresupuesto.Date.ToString()
fecpr = Mid(tfecpr, 7, 4) & Mid(tfecpr, 4, 2) & Mid(tfecpr,
1, 2)
insert_sql = "insert into registrocredito(idcredito, cliente,
nombrebusqueda, tasa, estado, tipocredito, periodo,valorsolicitado,
valoraprobado, numerocuotas,tea,fechainicial, fechafinal,
fechapresupuesto,formapago) values('"
insert_sql = insert_sql & rcr.Getidcredito & "','" &
rcr.Getcliente & "','" & rcr.getnombre & "','" & rcr.gettasa & "','" &
rcr.getestado & "','" & rcr.gettipocredito & "','" & rcr.getperiodo &
"'," & rcr.getvalorsolicitado & "," & rcr.getvaloraprobado & "," &
rcr.Getnumerocuotas & "," & rcr.Gettea & ",'" & fecini & "','" & fecfin &
"','" & fecpr & "','" & rcr.Getformapago & "')"
conexion.ejecutar(insert_sql)
MessageBox.Show("El crédito ha sido creadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getregistrocredito() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from registrocredito"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getregistrocreditoid(ByVal idc As String) As
registrocredito
Dim objalma As New DataSet()
Dim rcre As New registrocredito
Dim select_sql As String
Try
select_sql = "select * from registrocredito where idcredito =
'" & idc & "'"
objalma = conexion.consultar(select_sql)
rcre.setregitrocredito(objalma.Tables("tabla").Rows(0).Item("idcredito"),
objalma.Tables("tabla").Rows(0).Item("cliente"),
objalma.Tables("tabla").Rows(0).Item("nombrebusqueda"),
objalma.Tables("tabla").Rows(0).Item("tasa"),
objalma.Tables("tabla").Rows(0).Item("estado"),
objalma.Tables("tabla").Rows(0).Item("tipocredito"),
objalma.Tables("tabla").Rows(0).Item("periodo"),
objalma.Tables("tabla").Rows(0).Item("valoraprobado"),
objalma.Tables("tabla").Rows(0).Item("valorsolicitado"),
objalma.Tables("tabla").Rows(0).Item("numerocuotas"),
objalma.Tables("tabla").Rows(0).Item("tea"),
objalma.Tables("tabla").Rows(0).Item("fechainicial"),
99
objalma.Tables("tabla").Rows(0).Item("fechafinal"),
objalma.Tables("tabla").Rows(0).Item("fechapresupuesto"),
objalma.Tables("tabla").Rows(0).Item("formapago"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return rcre
End Function
Public Sub delcredito(ByVal idc As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
delete_sql = "delete from registrocredito where idcredito =
'" & idc & "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub cambiarestado(ByVal id As String, ByVal est As String)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If (est = "") Then
Throw New Exception("Debe selecionar un estado")
End If
update_sql = "update registrocredito set estado = '" & est &
"' where idcredito = '" & id & "'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
If (ex.Message = "1") Then
End If
conexion.cerraconexion()
End Try
End Sub
Public Sub cambiarfechafinalpago(ByVal id As String, ByVal fec As
Date)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Dim tfec, feci As String
Try
tfec = fec
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
update_sql = "update registrocredito set fechafinal = '" &
feci & "' where idcredito = '" & id & "'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
100
End Class
Requisitos
Public Class requisitos
Dim iddocumento, formalaboral, idcredito, idrequisito As String
Public Sub setdrequisitos(ByVal idr As String, ByVal idd As String,
ByVal forl As String, ByVal idc As String)
iddocumento = idd
formalaboral = forl
idcredito = idc
idrequisito = idr
End Sub
Public Function getidrequisito() As String
getidrequisito = idrequisito
End Function
Public Function Getiddocumento() As String
Getiddocumento = iddocumento
End Function
Public Function Getformalaboral() As String
Getformalaboral = formalaboral
End Function
Public Function Getidcredito() As String
Getidcredito = idcredito
End Function
End Class
requisitosbd
Public Class requisitos_bd
Dim conexion As New conexion_bd
Public Sub setrequisitos(ByVal req As requisitos)
Dim insert_sql As String
Try
If (req.getidrequisito = "") Then
Throw New Exception("Debe ingresar el identificador del
requisito")
End If
insert_sql = "insert into
requisitos(idrequisito,iddocumento,formalaboral,idcredito) values('" &
req.getidrequisito & "','" & req.Getiddocumento & "','" &
req.Getformalaboral & "','" & req.Getidcredito & "')"
conexion.ejecutar(insert_sql)
MessageBox.Show("El requisito ha sido creadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getrequisitos() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from requisitos"
101
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getrequisitosid(ByVal idr As String) As requisitos
Dim objalma As New DataSet()
Dim req As New requisitos
Dim select_sql As String
Try
select_sql = "select * from requisitos where idrequisito = '"
& idr & "'"
objalma = conexion.consultar(select_sql)
req.setdrequisitos(objalma.Tables("tabla").Rows(0).Item("idrequisito"),
objalma.Tables("tabla").Rows(0).Item("iddocumento"),
objalma.Tables("tabla").Rows(0).Item("formalaboral"),
objalma.Tables("tabla").Rows(0).Item("idcredito"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return req
End Function
Public Function getrequisitosidcredito(ByVal idc As String) As
DataSet
Dim objalma As New DataSet()
Dim docu As New documentos
Dim select_sql As String
Try
select_sql = "select * from requisitos where idcredito = '" &
idc & "'"
objalma = conexion.consultar(select_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return objalma
End Function
Public Sub delrequisitos(ByVal idr As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
delete_sql = "delete from requisitos where idrequisito = '" &
idr & "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updaterequisito(ByVal req As requisitos)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If (req.getidrequisito = "") Then
102
Throw New Exception("Debe ingresar el identificador del
requisito")
End If
update_sql = "update requisitos set idrequisito = '" &
req.getidrequisito & "',idcredito = '" & req.Getidcredito &
"',iddocumento = '" & req.Getiddocumento & "',formalaboral = '" &
req.Getformalaboral & "' where idrequisito = '" & req.getidrequisito &
"'"
conexion.ejecutar(update_sql)
MessageBox.Show("El requisito ha sido actualizadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
Tasas
Public Class tasas
Dim idtasa, descripcion As String
Dim valor As Double
Dim fecha As Date
Public Sub settasas(ByVal idt As String, ByVal des As String, ByVal
val As Double, ByVal fec As Date)
idtasa = idt
descripcion = des
valor = val
fecha = fec
End Sub
Public Function Getidtasa() As String
Getidtasa = idtasa
End Function
Public Function Getdescripcion() As String
Getdescripcion = descripcion
End Function
Public Function Getvalor() As Double
Getvalor = valor
End Function
Public Function Getfecha() As Date
Getfecha = fecha
End Function
End Class
Tasasbd
Public Class tasa_bd
Dim conexion As New conexion_bd
Public Sub settasa(ByVal tas As tasas)
Dim insert_sql As String
Dim tfec, feci As String
Try
If (tas.Getidtasa = "") Then
103
Throw New Exception("Debe ingresar el identificador de la
tasa")
End If
tfec = tas.Getfecha.Date.ToString()
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
insert_sql = "insert into
tasas(idtasa,descripcion,fecha,valor) values('" & tas.Getidtasa & "','" &
tas.Getdescripcion & "','" & feci & "'," & tas.Getvalor & ")"
conexion.ejecutar(insert_sql)
MessageBox.Show("la tasa de interés ha sido creadá")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function gettasa() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from tasas"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function gettasaid(ByVal idt As String) As tasas
Dim objalma As New DataSet
Dim tasa As New tasas
Dim select_sql As String
Try
select_sql = "select * from tasas where idtasa = '" & idt &
"'"
objalma = conexion.consultar(select_sql)
tasa.settasas(objalma.Tables("tabla").Rows(0).Item("idtasa"),
objalma.Tables("tabla").Rows(0).Item("descripcion"),
objalma.Tables("tabla").Rows(0).Item("valor"),
objalma.Tables("tabla").Rows(0).Item("fecha"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return tasa
End Function
Public Sub deltasa(ByVal idt As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
delete_sql = "delete from tasas where idtasa = '" & idt & "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updatetasa(ByVal tas as tasas)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
104
Dim tfec, feci As String
Try
If (tas.Getidtasa = "") Then
Throw New Exception("Debe ingresar el identificador de la
tasa")
End If
If (tas.Getvalor > 100) Then
Throw New Exception("Debe valor de la tasa no puede
superar el 100%")
End If
If (tas.Getvalor < 0) Then
Throw New Exception("Debe valor de la tasa no puede ser
menor a 0 (CERO)")
End If
tfec = tas.Getfecha.Date.ToString()
feci = Mid(tfec, 7, 4) & Mid(tfec, 4, 2) & Mid(tfec, 1, 2)
update_sql = "update tasas set idtasa = '" & tas.Getidtasa &
"',descripcion = '" & tas.Getdescripcion & "',valor = " & tas.Getvalor &
",fecha = '" & feci & "' where idtasa = '" & tas.Getidtasa & "'"
conexion.ejecutar(update_sql)
MessageBox.Show("la tasa de interés ha sido actualizadá")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
Tipocredito
Public Class tipocredito
Dim idcredito, descripcion As String
Dim presupuesto As Double
Public Sub settipocredito(ByVal idc As String, ByVal des As String,
ByVal pre As Double)
idcredito = idc
descripcion = des
presupuesto = pre
End Sub
Public Function Getidtipocredito() As String
Getidtipocredito = idcredito
End Function
Public Function Getdescripcion() As String
Getdescripcion = descripcion
End Function
Public Function Getpresupuesto() As Double
Getpresupuesto = presupuesto
End Function
End Class
Tipocreditobd
Public Class tipocredito_bd
105
Dim conexion As New conexion_bd
Public Sub settipocredito(ByVal tcre As tipocredito)
Dim insert_sql As String
Try
If (tcre.Getidtipocredito = "") Then
Throw New Exception("Debe ingresar el id del tipo de
credito")
End If
insert_sql = "insert into
tipocreditos(idcredito,descripcion,presupuesto) values('" &
tcre.Getidtipocredito & "','" & tcre.Getdescripcion & "'," &
tcre.Getpresupuesto & ")"
conexion.ejecutar(insert_sql)
MessageBox.Show("El tipo de crédito ha sido creadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
End Try
End Sub
Public Function gettipocredito() As DataSet
Dim objalma As DataSet
Dim select_sql As String
select_sql = "select * from tipocreditos"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function gettipocreditoid(ByVal idc As String) As tipocredito
Dim objalma As New DataSet
Dim tcre As New tipocredito
Dim select_sql As String
Try
select_sql = "select * from tipocreditos where idcredito = '"
& idc & "'"
objalma = conexion.consultar(select_sql)
tcre.settipocredito(objalma.Tables("tabla").Rows(0).Item("idcredito"),
objalma.Tables("tabla").Rows(0).Item("descripcion"),
objalma.Tables("tabla").Rows(0).Item("presupuesto"))
Catch ex As Exception
MessageBox.Show(ex.Message)
End Try
Return tcre
End Function
Public Sub deltipocredito(ByVal idc As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
Try
delete_sql = "delete from tipocreditos where idcredito = '"
& idc & "'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
End Try
End Sub
Public Sub updattipocredito(ByVal cre As tipocredito)
106
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If (cre.Getidtipocredito = "") Then
Throw New Exception("Debe ingresar el id del tipo de
credito")
End If
update_sql = "update tipocreditos set idcredito = '" &
cre.Getidtipocredito & "',descripcion = '" & cre.Getdescripcion &
"',presupuesto = " & cre.Getpresupuesto & " where idcredito = '" &
cre.Getidtipocredito & "'"
conexion.ejecutar(update_sql)
MessageBox.Show("El tipo de crédito ha sido actualizadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updatepresupuesto(ByVal cre As tipocredito, ByVal val As
Double)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If (cre.Getidtipocredito = "") Then
Throw New Exception("Debe ingresar el id del tipo de
credito")
End If
update_sql = "update tipocreditos set presupuesto = " & val &
" where idcredito = '" & cre.Getidtipocredito & "'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
End Class
Usuario
Public Class usuario
Dim usuario, password, perfil, activo, nombre, apellido,
identificacion As String
Public Sub setusuario(ByVal usr As String, ByVal pas As String, ByVal
per As String, ByVal act As String, ByVal nom As String, ByVal ape As
String, ByVal iden As String)
usuario = usr
password = pas
perfil = per
activo = act
nombre = nom
apellido = ape
identificacion = iden
End Sub
107
Public Function Getusuario() As String
Getusuario = usuario
End Function
Public Function getpassword() As String
getpassword = password
End Function
Public Function getperfil() As String
getperfil = perfil
End Function
Public Function getactivo() As String
getactivo = activo
End Function
Public Function getapellido() As String
getapellido = apellido
End Function
Public Function getnombre() As String
getnombre = nombre
End Function
Public Function getidentificacion() As String
getidentificacion = identificacion
End Function
End Class
usuariobd
Public Class usuario_bd
Dim conexion As New conexion_bd
Public Sub setrusuario(ByVal usr As usuario)
Dim insert_sql As String
Try
If (usr.Getusuario = "") Then
Throw New Exception("Debe ingresar el usuario")
End If
If (usr.getpassword = "") Then
Throw New Exception("Debe ingresar la contraseña")
End If
If (usr.getperfil = "") Then
Throw New Exception("Debe seleccionar un perfil")
End If
insert_sql = "insert into usuarios(usuario, password, perfil,
activo, nombre, apellido, identificacion) values('" & usr.Getusuario &
"','" & usr.getpassword & "','" & usr.getperfil & "','" & usr.getactivo &
"','" & usr.getnombre & "','" & usr.getapellido & "','" &
usr.getidentificacion & "')"
conexion.ejecutar(insert_sql)
MessageBox.Show("El usuario ha sido creadó")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Function getusuario() As DataSet
Dim objalma As DataSet
Dim select_sql As String
108
select_sql = "select * from usuarios"
objalma = conexion.consultar(select_sql)
Return objalma
End Function
Public Function getusuarioid(ByVal idc As String) As usuario
Dim objalma As New DataSet()
Dim cl As New usuario
Dim select_sql As String
Try
select_sql = "select * from usuarios where usuario = '" & idc
& "'"
objalma = conexion.consultar(select_sql)
cl.setusuario(objalma.Tables("tabla").Rows(0).Item("usuario"),
objalma.Tables("tabla").Rows(0).Item("password"),
objalma.Tables("tabla").Rows(0).Item("perfil"),
objalma.Tables("tabla").Rows(0).Item("activo"),
objalma.Tables("tabla").Rows(0).Item("nombre"),
objalma.Tables("tabla").Rows(0).Item("apellido"),
objalma.Tables("tabla").Rows(0).Item("identificacion"))
Catch ex As Exception
If StrComp(cl.Getusuario, "", CompareMethod.Binary) = 0 Then
MessageBox.Show("El usuario no existe")
Else
MessageBox.Show(ex.Message)
End If
conexion.cerraconexion()
End Try
Return cl
End Function
Public Function getusuarioactivo() As usuario
Dim objalma As New DataSet()
Dim cl As New usuario
Dim select_sql As String
Try
select_sql = "select * from usuarios where activo = 'SI'"
objalma = conexion.consultar(select_sql)
cl.setusuario(objalma.Tables("tabla").Rows(0).Item("usuario"),
objalma.Tables("tabla").Rows(0).Item("password"),
objalma.Tables("tabla").Rows(0).Item("perfil"),
objalma.Tables("tabla").Rows(0).Item("activo"),
objalma.Tables("tabla").Rows(0).Item("nombre"),
objalma.Tables("tabla").Rows(0).Item("apellido"),
objalma.Tables("tabla").Rows(0).Item("identificacion"))
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
Return cl
End Function
Public Sub delusuario(ByVal idc As String)
Dim objconexion As New OleDb.OleDbCommand
Dim delete_sql As String
109
Try
delete_sql = "delete from usuarios where usuario = '" & idc &
"'"
conexion.ejecutar(delete_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updateactivo(ByVal usr As String)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
update_sql = "update usuarios set activo = 'SI' where usuario
= '" & usr & "'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updatepassword(ByVal usr As usuario, ByVal pas As String,
ByVal npas As String, ByVal cpas As String)
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
If Not (usr.getpassword = pas) Then
Throw New Exception("las contraseña del usuario es
incorrecta")
End If
If Not (npas = cpas) Then
Throw New Exception("las contraseñas ingresadas no
coinciden")
End If
update_sql = "update usuarios set password = '" & npas & "'
where usuario = '" & usr.Getusuario & "'"
conexion.ejecutar(update_sql)
MessageBox.Show("La contraseña a sido modificada
satisfactoriamente")
Catch ex As Exception
MessageBox.Show(ex.Message)
conexion.cerraconexion()
End Try
End Sub
Public Sub updateactivoNO()
Dim objconexion As New OleDb.OleDbCommand
Dim update_sql As String
Try
update_sql = "update usuarios set activo = 'NO' where activo
= 'SI'"
conexion.ejecutar(update_sql)
Catch ex As Exception
MessageBox.Show(ex.Message)
110
conexion.cerraconexion()
End Try
End Sub
Public Function validaringreso(ByVal usr As String, ByVal pas As
String) As Boolean
Dim usrin As New usuario
usrin = Me.getusuarioid(usr)
If StrComp(usrin.Getusuario, "", CompareMethod.Binary) = 0 Then
validaringreso = False
Else
If StrComp(usrin.getpassword, pas, CompareMethod.Binary) = 0
Then
validaringreso = True
Me.updateactivo(usrin.Getusuario)
Else
MessageBox.Show("El usuario o la contraseña son
incorrectos")
validaringreso = False
End If
End If
End Function
End Class
Simularcredito
Public Class simularcredito
Dim cuota, dias, diasdate As Integer
Dim capital, tmpinteres, interesperiodo, interes, valcuota, saldo,
mora As Double
Dim fechapago As Date
Dim cuo As New cuota
Dim cuobd As New cuotas_bd
Dim sig As Boolean = True
Dim valortotal As Double
Dim ncuotas As Double
Dim valint As Double
Public Sub simularcredito(ByVal cre As registrocredito, ByVal vcuota
As Double)
Dim cuo2 As New cuota
Dim tasbd As New tasa_bd
Dim tas As New tasas
Dim regbd As New registrocredito_bd
Try
If StrComp(cre.Getformapago, "Valor cuota",
CompareMethod.Binary) = 0 And vcuota = 0 Then
Throw New Exception("Debe ingresar el valor de la cuota")
End If
cuobd.delcredito(cre.Getidcredito)
tas = tasbd.gettasaid(cre.gettasa)
If StrComp(cre.getperiodo, "Diario", CompareMethod.Binary) =
0 Then
dias = 30
diasdate = 1
111
Else
If StrComp(cre.getperiodo, "Semanal",
CompareMethod.Binary) = 0 Then
dias = 4
diasdate = 8
Else
dias = 1
diasdate = 30
End If
End If
fechapago = DateAdd(DateInterval.Day, diasdate,
cre.Getfechainicial)
If StrComp(cre.Getformapago, "Valor cuota",
CompareMethod.Binary) = 0 Then
ncuotas = cre.getvaloraprobado / vcuota
interesperiodo = 1 + ((((cre.Gettea + tas.Getvalor) /
100) / 12) / dias) * ncuotas
valortotal = cre.getvaloraprobado * interesperiodo
valint = valortotal - cre.getvaloraprobado
saldo = valortotal
cuota = 1
While sig = True
interes = valint / ncuotas
valcuota = vcuota - interes
saldo = saldo - vcuota
cuo.setcuotas(cre.Getidcredito, "NO", cuota,
valcuota, interes, vcuota, saldo, fechapago)
cuobd.setcuota(cuo)
If (saldo < vcuota) Then
cuota += 1
vcuota = saldo
valcuota = saldo - interes
saldo = 0
cuo.setcuotas(cre.Getidcredito, "NO", cuota,
valcuota, interes, vcuota, saldo, fechapago)
cuobd.setcuota(cuo)
sig = False
End If
fechapago = DateAdd(DateInterval.Day, diasdate,
fechapago)
cuota += 1
End While
Else
If StrComp(cre.Getformapago, "Capital fijo",
CompareMethod.Binary) = 0 Then
interesperiodo = 1 + ((((cre.Gettea + tas.Getvalor) /
100) / 12) / dias) * cre.Getnumerocuotas
valortotal = cre.getvaloraprobado * interesperiodo
valint = valortotal - cre.getvaloraprobado
saldo = valortotal
112
interes = valint
capital = cre.getvaloraprobado / cre.Getnumerocuotas
For cuota = 1 To cre.Getnumerocuotas
interes = interes / 2
saldo = saldo - capital - interes
If (cuota = cre.Getnumerocuotas) Then
interes = tmpinteres
saldo = 0
End If
cuo.setcuotas(cre.Getidcredito, "NO", cuota,
capital, interes, capital + interes, saldo, fechapago)
fechapago = DateAdd(DateInterval.Day, diasdate,
fechapago)
cuobd.setcuota(cuo)
tmpinteres = interes
Next
Else
interesperiodo = 1 + ((((cre.Gettea + tas.Getvalor) /
100) / 12) / dias) * cre.Getnumerocuotas
valortotal = cre.getvaloraprobado * interesperiodo
valint = valortotal - cre.getvaloraprobado
saldo = valortotal
For cuota = 1 To cre.Getnumerocuotas
interes = valint / cre.Getnumerocuotas
valcuota = valortotal / cre.Getnumerocuotas
capital = valcuota - interes
saldo = saldo - capital
If (cuota = cre.Getnumerocuotas) Then
saldo = 0
End If
cuo.setcuotas(cre.Getidcredito, "NO", cuota,
capital, interes, valcuota, saldo, fechapago)
fechapago = DateAdd(DateInterval.Day, diasdate,
fechapago)
cuobd.setcuota(cuo)
Next
End If
End If
regbd.cambiarfechafinalpago(cre.Getidcredito, fechapago)
MessageBox.Show("La simulación a sido ejecutada, puede
observar las cuotas")
Catch ex As Exception
MessageBox.Show(ex.Message)
End Try
End Sub
End Class
Creditos (controladora)
Public Class creditos
Dim tas As New tasas
Dim tasbd As New tasa_bd
Dim doc As New documentos
Dim docbd As New documentos_bd
113
Dim tcre As New tipocredito
Dim tcrebd As New tipocredito_bd
Dim req As New requisitos
Dim reqbd As New requisitos_bd
Dim cta As New cuota
Dim cuobd As New cuotas_bd
Dim rcr As New registrocredito
Dim rcrbd As New registrocredito_bd
Dim cli As New cliente
Dim clibd As New cliente_bd
Dim sim As New simularcredito
Dim usr As New usuario
Dim usrbd As New usuario_bd
'usuarios
Public Function validaringreso(ByVal usr As String, ByVal pwd As
String) As Boolean
validaringreso = usrbd.validaringreso(usr, pwd)
End Function
Public Sub registar_usuarios(ByVal usua As String, ByVal pwd As
String, ByVal per As String, ByVal act As String, ByVal nom As String,
ByVal ape As String, ByVal iden As String)
usr.setusuario(usua, pwd, per, act, nom, ape, iden)
usrbd.setrusuario(usr)
End Sub
Public Function getusuario() As DataSet
Dim dt As DataSet
dt = usrbd.getusuario()
getusuario = dt
End Function
Public Function getusuarioid(ByVal id As String) As usuario
Dim us As usuario
us = usrbd.getusuarioid(id)
getusuarioid = us
End Function
Public Function getusuarioactivo() As usuario
Dim us As usuario
us = usrbd.getusuarioactivo()
getusuarioactivo = us
End Function
Public Sub del_usuario(ByVal id As String)
usrbd.delusuario(id)
End Sub
Public Sub udp_activo(ByVal idc As String)
usrbd.updateactivo(idc)
End Sub
Public Sub udp_activoNO()
usrbd.updateactivoNO()
End Sub
Public Sub cambiarpassword(ByVal pas As String, ByVal npas As String,
ByVal cpas As String)
Dim us As usuario
us = Me.getusuarioactivo()
usrbd.updatepassword(us, pas, npas, cpas)
End Sub
114
'simulacion
Public Sub simulacion(ByVal icr As String, ByVal cuota As Double)
sim.simularcredito(Me.getregistrocreditoid(icr), cuota)
End Sub
'clientes
Public Sub registar_cliente(ByVal idc As String, ByVal nom As String,
ByVal prn As String, ByVal segn As String, ByVal pra As String, ByVal
sega As String, ByVal dir As String, ByVal tel As String, ByVal mov As
String, ByVal fax As String, ByVal ema As String, ByVal veh As String,
ByVal viv As String, ByVal pro As String, ByVal fla As String, ByVal fec
As Date)
cli.setcliente(idc, nom, prn, segn, pra, sega, dir, tel, mov,
fax, ema, veh, viv, pro, fla, fec)
clibd.setrcliente(cli)
End Sub
Public Function getcliente() As DataSet
Dim dt As DataSet
dt = clibd.getcliente()
getcliente = dt
End Function
Public Function getclienteid(ByVal id As String) As cliente
Dim cl As cliente
cl = clibd.getclienteid(id)
getclienteid = cl
End Function
Public Sub del_cliente(ByVal id As String)
clibd.delcliente(id)
End Sub
Public Sub udp_cliente(ByVal idc As String, ByVal nom As String,
ByVal prn As String, ByVal segn As String, ByVal pra As String, ByVal
sega As String, ByVal dir As String, ByVal tel As String, ByVal mov As
String, ByVal fax As String, ByVal ema As String, ByVal veh As String,
ByVal viv As String, ByVal pro As String, ByVal fla As String, ByVal fec
As Date)
cli.setcliente(idc, nom, prn, segn, pra, sega, dir, tel, mov,
fax, ema, veh, viv, pro, fla, fec)
clibd.updatecliente(cli)
End Sub
'registrarcredito
Public Sub registar_credito(ByVal idc As String, ByVal cli As String,
ByVal nom As String, ByVal tas As String, ByVal est As String, ByVal tcr
As String, ByVal per As String, ByVal vap As Integer, ByVal vso As
Integer, ByVal ncu As Integer, ByVal tea As Double, ByVal fin As Date,
ByVal ffi As Date, ByVal fpr As Date, ByVal fpa As String)
rcr.setregitrocredito(idc, cli, nom, tas, est, tcr, per, vap,
vso, ncu, tea, fin, ffi, fpr, fpa)
rcrbd.setregistrocredito(rcr)
End Sub
Public Function getregistrocredito() As DataSet
Dim dt As DataSet
dt = rcrbd.getregistrocredito()
getregistrocredito = dt
End Function
115
Public Function getregistrocreditoid(ByVal id As String) As
registrocredito
Dim rc As registrocredito
rc = rcrbd.getregistrocreditoid(id)
getregistrocreditoid = rc
End Function
Public Sub del_registrocredito(ByVal id As String)
rcrbd.delcredito(id)
End Sub
Public Sub cambiarestado(ByVal id As String, ByVal est As String)
rcrbd.cambiarestado(id, est)
End Sub
'cuotas
Public Sub registar_cuotas(ByVal idc As String, ByVal pag As String,
ByVal cuo As Integer, ByVal cap As Double, ByVal int As Double, ByVal
vcuo As Double, ByVal sal As Double, ByVal fec As Date)
cta.setcuotas(idc, pag, cuo, cap, int, vcuo, sal, fec)
cuobd.setcuota(cta)
End Sub
Public Function getcuotas() As DataSet
Dim dt As DataSet
dt = cuobd.getcuotas()
getcuotas = dt
End Function
Public Function getcuotasid(ByVal id As String) As DataSet
Dim dt As DataSet
dt = cuobd.getcuotascredito(id)
getcuotasid = dt
End Function
Public Function getcuotasinpago(ByVal id As String) As DataSet
Dim dt As DataSet
dt = cuobd.getcuotascreditoSinpago(id)
getcuotasinpago = dt
End Function
Public Sub del_cuotas(ByVal id As String)
cuobd.delcredito(id)
End Sub
Public Sub pagarcuotas(ByVal id As String, ByVal cuo As Integer)
cuobd.pagarcuota(id, cuo)
End Sub
'requisitos
Public Sub registar_requisitos(ByVal idr As String, ByVal idd As
String, ByVal forl As String, ByVal idc As String)
req.setdrequisitos(idr, idd, forl, idc)
reqbd.setrequisitos(req)
End Sub
Public Function getrequisitos() As DataSet
Dim dt As DataSet
dt = reqbd.getrequisitos()
getrequisitos = dt
End Function
116
Public Function getrequisitoscredito(ByVal id As String) As DataSet
Dim dt As DataSet
dt = reqbd.getrequisitosidcredito(id)
getrequisitoscredito = dt
End Function
Public Function getrequisitosid(ByVal id As String) As requisitos
Dim rq As requisitos
rq = reqbd.getrequisitosid(id)
getrequisitosid = rq
End Function
Public Sub del_requisitos(ByVal id As String)
reqbd.delrequisitos(id)
End Sub
Public Sub udp_requisitos(ByVal idr As String, ByVal idd As String,
ByVal forl As String, ByVal idc As String)
req.setdrequisitos(idr, idd, forl, idc)
reqbd.updaterequisito(req)
End Sub
'Tasas
Public Sub registar_tasas(ByVal idt As String, ByVal des As String,
ByVal val As Double, ByVal fec As Date)
tas.settasas(idt, des, val, fec)
tasbd.settasa(tas)
End Sub
Public Function gettasa() As DataSet
Dim dt As DataSet
dt = tasbd.gettasa()
gettasa = dt
End Function
Public Function gettasaid(ByVal id As String) As tasas
Dim ts As tasas
ts = tasbd.gettasaid(id)
gettasaid = ts
End Function
Public Sub del_tasas(ByVal id As String)
tasbd.deltasa(id)
End Sub
Public Sub udp_tasas(ByVal idt As String, ByVal des As String, ByVal
val As Double, ByVal fec As Date)
tas.settasas(idt, des, val, fec)
tasbd.updatetasa(tas)
End Sub
'Documentos
Public Sub registrar_documentos(ByVal iddoc As String, ByVal des As
String, ByVal cant As Integer)
doc.setdocumentos(iddoc, des, cant)
docbd.setdocumento(doc)
End Sub
Public Function getdocumento() As DataSet
Dim dt As DataSet
dt = docbd.getdocumentos()
getdocumento = dt
End Function
Public Function getdocumentoid(ByVal id As String) As documentos
117
Dim dc As documentos
dc = docbd.getdocumentosid(id)
getdocumentoid = dc
End Function
Public Sub del_documento(ByVal id As String)
docbd.deldocumentos(id)
End Sub
Public Sub udp_documento(ByVal idd As String, ByVal des As String,
ByVal can As Integer)
doc.setdocumentos(idd, des, can)
docbd.updatedocumentos(doc)
End Sub
'tipos de credito
Public Sub registrar_tipo_credito(ByVal idcre As String, ByVal des As
String, ByVal pre As Double)
tcre.settipocredito(idcre, des, pre)
tcrebd.settipocredito(tcre)
End Sub
Public Function gettipocredito() As DataSet
Dim dt As DataSet
dt = tcrebd.gettipocredito()
gettipocredito = dt
End Function
Public Function gettipocreditoid(ByVal id As String) As tipocredito
Dim tc As tipocredito
tc = tcrebd.gettipocreditoid(id)
gettipocreditoid = tc
End Function
Public Sub del_tipocredito(ByVal id As String)
tcrebd.deltipocredito(id)
End Sub
Public Sub udp_tipocredito(ByVal idc As String, ByVal des As String,
ByVal val As Double)
tcre.settipocredito(idc, des, val)
tcrebd.updattipocredito(tcre)
End Sub
End Class
118
Base de datos
USE [creditos]
GO
/****** Objeto: Table [dbo].[documentos]
Fecha de la secuencia de
comandos: 05/28/2008 22:01:46 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[documentos](
[iddocumento] [char](10) NOT NULL,
[descripcion] [text] NULL,
[cantidad] [int] NOT NULL,
CONSTRAINT [PK_documentos] PRIMARY KEY CLUSTERED
(
[iddocumento] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[tipocreditos]
Fecha de la secuencia de
comandos: 05/28/2008 22:02:00 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[tipocreditos](
[idcredito] [char](10) NOT NULL,
[descripcion] [text] NULL,
[presupuesto] [int] NOT NULL,
CONSTRAINT [PK_tipocreditos] PRIMARY KEY CLUSTERED
(
[idcredito] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[requisitos]
Fecha de la secuencia de
comandos: 05/28/2008 22:01:56 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
119
GO
CREATE TABLE [dbo].[requisitos](
[idrequisito] [char](10) NOT NULL,
[iddocumento] [char](10) NULL,
[formalaboral] [text] NULL,
[idcredito] [char](10) NULL,
CONSTRAINT [PK_requisitos] PRIMARY KEY CLUSTERED
(
[idrequisito] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[clientes]
Fecha de la secuencia de
comandos: 05/28/2008 22:01:39 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[clientes](
[idcliente] [char](10) NOT NULL,
[nombrebusqueda] [text] NULL,
[primernombre] [text] NOT NULL,
[segundonombre] [text] NULL,
[primerapellido] [text] NOT NULL,
[segundoapellido] [text] NULL,
[Direccion] [text] NOT NULL,
[telefono] [text] NOT NULL,
[movil] [text] NULL,
[fax] [text] NULL,
[email] [text] NULL,
[vehiculo] [text] NULL,
[vivienda] [text] NULL,
[profesion] [text] NULL,
[fechanacimiento] [datetime] NULL,
[formalaboral] [text] NULL,
CONSTRAINT [PK__clientes__0519C6AF] PRIMARY KEY CLUSTERED
(
[idcliente] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[cuotas]
Fecha de la secuencia de
comandos: 05/28/2008 22:01:44 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
120
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[cuotas](
[idcredito] [char](10) NULL,
[cuota] [int] NULL,
[fechapago] [datetime] NULL,
[capital] [numeric](18, 2) NULL,
[interes] [numeric](18, 2) NULL,
[valcuota] [numeric](18, 2) NULL,
[saldo] [numeric](18, 2) NULL,
[pago] [text] NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[usuarios]
Fecha de la secuencia de
comandos: 05/28/2008 22:02:04 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[usuarios](
[usuario] [char](10) NOT NULL,
[password] [text] NULL,
[perfil] [text] NULL,
[activo] [char](10) NULL,
[nombre] [text] NULL,
[apellido] [text] NULL,
[identificacion] [text] NULL,
CONSTRAINT [PK_usuarios] PRIMARY KEY CLUSTERED
(
[usuario] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[registrocredito]
Fecha de la secuencia
de comandos: 05/28/2008 22:01:53 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[registrocredito](
[idcredito] [char](10) NOT NULL,
[cliente] [char](10) NOT NULL,
[nombrebusqueda] [text] NULL,
[valorsolicitado] [int] NULL,
121
[valoraprobado] [int] NULL,
[fechapresupuesto] [datetime] NULL,
[fechainicial] [datetime] NULL,
[fechafinal] [datetime] NULL,
[tipocredito] [text] NULL,
[numerocuotas] [int] NULL,
[periodo] [text] NULL,
[tea] [float] NULL,
[tasa] [text] NULL,
[estado] [text] NULL,
[formapago] [text] NULL,
CONSTRAINT [FK_registrocredito_1] PRIMARY KEY CLUSTERED
(
[idcredito] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: Table [dbo].[tasas]
Fecha de la secuencia de
comandos: 05/28/2008 22:01:59 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [dbo].[tasas](
[idtasa] [char](10) NOT NULL,
[descripcion] [text] NULL,
[fecha] [datetime] NULL,
[valor] [float] NOT NULL,
PRIMARY KEY CLUSTERED
(
[idtasa] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY =
OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING OFF
GO
/****** Objeto: ForeignKey [FK_clientes_clientes]
Fecha de la
secuencia de comandos: 05/28/2008 22:01:39 ******/
ALTER TABLE [dbo].[clientes] WITH CHECK ADD CONSTRAINT
[FK_clientes_clientes] FOREIGN KEY([idcliente])
REFERENCES [dbo].[clientes] ([idcliente])
GO
ALTER TABLE [dbo].[clientes] CHECK CONSTRAINT [FK_clientes_clientes]
GO
122