Resumen

Resumen
En este proyecto se ha desarrollado una aplicación de contabilidad financiera que
permite realizar un seguimiento de la evolución de los datos contables de una empresa.
El principal motivo de la realización de este proyecto es la de utilizar la herramienta
desarrollada como material didáctico en las asignaturas de Economía, en las titulaciones de
Ingeniería informática. De esta forma el profesor se beneficia de tener la posibilidad de
llevar a cabo ejercicios de cierta complicación de una forma ordenada, siendo mucho más
fácil evaluar y corregir a los alumnos. También los alumnos son beneficiados, ya que
debido a la automatización del proceso, pueden seguirlo con mucha mayor facilidad y
adquirir conocimientos de una forma más rápida, sencilla y dinámica.
La aplicación puede ser aprovechada también para que cualquier persona pueda
llevar las cuentas de su empresa de forma ordenada, en caso de que esta empresa sea de
pequeño tamaño y no exija un volumen de operaciones muy grande.
El funcionamiento de la herramienta consiste en el almacenamiento en una base de
datos de diferentes empresas con sus respectivos libros diarios, en donde quedan registradas
todas las operaciones de la empresa. El funcionamiento de la aplicación va ligado
estrictamente al funcionamiento del proceso contable: se va definiendo la información de la
empresa, su situación inicial y por cada año de funcionamiento de la empresa se busca
registrar todas sus operaciones para poder generar un documento final que contiene el libro
diario, el libro mayor y el balance de comprobación de cada año. Por todo ello, para poder
utilizar la aplicación de una forma acertada es necesario que el usuario disponga de
conocimientos básicos en contabilidad financiera. El programa sigue el proceso estipulado
en el “Plan general de contabilidad” definido y establecido a partir del Real Decreto 743, el
I
20 de diciembre de 1990. Este plan establece las normas a seguir para elaborar los libros
diarios, los libros mayores y los balances así como las cuentas con sus respectivos nombres
y números que permiten dotar de cierta uniformidad a los hechos contables de las distintas
empresas.
En la actualidad existen diferentes programas diseñados para llevar la contabilidad
de las empresas, especialmente orientados a pequeñas y medianas empresas y que resultan
complicados de manejar por la multitud de opciones que incluyen. Sin embargo, no existen
aplicaciones con carácter lectivo orientadas a la contabilidad financiera. Es por eso que la
aplicación realizada en este proyecto, lejos de buscar obtener todo el potencial y
posibilidades de la contabilidad financiera, busca la mayor simplicidad posible pensando en
los alumnos.
Con el fin de facilitar el uso del programa por parte del usuario se muestran
mensajes informativos siempre que el usuario intente realizar una operación que no es
correcta desde el punto de vista contable (como, por ejemplo, introducir un balance con una
suma del haber mayor a la suma del debe). De esta forma el alumno verá a la aplicación
como un aliado.
Como output del programa se puede obtener un documento de texto como resumen
anual de la actividad contable de la empresa durante un año de funcionamiento. Este
documento contiene por este orden: libro diario, libro mayor, balance de comprobación
antes del cierre de cuentas de pérdidas y ganancias y balance de comprobación después del
cierre de cuentas de pérdidas y ganancias. Los asientos que representan operaciones de la
empresa son introducidos por el usuario pero es la aplicación la que genera una serie de
asientos especiales: el asiento de apertura, el asiento de cierre de cuentas temporal al debe,
el asiento de cierre de cuentas temporal al haber y asiento de cierre de cuentas permanente.
II
La tecnología escogida para llevar a cabo el programa ha sido la plataforma .NET
por la posibilidad de programar visualmente con relativa facilidad gracias a las “Windows
Forms”, por su buena interacción con el sistema operativo Windows (donde se ejecutará la
aplicación) y porque permite programar con uno de los lenguajes de programación más
potentes en la actualidad: C# que, a su vez, está diseñado para obtener todo el rendimiento
posible de la plataforma .NET. Al utilizar “Windows Forms”, el interfaz gráfico de la
aplicación resultará familiar al usuario ya que será similar al de la mayoría de programas
que se utilizan en Windows.
Para gestionar la base de datos se ha elegido Microsoft Access dado que por su
sencillez facilita el acceso a los datos por parte de la aplicación. Access no es un sistema
gestor de bases de datos muy potente pero es suficiente para los requerimientos de la
aplicación en el acceso a datos. Con el fin de almacenar toda la información necesaria, se
han definido cinco tablas en la base de datos. Una para almacenar los datos de una empresa
(nombre, tipo de sociedad, año de inicio y nombre del creador), otra para almacenar los
distintos estados que definen una situación inicial de una empresa, otra para almacenar los
libros diarios de las empresas, otra tabla donde se almacenan los asientos de un libro diario
y, por último, una tabla donde se almacenan las distintas operaciones que modifican el
saldo de una cuenta y que conforman los asientos. Se puede decir que una empresa cuenta
con una situación inicial (definida por los estados) y por una serie de libros diarios. Cada
uno de estos está formado por asientos, los cuales, a su vez, están formados por
operaciones.
Debido a que la aplicación va a constar de un ejecutable, con sólo algunos
documentos que se necesitan cargar y con una base de datos sencilla y de pequeño tamaño,
III
será posible ejecutarla desde cualquier ordenador con sistema operativo Windows sin
necesidad de tener que ser instalada o configurada.
IV
Abstract
In this Project a financial accounting application has been developed to allow
following up the evolution of the accounting data of an enterprise.
The main motive for doing this project is that the developed tool will be used as
didactic material in the economy subjects of the Computer Science Engineer courses. In
this way, the teacher of the subjects is beneficed because he can propose more complicated
exercises to the students and solve them in a tidier way, being easier the evaluation and
correction of the students’ solutions. There is also benefice for the students, since the
automation of the process, they can follow it in a simpler and easier way and they can
acquire accounting knowledge faster and more dynamically.
The developed tool can be also used by any other person to follow up the
accounting data of his enterprise in an ordered way, in case that this enterprise doesn’t have
a big size and doesn’t demand big volume of accounting operations.
The application functioning is based on storage on a data base of different
enterprises with their respective “log books” (one of these is a document that collects the
accounting operations of an enterprise in one year time). The functionality of the tool is
strictly tied to the functioning of the accounting process: first the main information of the
enterprise is defined, then it’s initial situation, then for each working year of the enterprise
all the accounting operations are registered so it is possible to make a final summarize
document of the year with the “log book”, the “general ledger” (it is a document that
contains all the operations classified by the number of account) and the “final balance” (it
is a document that contains the state of each account at the end of the year) of the enterprise
in the chosen year. Because of this, it is necessary that the user has basic knowledge in
V
financial accounting so he can use the tool in a proper way. The application follows the
process stipulated on the “Plan General de Contabilidad” (General Accounting Plan)
defined and established in Spain by the Royal Decree 743 on the 20th of December of 1990.
This is why the tool developed on the project is only completely valid for the Spanish
accounting system and not for other countries accounting systems. The mentioned plan
establishes some rules that have to be followed in order to elaborate the log books, the
general ledgers, the balances and the numbers and names of the different accounts that
allow giving some uniformity to the accounting information of the different enterprises.
Nowadays there exist different programs designed to follow up the accounting of an
enterprise, specially oriented to the small and medium ones. These programs integrate a big
variety of options that makes them complicated to be used. Nevertheless, there are no
financial accounting applications designed towards a teaching purpose. This is the reason
why the designed application doesn’t aim to have all the functionality that the financial
accounting allows. Instead it looks towards to the most possible simplicity so the students
can understand and learn the financial accounting basics.
To make the tool easier to use by the user, the tool displays informative messages
every time the user tries to make and invalid operation related to accounting. In this way,
the user will consider the application as an ally.
As an output of the program a text document is obtained. This document contains by
this order, log book, general ledger, balance before closing the loss and profit accounts and
balance after closing the loss and profit accounts. The accounting entries that represent the
operations of the enterprise are introduced by the user but it is the application the one that
generates automatically some special accounting entries: the opening entry of every year,
the accounts temporary closing entries and the accounts permanent closing.
VI
The chosen technology to develop the project has been the .NET platform because it
allows to program visually in an easy way with the “Windows Forms”, because it interacts
in a good way with Windows operative system (where the application will run on) and
because it allows to program with one of the most powerful programming languages: C#,
that is, in turn, designed to obtain all the possible yield from the .NET platform. Because
the tool uses “Windows Forms” for the graphic interface, this will be familiar for the user
because it will be similar to the interface of other programs executing on Windows.
To manage the data base, the chosen manager is Microsoft Access because of its
simplicity that allows the application to access the data in an easy way. Access is not a very
powerful database manager system but it is enough for the application requirements. To
store all the needed information on the database, five data tables are defined. One to store
the information of an enterprise (name, society type, initial year, and name of the creator),
another one to store the different states that compose the initial situation of the enterprise,
another data table to store the “log books” of the enterprise, another one to store the
accounting entries of each book and, finally, a data table to store the elemental accounting
operations that compose each accounting entry. The relations between the different data
tables are: each enterprise normally has an initial situation, each enterprise has at least one
“daily book” and one of this is composed by accounting entries that are in turn composed of
elemental operations.
Because the tool is going to be only composed by one executable file, some text
documents and one simple and small database, it will be possible to run it in every
computer with a Windows operative system with no need of configuring or installing the
application before executing it.
VII
Índice de Contenidos
CAPÍTULO 1: ANÁLISIS DE LA APLICACIÓN .......................... 1
1.1 Documento de Conceptos del Sistema ..................................................... 1
1.2 Lista de Requisitos ................................................................................... 4
1.3 Estado del arte .......................................................................................... 9
1.3.1 Aplicaciones a nivel empresarial .................................... 9
1.3.2 Aplicaciones a nivel docente ........................................ 13
CAPÍTULO 2: DISEÑO DE LA APLICACIÓN ............................ 14
2.1 Modelo lógico......................................................................................... 14
2.1.1 Diagrama de Contexto ................................................. 14
2.1.2 Diagrama de primer nivel (conceptual) ......................... 15
2.1.3 Diagramas de Nivel 2................................................... 18
2.2 Arquitectura/Tecnología de la aplicación .............................................. 24
2.3 Diseño de entradas y salidas................................................................... 26
2.3.1 Diseño de ventanas ..................................................... 26
2.3.2 Diseño de informe ....................................................... 40
2.4 Modelo lógico de datos .......................................................................... 46
CAPÍTULO 3: PROGRAMACIÓN ................................................ 51
3.1 Modelo físico de datos ........................................................................... 51
3.1.1 Base de datos en Access .............................................. 51
3.1.2 DataSets empleados en C# .NET .................................. 53
3.2 Explicación de la programación............................................................. 56
3.2.1 Clases ......................................................................... 56
3.2.1.1 La clase “Conexión”..................................................................................... 56
3.2.1.2 La clase “LibroDiario” ................................................................................. 57
3.2.1.3 La clase “Empresa” ...................................................................................... 57
3.2.1.4 La clase “CloseButton” ................................................................................ 58
3.2.1.5 La clase “AdvRichTextBox”........................................................................ 58
3.2.1.6 La clase “Global”.......................................................................................... 58
3.2.2 Los Formularios .......................................................... 64
3.2.2.1 “Menú principal” .......................................................................................... 64
3.2.2.2 “Acerca De”.................................................................................................. 69
3.2.2.3 “Añadir Asiento” .......................................................................................... 69
3.2.2.4 “Ayuda” ........................................................................................................ 76
3.2.2.5 “Balance de sumas y saldos” ........................................................................ 77
3.2.2.6 “Ficha de la Empresa” .................................................................................. 78
3.2.2.7 “Empresas Existentes”.................................................................................. 80
3.2.2.8 “Evolución del libro diario” ......................................................................... 80
3.2.2.9 “Libros Diarios” ........................................................................................... 81
3.2.2.10 “Resumen Anual” ....................................................................................... 82
VIII
3.2.2.11 “Saldo de una Cuenta”................................................................................ 86
3.2.2.12 “Situación inicial de la empresa”................................................................ 86
3.2.2.13 “Cuentas”.................................................................................................... 87
3.2.2.14 “Cuentas2”.................................................................................................. 87
ANEXO A: Introducción a la tecnología .NET ............................... 88
1. Compatibilidad entre lenguajes................................................................ 89
2. Ventajas globales de .NET....................................................................... 89
3. Arquitectura básica de la plataforma .Net................................................ 90
4. Características de C#................................................................................ 97
ANEXO B: Manual de Usuario ..................................................... 107
1. Introducción a la aplicación ................................................................... 107
2. Ejecución de la aplicación...................................................................... 109
3. Utilización de la aplicación.................................................................... 110
3.1 Menú Principal............................................................. 110
3.2 Ficha de la empresa ..................................................... 112
3.3 Empresas existentes..................................................... 115
3.4 Libros diarios de una empresa...................................... 118
3.5 Situación inicial de la empresa ..................................... 122
3.6 Evolución del Libro diario ............................................. 126
3.7 Saldo de la Cuenta ....................................................... 129
3.8 Balance de Sumas y saldos .......................................... 130
3.9 Añadir Asiento ............................................................. 131
3.10 Cuadro de Cuentas .................................................... 138
3.11 Cuadro de Cuentas (por orden alfabético) ................... 139
3.12 Resumen Anual.......................................................... 140
3.13 Ayuda ........................................................................ 147
3.14 Acerca de la aplicación ............................................... 148
4. Ejemplo – Ejercicio Resuelto................................................................. 149
4.1
4.2
4.3
4.4
4.5
Enunciado ................................................................... 149
Crear la empresa.......................................................... 150
Definir Situación inicial ................................................ 152
Evolución del libro diario para el año 2002 ................... 153
Resumen anual del 2002 .............................................. 159
ANEXO C: Valoración económica................................................ 165
ANEXO D: Planificación............................................................... 168
ANEXO E: Conclusiones............................................................... 173
Bibliografía..................................................................................... 174
IX
CAPÍTULO 1
ANÁLISIS DE LA APLICACIÓN
1.1 Documento de Conceptos del Sistema
Objetivos del sistema
La aplicación a desarrollar pretende ofrecer una forma simple de elaborar, guardar y
obtener resultados sobre los datos contables de una empresa. Esto se ha de hacer de una
manera sencilla y fácil de usar combinando interacción con el usuario y generación
automática de cierta información contable. Con el fin de dotarle de facilidad y de buena
interacción con el usuario la aplicación contará con gran número de mensajes informativos
y control de errores sobre los datos contables introducidos por el usuario. Son objetivos del
sistema:
•
Seguimiento y almacenamiento de los datos contables de una empresa.
•
Generación de documentos con resúmenes anuales de los estados financieros de una
empresa.
Alcance del sistema
1. Automatizar la entrada de asientos para los libros diarios de una empresa.
2. Contabilizar las operaciones de la empresa y controlar que dichas operaciones
cuadren.
1
3. Identificar las distintas cuentas que pueden intervenir en cada operación.
4. Permitir definir un balance inicial para el comienzo de funcionamiento de la
empresa.
5. Contabilizar y mostrar en todo momento los saldos de cada cuenta así como el
balance de sumas y saldos.
6. Realizar y contabilizar asientos de apertura y de cierre de cuentas de forma
automática.
7. Generar documento con el resumen anual del funcionamiento de cada empresa,
incluyendo libro diario, libro mayor y balance de comprobación antes y después del
cierre de cuentas de ingresos y gastos.
8. Proporcionar información de ayuda al usuario acerca del plan general contable.
9. Obtener un interfaz de usuario fácil de manejar.
10. Permitir que cada usuario pueda llevar los datos de la empresa consigo y pueda
acceder a ellos desde cualquier lugar o sistema.
Tipología de los usuarios finales
Los usuarios finales del sistema son:
•
Alumnos, para poder realizar los ejercicios propuestos por el profesor de la
asignatura.
•
Profesores. En primer lugar para ver los ejercicios realizados por los alumnos y, en
segundo, para poder realizar los ejercicios y mostrar la corrección a los alumnos.
2
•
Aquellas personas que deseen utilizar la aplicación para llevar las cuentas de su
empresa de una manera fácil y sencilla.
Restricciones
•
Se ha de buscar en todo momento la simplicidad con el fin de que el alumno que se
está iniciando en la contabilidad pueda seguir el proceso general contable.
•
Se va a utilizar la tecnología .NET y dado que no se dispone de la extensión “TX
Text Control .NET Server” la posibilidad de generación de archivos Word, Excel o
Pdf es muy limitada o nula.
•
Se debe trabajar con una base de datos móvil para que el usuario la pueda llevar
consigo y poder trabajar con ella en cualquier momento y en cualquier lugar.
Antecedentes
•
Los ejercicios sobre la contabilidad de empresas ficticias se vienen realizando en las
asignaturas de introducción a la contabilidad en el primer año de las carreras de
ingeniería de ICAI. Estos ejercicios se hacen de forma manual por lo que es difícil
asegurarse de cuadrar las cuentas y de seguir la evolución de la empresa en un
ejercicio que sea complicado.
3
1.2 Lista de Requisitos
Se analizarán los diferentes objetivos del sistema (expuestos en el documento de
conceptos del sistema) y se definirán los requisitos que debe cumplir la aplicación para
poder cubrir cada uno de los requisitos del sistema:
Objetivo 1: Automatizar la entrada de asientos para los libros diarios de una empresa.
Requisitos necesarios:
•
La aplicación debe contar con una pantalla que permita al usuario introducir las
distintas operaciones que componen un asiento, así como su fecha.
•
La aplicación necesita una pantalla que muestre al usuario una lista con todos los
asientos pertenecientes al libro diario de la empresa.
•
Internamente la aplicación debe trabajar con códigos de empresas, de operaciones,
de asientos y de libros diarios de una forma relacional con el fin de que se puedan
almacenar diferentes empresas, con diferentes libros diarios que a su vez tengan
diferentes asientos y operaciones.
Objetivo 2: Contabilizar las operaciones de la empresa y controlar que dichas
operaciones cuadren.
Requisitos necesarios:
•
La aplicación debe asegurarse de que la suma de los valores de las operaciones que
intervienen en el “debe” de un asiento es igual a la suma de los valores de las
operaciones que intervienen en el “haber”.
4
•
Hay ciertas cuentas que no pueden intervenir en un asiento formando parte de las
operaciones de debe o de haber. El programa debe controlar esto.
•
Asegurarse que las operaciones se guardan correctamente y que los asientos se
pueden recuperar de una ejecución de la aplicación a otra.
Objetivo 3: Identificar las distintas cuentas que pueden intervenir en cada operación.
Requisitos necesarios:
•
Al introducir un número de cuenta válido el programa debe mostrar el nombre de la
cuenta y el tipo: activo, pasivo, pérdida o ganancia. También se debe especificar si
esa cuenta debe tener un valor positivo o negativo.
•
La aplicación debe asegurarse de que la cuenta introducida puede participar en la
operación seleccionada del asiento correspondiente o en el estado inicial de la
cuenta para el balance inicial de la empresa.
Objetivo 4: Permitir definir un balance inicial para el comienzo de funcionamiento de
la empresa.
Requisitos necesarios:
•
Se debe mostrar una pantalla con la situación inicial de la empresa y dar la
posibilidad al usuario de ir añadiendo estados de cuentas tanto a la columna del
haber como a la columna del debe.
•
El balance de situación inicial debe cuadrar, es decir, la suma de las cantidades del
debe tiene que ser igual a la suma de las cantidades del haber.
5
Objetivo 5: Contabilizar y mostrar en todo momento los saldos de cada cuenta así
como el balance de sumas y saldos.
Requisitos necesarios:
•
Se debe dar la posibilidad al usuario de seleccionar cualquier número de cuenta de
las que intervienen en un libro diario y poder ver el saldo de esa cuenta.
•
Se debe dar la posibilidad al usuario de ver en cualquier momento el balance de
sumas y saldos provisional del libro diario.
Objetivo 6: Realizar y contabilizar asientos de apertura y de cierre de cuentas de forma
automática.
Requisitos necesarios:
•
Cada vez que se muestren los asientos de un libro diario se debe calcular y mostrar
el asiento de apertura de dicho libro. Para ello hay que analizar los asientos de libros
diarios de años anteriores y la situación inicial de la empresa para obtener los
estados financieros de la empresa a 1 de enero de ese año.
•
Cada vez que se muestre el resumen anual de la actividad de un libro diario se debe
calcular y mostrar el asiento de apertura de dicho libro así como los asientos de
cierre de cuentas temporales (al debe y al haber) y el de cierre de cuentas
permanente. Para ello hay que analizar el balance de la empresa al comenzar el año
y todas las operaciones registradas en el libro diario.
6
Objetivo 7: Generar documento con el resumen anual del funcionamiento de cada
empresa, incluyendo libro diario, libro mayor y balance de comprobación antes y
después del cierre de cuentas de ingresos y gastos.
Requisitos necesarios:
•
Con el fin de poder crear el resumen del libro diario es necesario recorrer y analizar
todos los asientos del libro diario.
•
Para poder escribir el libro mayor hace falta contabilizar para cada cuenta las
distintas operaciones que intervienen en ella.
•
Se ha de mostrar también el balance de comprobación antes del cierre de cuentas de
ingresos y gastos (sin incluir los asientos de cierre de cuentas temporales) y después
del cierre de cuentas de ingresos y gastos (que incluye los asientos de cierre de
cuentas temporales).
•
Mostrar por pantalla el contenido del resumen anual. Para ello se ha de cargar un
archivo RTF con las pertinentes tabulaciones, espacios y saltos de línea para que se
pueda conseguir una presentación aceptable.
•
Generar un archivo que contenga el resumen anual y que pueda ser editado por el
usuario en Word. Para conseguir una presentación aceptable es necesario que las
tabulaciones, espacios y saltos de línea se adapten a los parámetros del programa
Word.
Objetivo 8: Proporcionar información de ayuda al usuario acerca del plan general
contable.
Requisitos necesarios:
7
•
Se debe poder mostrar el contenido del plan general contable si el usuario lo cree
oportuno.
Objetivo 9: Obtener un interfaz de usuario fácil de manejar.
Requisitos necesarios:
•
Se debe buscar un diseño que permite un uso sencillo e intuitivo. Para eso se deben
mostrar todas las funcionalidades de la aplicación en menú y/o en botones.
•
Las diferentes pantallas de la aplicación deben de estar perfectamente conectadas
pudiendo cambiar entre ellas siempre que el usuario lo desee.
Objetivo 10: Permitir que cada usuario pueda llevar los datos de la empresa consigo y
pueda acceder a ellos desde cualquier lugar o sistema.
Requisitos necesarios:
•
Los datos contables de la empresa se han de poder almacenar en una base de datos
sencilla y de pequeño tamaño que el usuario pueda llevar junto la aplicación y poder
ejecutar ésta en cualquier ordenador y en cualquier momento.
•
Para distinguir entre una empresa con el mismo nombre creada por dos o más
personas diferentes, se debe incluir un campo que especifique el nombre del autor o
creador de la empresa.
•
Con el fin de que no se guarden datos erróneos en la base de datos, como por
ejemplo un balance inicial que no cuadra, la aplicación debe comprobar la
integridad de la base de datos al comenzar su ejecución y realizar las tareas de
corrección pertinentes.
8
1.3 Estado del arte
1.3.1 Aplicaciones a nivel empresarial
Existen en el mercado multitud de empresas que desarrollan software para llevar la
contabilidad de pequeñas y medianas empresas. Las grandes multinacionales utilizan, en
muchos casos, soluciones a medida pero las Pymes (pequeñas y medianas empresas) son un
gran sector a explotar a la hora de diseñar aplicaciones contables.
Existe una enorme cantidad de programas contables que se pueden descargar de
Internet gratuitamente (y legalmente). Hay programas que han de ser encargados a la
empresa responsable. Existen también otros que se pueden descargar gratuitamente pero
que para poder contar con ciertas opciones o servicios hace falta adquirir una licencia de la
compañía desarrolladora.
Hay que resaltar que el modelo contable difiere de unos países a otros por lo que es
normal que cada desarrolladora de software haga aplicaciones específicas para los modelos
contables de los distintos países. Se analizarán las aplicaciones orientadas a las empresas
españolas y que están adaptadas a las leyes contables españolas. Las aplicaciones que
dominan el mercado son de compañías españolas, ya que han sabido captar mejor el
modelo de gestión de la contabilidad en las pequeñas y medianas empresas españolas.
•
La aplicación con más fama en el sector es la denominada “ContaPlus” desarrollada
por la compañía SAGE SP que es el líder nacional en aplicaciones para pequeñas y
medianas empresas. Este programa se puede encontrar en diferentes modelos según
el nivel de funcionalidad o complejidad que se necesite en la empresa. Es la
herramienta más completa del mercado pero su manejo puede llegar a ser muy
9
complicado. Se pueden encontrar tutoriales o incluso cursos a aprendizaje sobre esta
aplicación. El precio de la aplicación fluctúa entre 150 € y 1500 € según la
funcionalidad de la aplicación y los servicios de soporte ofrecidos. SAGE SP
también desarrolla la aplicación “FacturaPlus” que, siguiendo las mismas directrices
que ContaPlus, se orienta más a controlar la facturación de una empresa.
•
Otra aplicación orientada a llevar la contabilidad de las pymes es “Contar”. Ha sido
desarrollada por la empresa “Grupo EI”. La versión actual de este software es la 3.0
que salió al mercado a finales del año 2002, por lo que la falta de actualización es
un punto en contra de esta aplicación. Se puede considerar una buena aplicación
para PYMES ya que abarca un amplio rango de funcionalidades que la contabilidad
de una PYME puede requerir pero sin excesivas complicaciones. Su precio varía
entre 50 € y 300 € según el nivel de funcionalidad requerido.
•
La empresa “Infoser sistemas” ha desarrollado el software “PowerGest” que
consiste en tres programas de contabilidad que trabajan sobre la misma base y que
se diferencian por su nivel de funcionalidad. PowerGest puede ser una solución
óptima ya que puede alcanzar una gran funcionalidad a un precio asequible en
relación con “ContaPlus”. Las tres variantes de PowerGest son:
o PowerGest Standard es una solución sencilla para pequeñas empresas.
Incorpora funciones de control de contabilidad y de control de facturación.
Su precio es de 150 €.
o PowerGest Profesional, orientado a PYMES. Abarca las mismas funciones
que la versión “Standard” Incluye además funciones de ayuda a la gestión de
10
la empresa y de sistema experto para la ayuda de toma de decisiones. Su
precio va de 350 € a 460 € según se incluya funcionalidad en red o no.
o PowerGest Master, orientado a PYMES. Tiene las mismas funciones que la
versión “Profesional” pero permite opciones más avanzadas. Sólo funciona
con distribución en red. Su precio es de 650 €.
•
La empresa “Soporte Multivendor” ofrece otra aplicación que sigue la línea de las
ya descritas. El nombre de la aplicación es “Gestión VARS” y es un programa muy
completo que permite interactuar con diferentes tipos de bases de datos y también
permite funcionamiento en red con arquitectura cliente/servidor así como enlace a
PDA’s. Incorpora procesador de textos y de hojas de cálculo y se acerca en calidad
a la aplicación ContaPlus. Se ofrecen múltiples opciones con el fin de que el usuario
elija su aplicación a medida. Los precios van desde 100 a 1500 € por mes según la
funcionalidad de la aplicación y el servicio técnico que se incluya.
•
La empresa “Golden Soft” desarrolla la aplicación “Visual Conta” que ha alcanzado
ya su versión 10.5. Su precio es completamente gratuito. El programa está orientado
a pequeñas empresas ya que no tiene suficiente envergadura para hacer frente a la
contabilidad de una empresa que no sea pequeña. Por ejemplo, el número de
asientos que se pueden añadir a un libro diario está limitado y no es muy elevado.
•
La empresa “Sistemas Multimedia y de Gestión, S.L.” ofrece software especializado
para empresas de tamaño mediano con multitud de diferentes opciones a elegir por
el usuario. Existen varias aplicaciones con distintos nombres (ContaSol, FactuSol,
TPVSol) dependiendo de la finalidad y opciones de su funcionamiento. La descarga
de las aplicaciones es completamente gratuita pero para disponer de todos los
11
servicios de la empresa (el más útil es el servicio de consultas técnicas) hace falta
registrarse para lo que hay que pagar entre 50 y 300 €/año según la aplicación que
se vaya a utilizar.
•
La empresa “EspaSoft” desarrolla software relacionado con las finanzas. Para llevar
la contabilidad de una empresa cuenta con la aplicación “WinConta”. No abarca
muchas funcionalidades y tiene un fácil manejo. El precio de registrar la aplicación
es de 60 euros.
•
La empresa AIG (Asesoría Informática Gallega) también se ocupa de desarrollar
aplicaciones de gestión de la contabilidad. Actualmente cuenta con dos
herramientas: ClassicGes y ClassicConta. ClassicGes está más orientado a lleva una
gestión íntegra de la empresa mientras que ClassicConta se centra en los estados
financieros de la empresa. Están orientados a empresas pequeñas y su funcionalidad
es limitada. Ambos tienen un precio de 60 €.
•
La empresa “GEYCE Grup” cuenta con la aplicación “J-Conta” que sigue la línea
de las aplicaciones ya descritas.
•
La empresa “Epsylon Sofá” ha desarrollado la herramienta “Winfac” que integra
gestión, facturación, contabilidad y cobros y pagos al mismo tiempo.
Otras aplicaciones, como GnuCash, se encargan de la contabilidad de las empresas a nivel
“internacional” sin tener en cuenta el plan general contable español por lo que no son
propicias para ser utilizadas por pymes españolas.
12
1.3.2 Aplicaciones a nivel docente
A diferencia de la gran cantidad de aplicaciones que se pueden encontrar para
gestionar los estados contables de las pymes, en la actualidad no existen herramientas o
aplicaciones que puedan ser utilizadas para enseñar contabilidad en el ámbito de la
docencia. A la hora de aprender contabilidad en las universidades o en cursos
especializados, los alumnos siempre trabajan con ejercicios que resuelven manualmente y
nunca de forma automatizada con ayuda de software.
13
CAPÍTULO 2
DISEÑO DE LA APLICACIÓN
2.1 Modelo lógico
2.1.1 Diagrama de Contexto
Opción elegida, info. empresa, nº cuenta,
fecha, operaciones
Usuario
Aplicación
Situación inicial, empresas, libros diarios,
resumen anual, ayuda, libro diario, balance
sumas/saldos, saldo cuenta, posibles
opciones
En el diagrama se puede observar como el usuario es la única entidad externa que
interactúa con la aplicación. Se considera flujo de datos la información que muestra la
aplicación por pantalla. Todo el flujo de datos entre el usuario y la aplicación es
información que muestra la aplicación por pantalla. El usuario va viendo a lo largo de la
ejecución de la aplicación toda la información que requiere por pantalla.
14
2.1.2 Diagrama de primer nivel (conceptual)
Opción elegida
Info. de la empresa
Posibles opciones
2. Crear
empresa y
libro diario
Código nueva empresa,
Código nuevo l.d.
1.
Obtener
Opción
Códigos, archivos de
ayuda, empresas
Nueva
empresa,
nuevo l.d.
Nueva empresa,
nuevo l.d.
Situación inicial
Empresas
L.d., empresas,
operac., asientos
Base de datos
Nuevos
asientos
3. Cargar
empresa y
l.d.
4.
Situación
inicial
Códigos de
asientos y
operaciones
Libro diario
Situación
inicial
Empresa
Libro diario
Archivos de
ayuda
Empresas,
libros d.
5.
Evolución
libro diario
Libro diario,
saldo cuenta,
sumas/saldos
7.
Mostrar
Ayuda
Nº Cuenta,
Fecha,
operaciones
Ayuda
15
Libro diario
modificado
Resumen
anual
6.
Resumen
Anual
El funcionamiento de la aplicación se puede dividir en siete procesos básicos:
•
Proceso 1: Obtener opción. La aplicación muestra el menú principal con las
diferentes opciones, de las cuales el usuario escoge una. Dependiendo de la opción
elegida se pasa al proceso 2 (pero antes calculando los códigos para la nueva
empresa y el nuevo libro diario que se van a crear), al proceso 3 (cargando la
información de todas las empresas desde la base de datos para pasárselas al proceso
3) o al proceso 7 (antes se cargan los documentos de ayuda para pasárselos al
proceso 7).
•
Proceso 2: Crear empresa y libro diario. Recibe la información de la nueva empresa
y registra en la base de datos la nueva empresa con el libro diario de su primer año
de funcionamiento.
•
Proceso 3: Cargar empresa y libro diario. Muestra las empresas existentes para que
el usuario seleccione la que quiere cargar. Después carga los libros diarios de la
empresa seleccionada para que el usuario seleccione el que quiera ver. Finalmente
carga los asientos (con sus operaciones) existentes para ese libro diario en la base de
datos y pasa esta información al proceso 5.
•
Proceso 4: Situación inicial. Si se ejecuta después del proceso 2 muestra la situación
inicial de la empresa recién creada. Si se ejecuta después del proceso 5 muestra la
situación inicial de la empresa a la que pertenece el libro diario que se estaba
visualizando. En cualquiera de los dos casos muestra la situación inicial de la
empresa y permite al usuario modificarla.
16
•
Proceso 5: Evolución del libro diario. Se muestra por pantalla el libro diario que
recibe del proceso 4 o del proceso 3. Antes de mostrarlo debe calcular el asiento de
apertura y añadirlo al libro diario. Además permite añadir nuevos asientos con
operaciones al libro diario. Para ello toma de la base de datos los códigos de los
asientos y de las operaciones con el fin de calcular los códigos para los nuevos
asientos y operaciones. Permite borrar o añadir asientos al libro diario para lo que
recibe la información del asiento y sus operaciones del usuario. Por último permite
mostrar al usuario el balance de sumas y saldos provisional y los saldos de cuentas
específicas (recibe el nº de cuenta del usuario).
•
Proceso 6: Resumen anual. Recibe un libro diario, calcula sus asientos de cierre y
genera un documento con el libro diario, libro mayor y balances de comprobación.
Muestra este documento por pantalla.
•
Proceso 7: Mostrar ayuda. Muestra los diferentes documentos con la información de
ayuda al usuario.
A continuación se mostrarán los DFD de nivel 2 en los que se pueden ver los
subprocesos de cada uno de estos siete procesos, a excepción del proceso 7 que, por su
simplicidad, no hace falta descomponerlo en subprocesos
17
2.1.3 Diagramas de Nivel 2
Diagrama de Nivel 2 para el proceso 1 (Obtener Opción)
Posibles opciones
1. 1 Leer
Opción de
Menú
principal
Opción elegida
Opción
Opción
1.2 Cargar
archivos de
ayuda
Opción
Archivos de
ayuda
1.4
Calcular
código
empresa
Archivos de ayuda
1.3 Cargar
empresas
Empresas
Códigos de
empresas
Base de datos
Códigos de
libros diarios
Empresas
Código nueva
empresa, código de
nuevo l.d.
18
Código nueva
empresa
1.5
Calcular
código
l.d.
Diagrama de nivel 2 para el proceso 2 (Crear empresa y libro diario)
Info. de la empresa
2.1 Leer
info. de
la
empresa
Código nueva
empresa, código nuevo
libro diario
Info. de la empresa
2. 2 Crear
nueva
empresa
Nueva empresa
Nueva empresa
Opción
Base de datos
Nuevo libro
diario
2.3 Crear
nuevo
libro
diario
Nuevo libro
diario
19
Diagrama de Nivel 2 para el proceso 3 (Cargar empresa y libro
diario)
Empresas
Empresas
3.1
Mostrar
empresas
Empresa
Datos de empresa selec.
3.2
Mostrar
empresa
selec.
Libros diarios
Libros diarios
Datos
empresa
3.3
Modificar
datos de
empresa
3.4
Mostrar
libros
diarios
Libros diarios
Datos
empresa
modificados
Libros
diarios
selec.
Libro diario
selec.
Base de datos
Asientos,
operaciones
Libro d. con
asientos y
operaciones
20
Libros diarios
3.6 Cargar
libro
diario
3.5
Modificar
fechas
libros d.
Diagrama de Nivel 2 para el proceso 4 (Situación inicial)
Nueva empresa, nuevo l.d.
Libro diario
Situación
inicial
4.1
Mostrar
Situación
inicial
Situación inicial
Situación inicial
modificada
Empresa
Situación
inicial
4.2
Modificar
situación
inicial
Situación inicial
modificada
Base de datos
21
Diagrama de Nivel 2 para el proceso 5 (Evolución libro diario)
Libro diario
Libro diario
5.1
Añadir
asiento de
apertura
Libro diario (se ha
incluido el asiento
de apertura)
5.2
Mostrar
libro
diario
Código nuevo asiento, código
nuevas operaciones
5.3 Crear
Libro diario
5.3
Mostrar
saldo de
cuenta
Nº cuenta
asiento
Nuevo asiento
Códigos de
asientos y
operaciones
Libro diario
Saldo cuenta.
Fecha y
operaciones
Empresa
5.4 Mostrar
balance
sumas
/saldos
Balance
sumas/saldos
22
Nuevo asiento
Base de datos
Diagrama de Nivel 2 para el proceso 6 (Resumen Anual)
Libro diario
6.1
Añadir
asientos
de cierre
Libro diario (con asientos de cierre)
Resumen anual
Resumen
anual
6.3
Mostrar
Resumen
Anual
23
6.2
Generar
resumen
anual
2.2 Arquitectura/Tecnología de la aplicación
La aplicación está basada enteramente en la arquitectura .NET. La principal razón
para utilizar .NET es debido a la potencia que ofrece a la hora de programar,
especialmente en combinación con C# que ha sido el lenguaje elegido para
desarrollar esta aplicación. La aplicación tiene todos sus niveles (datos, aplicación y
presentación) en el ordenador del usuario. Se planteó llevar a cabo una arquitectura
cliente-servidor pero se desechó por los siguientes motivos:
•
Es una aplicación que está basada en un ejecutable y no requiere instalación.
•
Es una aplicación que debe funcionar en varios lugares de trabajo. Por ejemplo en
las aulas de ordenadores de la facultad o en los ordenadores personales que los
alumnos tengan en sus domicilios.
•
La base de datos encargada de gestionar todos los datos de las ejecuciones de la
aplicación adquiriría un gran tamaño innecesariamente y sería difícil de gestionar si
fuera una base de datos centralizada.
•
Las necesidades de la aplicación no requieren un modelo cliente-servidor. El
alumno podrá realizar su ejercicio en cualquier lugar y finalmente entregar al
profesor los documentos con los resúmenes anuales para que realice su corrección.
Por ello y pensando en el fácil manejo de la aplicación y de su portabilidad se ha optado
porque cada alumno pueda llevar, junto con el ejecutable de la aplicación, una pequeña
base de datos en Microsoft Access donde guarde sus ejercicios.
A la hora de decidir la tecnología a utilizar en la aplicación se barajó la posibilidad
de utilizar otros lenguajes que posibilitan programación visual. Finalmente se decidió por
24
utilizar C# con .NET frente a JAVA por ser un lenguaje que incorpora las mismas
funcionalidades de JAVA incluyendo ventajas a la hora de la programación o el diseño. La
plataforma .NET también permite realizar aplicaciones con un interfaz similar al que se
utiliza en otros programas de Windows por lo que puede resultarle más familiar y de
manejo más fácil a los alumnos que vayan a utilizar la presente aplicación (que, en un
principio, serán los alumnos de primer curso de las titulaciones IINF e ITIG).
Frente a otros lenguajes de programación que utilizan la plataforma .NET se ha
elegido C# ya que es el más potente de todos y que consigue sacar todo el beneficio que
puede aportar .NET. Esto se debe a que es un lenguaje que fue creado por una razón:
funcionar por y para .NET.
Con el fin de desarrollar la base de datos e interactuar con ella se ha optado por
utilizar Microsoft Access. A pesar de ser uno de los gestores menos potentes, es capaz de
satisfacer todas las necesidades de la aplicación de una forma sencilla.
25
2.3 Diseño de entradas y salidas
Se mostrarán los interfaces diseñados para la entrada o salida de datos a la
aplicación. Estos interfaces se han realizado con el diseñador de interfaces de la plataforma
.NET. Una vez diseñados, se implementarán todas sus funciones más adelante.
2.3.1 Diseño de ventanas
DISEÑO DE VENTANA 1
Nombre: Menú Principal
Descripción: Permite al usuario escoger una opción de funcionamiento sobre todas las
que presenta la aplicación.
Tipo: Entrada (recibe opción) / Salida (muestra posibles opciones)
Ventanas a las que llama: 2, 3, 11 y 13
Diseño:
26
DISEÑO DE VENTANA 2
Nombre: Ficha de la empresa
Descripción: Permite recibir los datos de la nueva empresa del usuario o mostrar los
datos de una empresa ya existente para que puedan ser modificados
Ventanas a las que llama: 1, 3, 5 y 11
Tipo: Entrada / Salida
Diseño:
27
DISEÑO DE VENTANA 3
Nombre: Empresas existentes
Descripción: Muestra la información de todas las empresas existentes en la base de
datos.
Ventanas a las que llama: 1, 2, 4, 5 y 11
Tipo: Salida
Diseño:
28
DISEÑO DE VENTANA 4
Nombre: Libros diarios de una empresa
Descripción: Muestra la información de una empresa y todos sus libros diarios.
Ventanas a las que llama: 1, 2, 3, 5, 6 y 11
Tipo: Salida
Diseño:
29
DISEÑO DE VENTANA 5
Nombre: Situación inicial de una empresa
Descripción: Muestra situación inicial de la empresa dando la posibilidad de
modificarla.
Ventanas a las que llama: 1, 2, 3, 4, 6, 10a y 11.
Tipo: Entrada / Salida
Diseño:
30
DISEÑO DE VENTANA 6
Nombre: Evolución de un libro diario
Descripción: Muestra todos los asientos (con sus operaciones) de un libro diario.
Ventanas a las que llama: 1, 2, 3, 4, 5, 7, 8, 11 y 12
Tipo: Salida
Diseño:
31
DISEÑO DE VENTANA 7
Nombre: Saldo de una cuenta
Descripción: Muestra todas las operaciones de una cuenta en un libro diario con su saldo total.
Ventanas a las que llama: Ninguna
Tipo: Salida
Diseño:
32
DISEÑO DE VENTANA 8
Nombre: Balance de sumas y saldos
Descripción: Muestra el balance de sumas y saldos provisional de un libro diario.
Ventanas a las que llama: Ninguna
Tipo: Salida
Diseño:
33
DISEÑO DE VENTANA 9
Nombre: Añadir asiento
Descripción: Permite al usuario introducir las operaciones y la fecha de un asiento.
Ventanas a las que llama: 1, 2, 3, 6, 10a y 11
Tipo: Entrada
Diseño:
34
DISEÑO DE VENTANA 10a
Nombre: Cuadro de Cuentas
Descripción: Muestra todas las cuentas del Plan General Contable.
Ventanas a las que llama: 10b
Tipo: Salida
Diseño:
35
DISEÑO DE VENTANA 10b
Nombre: Cuadro de Cuentas por orden alfabético
Descripción: Muestra todas las cuentas del plan general contable pero ordenadas por orden
alfabético.
Ventanas a las que llama: Ninguna
Tipo: Salida
Diseño:
36
DISEÑO DE VENTANA 11
Nombre: Ayuda
Descripción: Muestra todos los documentos de ayuda que proporciona la aplicación.
Ventanas a las que llama: Ninguna
Tipo: Salida
Diseño:
37
DISEÑO DE VENTANA 12
Nombre: Resumen Anual
Descripción: Muestra el documento generado como resumen de la actividad contable de la
empresa en un año. El contenido del documento se expondrá cuando se explique el documento
como un informe.
Ventanas a las que llama: 1, 2, 3, 4, 6 y 11
Tipo: Salida
Diseño:
38
DISEÑO DE VENTANA 13
Nombre: Acerca de la aplicación
Descripción: Muestra información sobre la creación de la aplicación.
Ventanas a las que llama: Ninguna
Tipo: Salida
Diseño:
39
2.3.2 Diseño de informe
DISEÑO DE INFORME 1
Nombre: Resumen anual
Descripción: Es el documento generado como resumen de la actividad contable de la empresa en un
año. Será un archivo con extensión .rtf y que estará preparado para abrirse con el programa Word de
Microsoft Office. Contiene el libro diario, el libro mayor y los balances de comprobación de la
empresa
Tipo: Salida
Diseño: A continuación se muestra un ejemplo de cómo puede ser el documento
LIBRO DIARIO (Año 2001)
N As
Fecha
N Cuenta
Debe
1
01/01/2001
200
202
2000
2000
2
01/01/2001
570
1000
01/01/2001
600
1000
600
400
4
01/01/2001
200
01/01/2001
220
6
01/01/2001
200
20/01/2001
226
50
Gastos de constitución.
a
Caja, euros.
1000
100
100
7
600
1000
570
100
1000
Caja, euros.
a
Deudas a corto plazo con entida.
Compras de mercaderías.
a
Proveedores.
50
570
5
Cuentas
Gastos de constitución.
Gastos de ampliación de capital.
a
100
2000
Capital social.
102
1000
Capital.
410
1000
Acreedores por prestaciones de s.
------- Apertura de Balance -------
520
3
Haber
Terrenos y bienes naturales.
a
Caja, euros.
Gastos de constitución.
a
Capital social.
Mobiliario.
a
40
570
8
1000
25/01/2001
4000
10000
472
1600
(Explicación: IVA sobre cuenta 4000)
Caja, euros.
Proveedores (euros).
Hacienda Pública, IVA soportado.
a
155
10000
477
1600
(Explicación: IVA sobre cuenta 155)
9
23/03/2001
226
500
570
10
28/04/2001
300
500
Deudas representadas en otros va.
Hacienda Pública, IVA repercutid.
Mobiliario.
a
Caja, euros.
600
Mercaderías A.
a
610
600
Variación de existencias de merc.
(Explicación: Recuento físico y valoración de existencias a fin de
ejercicio)
-----20450
-----20450
11
31/12/2001
610
600
Variación de existencias de merc.
a
129
600
Pérdidas y ganancias.
------- Cierre de cuentas temporales (p y g) al haber -------
12
31/12/2001
129
600
Pérdidas y ganancias.
a
600
600
Compras de mercaderías.
------- Cierre de cuentas temporales (p y g) al debe -----------21650
-----21650
13
31/12/2001
100
102
155
400
410
477
520
570
200
202
220
226
2100
1000
10000
600
1000
1600
1000
1550
2150
2000
1000
1500
41
Capital social.
Capital.
Deudas representadas en otros va.
Proveedores.
Acreedores por prestaciones de s.
Hacienda Pública, IVA repercutid.
Deudas a corto plazo con entida.
Caja, euros.
a
Gastos de constitución.
Gastos de ampliación de capital.
Terrenos y bienes naturales.
Mobiliario.
300
600
Mercaderías A.
472
1600
Hacienda Pública, IVA soportado.
4000
10000
Proveedores (euros).
------- Cierre de cuentas permanente -----------40500
Total debe
Total haber
-----40500
LIBRO MAYOR (Año 2001)
100. Capital social
2100 (13)
100 (6)
2000 (1)
102. Capital
1000 (13)
1000 (1)
129. Pérdidas y ganancias
600 (12)
600 (11)
155. Deudas representadas en otros valores negociables
10000 (13)
10000 (8)
200. Gastos de constitución
50 (4)
2150 (13)
100 (6)
2000 (1)
202. Gastos de ampliación de capital
2000 (1)
2000 (13)
220. Terrenos y bienes naturales
1000 (5)
1000 (13)
226. Mobiliario
42
1000 (7)
500 (9)
1500 (13)
300. Mercaderías A
600 (10)
600 (13)
400. Proveedores
600 (13)
600 (3)
4000. Proveedores (euros)
10000 (8)
10000 (13)
410. Acreedores por prestaciones de servicios
1000 (13)
1000 (1)
472. Hacienda Pública, IVA soportado
1600 (8)
1600 (13)
477. Hacienda Pública, IVA repercutido
1600 (13)
1600 (8)
520. Deudas a corto plazo con entidades de crédito
1000 (13)
1000 (2)
570. Caja, euros
1000 (2)
1550 (13)
50 (4)
1000 (5)
1000 (7)
500 (9)
600. Compras de mercaderías
600 (3)
600 (12)
610. Variación de existencias de mercaderías
600 (11)
600 (10)
43
BALANCE DE COMPROBACION (Año 2001)
Antes del cierre de las cuentas de ingresos y gastos
SUMAS
NºCuenta
100
102
155
200
202
220
226
300
400
4000
410
472
477
520
570
600
610
TOTALES:
Debe
SALDOS
Haber
Deudor
Acreedor
0
0
0
2150
2000
1000
1500
600
0
10000
0
1600
0
0
1000
600
0
2100
1000
10000
0
0
0
0
0
600
0
1000
0
1600
1000
2550
0
600
0
0
0
2150
2000
1000
1500
600
0
10000
0
1600
0
0
0
600
0
2100
1000
10000
0
0
0
0
0
600
0
1000
0
1600
1000
1550
0
600
20450
20450
19450
19450
Nombre de la Cuenta
Capital social.
Capital.
Deudas representadas en .
Gastos de constitución.
Gastos de ampliación de .
Terrenos y bienes natura.
Mobiliario.
Mercaderías A.
Proveedores.
Proveedores (euros).
Acreedores por prestacio.
Hacienda Pública, IVA so.
Hacienda Pública, IVA re.
Deudas a corto plazo co.
Caja, euros.
Compras de mercaderías.
Variación de existencias.
BALANCE DE COMPROBACION (Año 2001)
Después del cierre de las cuentas de ingresos y gastos
SUMAS
NºCuenta
100
102
129
155
200
202
220
226
300
400
4000
410
472
Debe
0
0
600
0
2150
2000
1000
1500
600
0
10000
0
1600
SALDOS
Haber
Deudor
Acreedor
2100
1000
600
10000
0
0
0
0
0
600
0
1000
0
0
0
0
0
2150
2000
1000
1500
600
0
10000
0
1600
2100
1000
0
10000
0
0
0
0
0
600
0
1000
0
44
Nombre de la Cuenta
Capital social.
Capital.
Pérdidas y ganancias.
Deudas representadas en .
Gastos de constitución.
Gastos de ampliación de .
Terrenos y bienes natura.
Mobiliario.
Mercaderías A.
Proveedores.
Proveedores (euros).
Acreedores por prestacio.
Hacienda Pública, IVA so.
477
520
570
600
610
TOTALES:
0
0
1000
600
600
1600
1000
2550
600
600
0
0
0
0
0
1600
1000
1550
0
0
21650
21650
18850
18850
45
Hacienda Pública, IVA re.
Deudas a corto plazo co.
Caja, euros.
Compras de mercaderías.
Variación de existencias.
2.4 Modelo lógico de datos
Nuestro modelo de datos va a constar de cinco entidades y cuatro relaciones entre
ellas. Las entidades con sus atributos son:
•
EMPRESA. Representa cualquier empresa que puede crear el usuario y sobre cuyos
libros diarios puede operar. Tiene los siguientes atributos:
o Código de empresa: es un número entero no negativo que será el
identificador de la empresa. Este atributo es la clave principal de la entidad.
o Nombre: es el nombre de la empresa. Incluye una terminación del tipo S.L.
o S.A. para indicar el tipo jurídico de sociedad que es la empresa. Es un
campo alfanumérico.
o Creador: es el nombre del usuario que ha creado la empresa. Es un campo
alfanumérico.
o Inicio: es el primer año de funcionamiento de la empresa. Es un entero cuyo
valor estará comprendido entre 1950 y 2100.
•
ESTADO. Representa el estado de una cuenta en la situación inicial de la empresa.
Habrá un estado por cada cuenta cuyo saldo no sea nulo antes de comenzar el
funcionamiento de la empresa en el año ‘0’. Tiene los siguientes atributos:
o Código de estado: es un número entero no negativo que es el identificador
del estado. Este atributo es la clave principal de la entidad.
o Nombre de cuenta: es el nombre de la cuenta sobre la que se representa un
saldo inicial distinto de 0. Es un campo alfanumérico.
46
o Nº de cuenta: es el número de la cuenta sobre la que se representa un saldo
inicial distinto de 0. Es un entero con valor comprendido entre 100 y 8000.
o Cantidad: representa el saldo de la cuenta. Es un número en coma flotante
cuyo valor máximo es de un billón.
o Tipo: representa si el estado está anotado en la columna del “Debe” o del
“Haber” en la situación inicial de la empresa. Es un campo alfanumérico que
sólo puede tomar los valores “Debe” o “Haber”.
o Código de empresa: es un número entero no negativo que representa la
empresa a la que pertenece el estado.
•
LIBRO DIARIO. Representa cada uno de los libros diarios de una empresa. Recoge
los hechos contables de una empresa a lo largo de un año. Tiene los siguientes
atributos:
o Código de libro diario: es un número entero no negativo que es el
identificador del libro diario. Este atributo es la clave principal de la entidad.
o Año: es el año de funcionamiento de la empresa al que corresponde este
libro diario. Es un entero cuyo valor estará comprendido entre 1950 y 2100.
o Código empresa: es un número entero no negativo que representa la
empresa a la que pertenece el libro diario.
•
ASIENTO. Representa un asiento contable que es un “registro de una operación real
o virtual en el libro correspondiente”. Tiene los siguientes atributos:
o Número de asiento: es un entero no negativo que identifica al asiento. Este
atributo es la clave principal de la entidad.
47
o Fecha: es un campo de tipo fecha que indica la fecha del año del libro diario
a la que pertenece el asiento.
o Código de libro diario: es un número entero no negativo que representa el
libro diario al que pertenece el asiento.
•
OPERACIÓN. Entendida como la unidad elemental de un hecho contable.
Representa una variación en el saldo de una cuenta. Tiene los siguientes atributos:
o Código de operación: es un entero no negativo que identifica a la
operación. Este atributo es la clave principal de la entidad.
o Tipo: representa si la operación afecta al “debe” o al “haber” de la cuenta.
Es un campo alfanumérico que sólo puede tomar los valores “Debe” o
“Haber”.
o Valor: es la cantidad en la que se modifica el saldo de la cuenta con la
operación. Es un número en coma flotante cuyo valor máximo es de un
billón.
o Nº de cuenta: es la cuenta sobre la que se modifica el saldo en la operación.
Es un entero con valor comprendido entre 100 y 8000.
o Explicación: es un campo alfanumérico que contiene una explicación que el
usuario puede dar opcionalmente a la explicación.
o Código de asiento: es un número entero no negativo que representa el
asiento al que pertenece la operación.
48
A continuación se muestra un diagrama donde se pueden ver las relaciones lógicas entre las
cinco entidades de nuestro modelo lógico de datos:
1
Empresa
M
Tiene
Libro Diario
1
1
Inicia
con
Contiene
N
N
Estado
Asiento
1
Formado
por
M
Operación
49
Las cuatro relaciones que se ven en el diagrama son:
•
“Inicia con”. Indica la relación entre las entidades de “Empresa” y de “Estados”.
Cada empresa puede tener cero o varios (cardinalidad N) estados para expresar su
situación inicial. Un estado siempre ha de tener una empresa a la que pertenece (y
no más).
•
“Tiene”. Representa la relación entre las entidades “Empresa” y “Libro diario”.
Una empresa siempre ha de tener uno o más (cardinalidad M) libros diarios. Es
obligatorio que posea el libro diario de su primer año de funcionamiento. Un libro
diario siempre ha de tener una empresa a la que pertenecer (y no a más).
•
“Contiene”. Es la relación existente entre las entidades de “Libro diario” y
“Asiento”. Un libro diario contiene cero o varios asientos. Un asiento siempre ha de
pertenecer a un libro diario (y no a más).
•
“Formado por”. Representa la relación entre las entidades de “Asiento” y
“Operación”. Un asiento siempre tiene que estar compuesto por una o más
operaciones; no puede existir un asiento sin operaciones. Una operación siempre ha
de pertenecer a uno, y sólo un, asiento.
50
CAPÍTULO 3
PROGRAMACIÓN
3.1 Modelo físico de datos
3.1.1 Base de datos en Access
Se va a trabajar con una base de datos de Microsoft Access por su simplicidad y su fácil
manejo, además de adaptarse a las necesidades de la aplicación. La aplicación va a guardar
todos sus datos en una base de datos denominada “bbdd”, que está constituida por cinco
tablas que representan las entidades expuestas en el modelo lógico de datos. Para mostrar
los campos de las tablas se utilizará la definición de la tabla realizada con Microsoft
Access.
Las cinco tablas son:
•
La tabla “Empresas” con los siguientes campos:
•
La tabla “Estados” con la siguiente estructura:
51
•
La tabla “LibrosDiarios” con los campos siguientes:
•
La tabla “Asientos” con los siguientes campos:
•
La tabla “Operaciones” con la estructura:
52
3.1.2 DataSets empleados en C# .NET
A continuación se explicarán los conjuntos de datos utilizados en la programación de la
aplicación. Un “DataSet” es un conjunto de datos utilizado por la plataforma .NET que
permite albergar datos que vienen de XML. De hecho un “DataSet” permite la
posibilidad de definir visualmente un esquema de datos en XML y hacer que se genere
un modelo de objetos en torno a él.
Para llevar a cabo la aplicación han hecho falta seis datasets o conjuntos de datos
diferentes:
•
DataSet1. Se utiliza para realizar la carga de los datos al iniciar la aplicación (en el
formulario del menú principal). Es el conjunto de datos que más se va a utilizar en
toda la aplicación. Sirve para manejar todas las tablas de la base de datos. Su
esquema es el siguiente:
53
•
DataSet2. Se utiliza en el formulario de “Añadir Asiento” con el fin de mostrar las
operaciones que se van a añadir al debe y al haber de un asiento. Cuenta con un sola
tabla y el siguiente esquema:
•
DataSet3. Se utiliza en el formulario de “Evolución del libro diario” para mostrar
todos los asientos de un libro diario. Cuentan con una sola tabla y su esquema es el
siguiente:
•
DataSet4. Se utiliza en el formulario de “Situación inicial”. Sirve para cargar los
estados iniciales en las columnas del “haber” y del “debe”. Su estructura es la
siguiente:
54
•
DataSet5. Se utiliza en el formulario de “Balance de sumas y saldos” y en el de
“Resumen anual” con el fin de cargar los balances sobre su estructura. Este conjunto
de datos está formado por la siguiente tabla:
•
DataSet6. Se utiliza en el formulario de “Libros Diarios de la empresa” con el fin
de mostrar los libros diarios existentes para una empresa. La estructura del conjunto
de datos es la siguiente:
55
3.2 Explicación de la programación
En esta sección no se pretende realizar una explicación extensa de todo el código
sino resaltar de cada clase o formulario los aspectos más característicos de su
programación. En primer lugar se van a analizar aquellas clases que no implementan
controles visuales pero que serán instanciadas y/o cuyos métodos serán utilizados desde los
formularios de la aplicación.
3.2.1 Clases
3.2.1.1 La clase “Conexión”
Es la que permite cargar todos los datos de la base de datos al iniciar la aplicación
para que se puedan manejar y actualizar a lo largo del funcionamiento de la aplicación. Se
creará una instancia de “Conexión” al iniciar el formulario del “Menú principal”; dicha
instancia será pasada como argumento de entrada a todos aquellos formularios que
necesiten acceso a la base de datos a lo largo del funcionamiento de la aplicación.
La clase “Conexión” tiene los siguientes atributos:
•
Un DataSet sobre el que se cargará toda la información de la base de datos. Su
nombre será “data”.
•
Un DataAdapter del tipo OleDb para acceder a la tabla de Empresas. Su nombre
será “a_empresas”.
•
Un DataAdapter del tipo OleDb para acceder a la tabla de Estados. Su nombre será
“a_estados”.
56
•
Un DataAdapter del tipo OleDb para acceder a la tabla de Asientos. Su nombre será
“a_asientos”.
•
Un DataAdapter del tipo OleDb para acceder a la tabla de LibrosDiarios. Su nombre
será “a_librosdiarios”.
•
Un DataAdapter del tipo OleDb para acceder a la tabla de Operaciones. Su nombre
será “a_operaciones”.
3.2.1.2 La clase “LibroDiario”
Representa a un libro diario con sus atributos básicos, sin incluir sus asientos u
operaciones. Esta clase simplemente permite crear instancias en las que estén almacenados
el código del libro diario, el año al que pertenece el libro diario y el código de empresa al
que pertenece el libro diario. También tiene implementados métodos para obtener el valor
de estos tres atributos.
3.2.1.3 La clase “Empresa”
Representa a una empresa con sus atributos básicos que son su código, su nombre,
su creador, su año de inicio y el tipo jurídico de sociedad que es. También se implementan
métodos que devuelven los valores de estos atributos.
57
3.2.1.4 La clase “CloseButton”
Esta clase recibe un formulario como argumento y se encarga de desactivar el botón
de cierre (la X blanca sobre fondo rojo) de la esquina superior derecha del formulario. De
esta forma sólo se podrá salir de la aplicación mediante la opción “Salir de la aplicación”
habilitada en uno de los menús del formulario.
3.2.1.5 La clase “AdvRichTextBox”
Esta clase define una nueva clase que hereda de la clase “RichTextBox” e
implementa la posibilidad de justificar (en referencia a su alineación) el texto que muestra.
De esta forma, a la hora de mostrar documentos en la aplicación con en el caso de las
ayudas, éstos podrán tener una alineación justificada del texto.
3.2.1.6 La clase “Global”
En esta clase se definen una serie de métodos que serán utilizados en varios de los
formularios de la aplicación. A continuación se analizan estos métodos uno a uno:
•
El método “CurrentRow”. Recibe un datagrid como argumento y devuelve la fila
del datagrid que está seleccionada. De esta forma cada vez que se quiera cargar o
eliminar los datos de una fila seleccionada por el usuario en un datagrid se llamará a
este método. Su código es el siguiente:
public static DataRow CurrentRow(DataGrid aGrid)
{
58
CurrencyManager xCM
=(CurrencyManager)aGrid.BindingContext[aGrid.DataSource,
aGrid.DataMember];
DataRowView xDRV = (DataRowView)xCM.Current;
return xDRV.Row;
}
•
El método “quitarTildes”. Recibe una cadena de caracteres como argumento de
entrada y devuelve una cadena con los mismos caracteres que la de entrada, pero sin
tildes. Este método se utiliza cuando se quiere mostrar un texto en formato .rtf sobre
una “RichTextBox”. El código es el siguiente:
public static string quitarTildes(string cadena)
{
char[] c = cadena.ToCharArray ();
int i=0;
while(i<c.Length)
{
if(c[i]==’á’)
{
c[i]=’a’;
}
if(c[i]==’é’)
{
c[i]=’e’;
}
if(c[i]==’í’)
{
c[i]=’©’;
}
if(c[i]==’ó’)
{
c[i]=’o’;
}
if(c[i]==’ú’)
{
c[i]=’u’;
}
i++;
}
string s=new string(c);
return s;
}
•
El método “esCuenta67”. Recibe un entero con un número de cuenta y devuelve
un 0 cuando la cuenta no es del grupo 6 o del grupo 7, y un 1 cuando sí lo es. Este
método se utiliza, por ejemplo, cuando se quiere generar un asiento de cierre de
59
cuentas temporal y sólo se quiere contabilizar las cuentas de pérdidas y ganancias.
La implementación del método es:
public static int esCuenta67(int cuenta)
{
int resultado=0;
if (cuenta>1000)
{
if((cuenta>5999)&&(cuenta<8000))
{
resultado = 1;
}
}
else
{
if((cuenta>599)&&(cuenta<800))
{
resultado = 1;
}
}
return resultado;
}
•
El método “comprobarNúmero”. Se utiliza para saber si una cadena de caracteres
contiene un número o no. Devuelve un 1 en caso afirmativo y un 0 en caso
contrario. Este método es empleado para comprobar que el usuario rellena los
campos numéricos con valores correctos. Su código es el siguiente:
public static int comprobarNúmero(string st)
{
char[] ch = st.ToCharArray();
int lon = ch.Length;
int z;
int numero=1;
for(z=0; z<lon; z++)
{
if((Convert.ToUInt16(ch[z])>57) ||
(Convert.ToUInt16(ch[z])<48))
{
numero=0;
}
}
return numero;
}
60
•
El método “comprobarNúmeroNegativo”. Recibe una cadena de caracteres con
un número y devuelve un 1 si ese número es negativo o 0 si no es negativo. Su
código es:
public static int comprobarNúmeroNegativo(string st)
{
char[] ch = st.ToCharArray();
int lon = ch.Length;
int z;
int numero=1;
if(ch[0]!=’-‘)
{
numero=0;
}
for(z=1; z<lon; z++)
{
if((Convert.ToUInt16(ch[z])>57) ||
(Convert.ToUInt16(ch[z])<48))
{
numero=0;
}
}
return numero;
}
•
El método “getInfoCuenta”. Este método recibe un número entero con un número
de cuenta y devuelve un string con el nombre de esa cuenta en el Plan general
contable y otro string que contiene el tipo de la cuenta. Esta cadena de tipo de la
cuenta puede contener los valores activo, pasivo, ingreso o gasto, y, en caso de que
la cuenta sólo soporte valores negativos, el tipo irá entre paréntesis (por ejemplo un
activo negativo sería “(Activo)”. Se muestra el código reducido (ya que necesita
especificar todas las cuentas del plan general contable y esto requiere un gran
número de líneas de código):
public static string[] getInfoCuenta(int n_cuenta)
{
string[] info = new string[2];
string nombre;
string tipo=””;
61
switch(n_cuenta)
{
case 100:
nombre=”Capital
tipo=”Pasivo”;
break;
case 1000:
nombre=”Capital
tipo=”Pasivo”;
break;
case 1001:
nombre=”Capital
tipo=”Pasivo”;
break;
case 1002:
nombre=”Capital
tipo=”Pasivo”;
break;
case 1003:
nombre=”Capital
tipo=”Pasivo”;
break;
social”;
ordinario”;
privilegiado”;
sin derecho a voto”;
con derechos restringidos”;
(…)
case 7991:
nombre=”Exceso de provisión para insolvencias de
créditos a corto plazo de empresas asociadas”;
tipo=”(Gasto)”;
break;
case 7993:
nombre=”Exceso de provisión para insolvencias de
créditos a corto plazo de otras empresas”;
tipo=”(Gasto)”;
break;
default:
nombre=””;
tipo=””;
break;
}
info[0]=nombre;
info[1]=tipo;
return info;
}
•
El método “adaptarLibros”. Es el método que recalcula los asientos de apertura y
de cierre de los libros diarios. Este método es llamado antes de mostrar el
formulario de “Evolución de un libro diario” ya que se necesita el asiento de
apertura del libro diario, y antes de llamar al formulario de “Resumen anual”, ya
62
que para escribir el libro diario, el libro mayor y los balances es preciso que los
asientos de apertura y de cierre sean correctos. Debido a la cantidad de operaciones
que debe realizar este método es posible que su tiempo de ejecución pueda llegar
hasta los 10 segundos (en un caso extremo). Debido a la gran extensión en líneas de
código de este método, simplemente se va a exponer lo que hace este método para
generar los asientos de apertura y de cierre:
Sobre un bucle “for” se van a recorrer todos los libros diarios de la empresa. En
cada iteración se realizará lo siguiente:
o Se borra el asiento de apertura existente para ese libro diario.
o Se crea un nuevo asiento de apertura. En caso de que el libro diario sea el del
primer año de funcionamiento de la empresa, se generará el asiento de
apertura basándose en los estados definidos para la situación inicial de la
empresa. En caso de que el libro diario pertenezca a un año posterior al de
inicio de la empresa, se tomará el asiento de cierre de cuentas permanente del
año anterior y se invertirán operaciones de “debe” por operaciones de “haber”
y con ellas se creará el asiento de apertura. Esto se debe a que el asiento de
cierre de cuentas permanente del año N es igual al asiento de apertura del año
N+1 pero tomando todos los valores de la columna del “debe” y pasarlos a la
columna del “haber” y viceversa.
o Se eliminan todos los asientos de cierre de cuentas del libro diario.
o Se rehacen los asientos de cierre de cuentas. En primer lugar se recorren las
operaciones de las cuentas de los grupos 6 y 7 de los asientos del libro diario.
Con estas operaciones se crean los asientos de cierre de cuentas temporales
63
generando cada uno la correspondiente operación que modifica el saldo de la
cuenta 129. A continuación se recorren todas las operaciones de los asientos
del libro diario que no son del grupo 6 o 7 y se genera el asiento de cierre de
cuentas permanente. Con este asiento el saldo final de cada cuenta queda con
valor nulo (este asiento no se contabiliza a la hora de calcular el balance de
sumas y saldos del libro diario).
3.2.2 Los Formularios
Se va a explicar los aspectos más relevantes de la programación de cada formulario.
No se muestran los interfaces de los formularios ya que éstos se pueden ver en el diseño de
entradas y salidas citado anteriormente. También se explica detenidamente la funcionalidad
resultante de cada formulario con relación al funcionamiento de la aplicación; esto se puede
ver en el Manual de Usuario. Se procura no caer en explicaciones repetitivas sobre aspectos
del código, por lo que en cada formulario sólo se explicará el código que no sea similar y
no realice las mismas funciones que el código ya explicado de formularios anteriores. No se
va a explicar la forma o el funcionamiento de los elementos denominados “Windows
Forms” ya que viene definida por el paquete de la plataforma .NET (Ver anexo A).
3.2.2.1 “Menú principal”
Es el formulario con el que arranca el programa. Tiene definidos cinco
“OledbDataAdapters” para cargar cada una de las tablas de la base de datos sobre un
64
DataSet de tipo DataSet1. Estos cinco elementos formarán una instancia del tipo
“Conexión” (citada anteriormente) que recibirá el nombre de “conect” y que pasarán como
argumento a los formularios que llamen y que necesiten tener acceso a información de la
base de datos. A su vez, los futuros formularios que se vayan ejecutando pasarán esta
instancia del tipo “Conexión” a los formularios a los que llamen y que necesiten acceso a la
base de datos. Las sentencias SQL utilizadas en los “OledbDataAdapters” para cargar los
datos en el “DataSet1” se generan con el asistente de .NET. Las sentencias Select utilizadas
son muy sencillas:
SELECT * FROM Tabla_correspondiente
Con el fin de eliminar datos incorrectos de la base de datos se realizarán una serie de
comprobaciones y correcciones sobre estos datos:
•
En primer lugar, se eliminarán aquellos asientos que no estén formados por alguna
operación. El código para realizar esto es:
int borrado1=1;
while(borrado1==1)
{
borrado1=0;
foreach(DataRow d in dataSet11.Tables[“Asientos”].Rows)
{
int tiene_op=0;
foreach(DataRow d2 in
dataSet11.Tables[“Operaciones”].Rows)
{
if(Convert.ToInt32(d2[“Asiento”] ==
Convert.ToInt32(d[“NumeroAsiento”]))
{
tiene_op=1;
break;
}
}
if(tiene_op==0)
{
d.Delete();
65
dataSet11.Tables[“Asientos”].Rows.Remove(d);
this.oleDbDA_asientos.Update(
dataSet11,”Asientos”);
dataSet11.AcceptChanges();
borrado1=1;
break;
}
}
}
Como se puede ver en el código, se utiliza un “foreach” para ir recorriendo
todas las filas de una tabla hasta que se realiza una operación de eliminar o
modificar una fila. Sólo en estos casos (y no cuando sólo se lee algún valor de una
fila) es necesario incluir un break. Con el fin de continuar eliminando o
modificando más elementos de la tabla introducimos una variable (como borrado1)
que controle un bucle while que sirve para ir recorriendo todas las filas a pesar de
que se realice una operación de borrado o modificado. En este caso, se borran todos
los asientos para los cuales no se ha encontrado ninguna operación (tiene_op==0).
•
Después, se eliminan aquellos asientos que tengan en su campo de código de libro
diario al que pertenecen un número que no se corresponde con ningún libro diario
existente.
•
Luego se recorren todas las operaciones y se eliminan aquéllas que no estén
asociadas a un asiento existente.
•
Se recorren todos los libros diarios y se borran aquéllos que no tengan el código de
una empresa existente en su campo de código de empresa a la que pertenecen.
•
Se recorren todos los balances iniciales de las empresas y, en caso de que alguno de
ellos no cuadre, se eliminará el balance inicial de la empresa mostrando un mensaje
informativo al usuario.
66
Una vez comprobada la integridad de la información en la base de datos, se pasa a
cargar los códigos ya utilizados en la base de datos. Por cada tabla en la base de datos
existe un array que guarda qué códigos han sido ya utilizados para que no se vuelvan a
reutilizar ya que estos códigos son las claves principales. Los nombres de estos arrays y sus
dimensiones se pueden observar en el código:
empresas = new int[1000];
asientos = new int[10000];
operaciones = new int[100000];
librosdiarios = new int[10000];
estados = new int[10000];
Para saber qué códigos han sido utilizados ya, se almacenará un 1 en la posición del
array si está cogido o un 0 si está libre:
foreach(DataRow d in dataSet11.Tables[“Empresas”].Rows)
{
empresas[Convert.ToInt32(d[“CodigoEmpresa”])] = 1;
}
foreach(DataRow d in dataSet11.Tables[“Asientos”].Rows)
{
asientos[Convert.ToInt32(d[“NumeroAsiento”])] = 1;
}
foreach(DataRow d in dataSet11.Tables[“Operaciones”].Rows)
{
operaciones[Convert.ToInt32(d[“Codigo_operacion”])] = 1;
}
foreach(DataRow d in dataSet11.Tables[“LibrosDiarios”].Rows)
{
librosdiarios[Convert.ToInt32(d[“CodigoLibrodiario”])] = 1;
}
foreach(DataRow d in dataSet11.Tables[“Estados”].Rows)
{
estados[Convert.ToInt32(d[“CodigoEstado”])] = 1;
}
Cada vez que se cree un nuevo elemento en la base de datos habrá que buscar un
código que esté libre de la forma:
ind=0;
repetido=1;
while(repetido==1)
{
if(operaciones[ind]== 0)
67
{
operaciones[ind]= 1;
repetido=0;
}
else
{
ind++;
}
}
En este formulario se incluyen unos botones que abren otras ventanas. En caso de
que se abra una nueva cerrando la actual, esta acción se implementa así:
private void button3_Click(object sender, System.EventArgs e)
{
Form_CrearEmpresa F = new Form_CrearEmpresa(conect, empresas,
asientos, operaciones, librosdiarios, estados, this);
F.Show();
this.Hide();
}
Cuando se instancia un nuevo formulario se le pasan los argumentos que vaya a
necesitar. En este caso son los arrays con los códigos, la instancia de “Conexión”
denominada “conect” y un argumento que se llama “this” y que se refiere al formulario
actual, que es el de Menú principal. Este argumento se pasa ya que, si se cierra el
formulario de Menú principal, se cerraría la aplicación entera debido a que es el formulario
sobre el que se lanza la aplicación. Con el fin de no tener varios procesos inactivos de
menús principales no visibles se ha decidido pasar el primero como argumento, ya que en
caso de que la aplicación requiera volver a mostrar el menú principal, simplemente éste se
hará visible otra vez sin tener que volver a crear otra instancia de formulario de Menú
principal. En caso de que la nueva ventana se abra y la actual no se cierre, se implementa
así:
Ayuda_Form F = new Ayuda_Form();
F.Show();
68
3.2.2.2 “Acerca De”
Este formulario está programado enteramente con el diseñador de .NET y es muy
sencillo por lo que no requiere más comentarios.
3.2.2.3 “Añadir Asiento”
Este formulario permite definir la fecha y las operaciones de un asiento y crearlo en
la base de datos. Además de manipular la variable “conect” (que es instancia de
“Conexión”) utiliza una instancia de DataSet2 con el fin de poder mostrar las operaciones
del “haber” en un datagrid y las operaciones del “debe” en otro datagrid.
Para que el usuario pueda introducir la fecha del asiento se usa una instancia de
“DateTimePicker” que muestra un calendario sobre el que el usuario puede seleccionar la
fecha. No se permitirá crear un asiento cuya fecha pertenezca a un año diferente al del libro
diario. También con el diseñador de .NET se han añadido menús y submenús al formulario
cuyo funcionamiento es bastante sencillo.
A continuación se muestra el código del constructor del formulario:
public Form_AñadirAsiento(Operación _conect,int[] _empresas, int[]
_asientos, int[] _operaciones, int[] _librosdiarios, int[] _estados,
LibroDiario _ld, Form_MenuPrincipal _Fprincipal)
{
InitializeComponent();
asientos = _asientos;
operaciones = _operaciones;
conect = _conect;
librosdiarios = _librosdiarios;
estados= _estados;
ld = _ld;
69
Fprincipal = _Fprincipal;
empresas = _empresas;
nuevo_asiento();
ajusteInicial();
ajustarDatagrids();
botonesBorrado();
}
En primer lugar, se ha llamado al método “InitializeComponent”, que se encarga se
generar (con sus respectivos ajustes) todos los elementos del formulario. Después se
guardan los argumentos de entrada en variables del formulario. Después se llama al método
“nuevo_asiento”, que busca un código válido para el asiento que se va a crear. El método
“ajusteInicial” se encarga se dar ciertos valores a propiedades de elementos del formulario.
El método “ajustarDatagrids” sirve para definir la apariencia de las columnas de datos en
los datagrids. El método “botonesBorrado” deshabilita los botones de borrar operaciones
cuando no hay operaciones existentes como en caso inicial.
Se muestra el código de “ajusteInicial”:
public void ajusteInicial()
{
rB_exp1.Checked=false;
rB_exp2.Checked=true;
rB_exp3.Checked=false;
rB_exp4.Checked=true;
comboBox1.Enabled=false;
checkBox1.Checked=false;
comboBox2.Enabled=false;
checkBox2.Checked=false;
textBox5.Enabled=false;
textBox1.Enabled=false;
this.dateTimePicker1.Value = Convert.ToDateTime(“01/01/” +
ld.getAño());
String nombre =” “;
foreach(DataRow d in conect.data.Tables[“Empresas”].Rows)
{
if(Convert.ToInt32(d[“CodigoEmpresa”]) ==ld.getN_empresa())
{
nombre = Convert.ToString(d[“Nombre”]);
break;
70
}
}
String st = “Generando nuevo asiento para el año “ + ld.getAño() +
“ de la empresa “ + nombre;
label9.Text = st;
}
Se puede ver cómo se habilitan o deshabilitan diversos elementos del formulario. Se
establece la fecha por defecto para el “DateTimePicker” y se muestra una etiqueta con el
año de la empresa y del libro diario al que pertenece el asiento.
Se muestra el código de “ajustarDatagrids”:
private void ajustarDatagrids()
{
DataGridTableStyle ts1 = new DataGridTableStyle();
ts1.MappingName=”Operaciones”;
dataGrid1.TableStyles.Clear();
DataGridColumnStyle Col1=new DataGridTextBoxColumn();
Col1.MappingName=”NºCuenta”;
Col1.HeaderText=”NºCuenta”;
Col1.Width=100;
ts1.GridColumnStyles.Add(Col1);
DataGridColumnStyle Col2=new DataGridTextBoxColumn();
Col2.MappingName=”Valor”;
Col2.HeaderText=”Valor”;
Col2.Width=100;
ts1.GridColumnStyles.Add(Col2);
DataGridColumnStyle Col3=new DataGridTextBoxColumn();
Col3.MappingName=”Explicacion”;
Col3.HeaderText=”Explicación”;
Col3.Width=480;
ts1.GridColumnStyles.Add(Col3);
dataGrid1.TableStyles.Add(ts1);
ts1.DataGrid.Update();
(se hace lo mismo para el segundo datagrid)
}
La clase “DataGridTableStyle” sirve para definir el estilo y apariencia de las
columnas que van a salir en un datagrid. Así se define un “DataGridColumnStyle” para
cada columna y se añaden al “DataGridTableStyle”. Así se puede especificar el nombre que
71
aparecerá en la cabecera de cada columna, el campo de la base de datos con el que se
corresponde cada columna y el ancho de cada columna.
A continuación se muestran las distintas partes del código que implementa el botón
de añadir operación al “debe”. En primer lugar veremos los filtros que se hacen sobre el
contenido de los campos a rellenar por el usuario:
if ((t_numero.Text==””)||(t_valor.Text==””))
{
MessageBox.Show(this, “Necesita rellenar los campos de nº de cuenta
y de valor del debe”, “¡Atención!” , MessageBoxButtons.OK,
MessageBoxIcon.Stop);
}
else
{
if((Global.comprobarNumero(t_numero.Text)==0)
||(Global.comprobarNumero(t_valor.Text)==0))
{
MessageBox.Show(this, “Los campos de nº de cuenta y de valor
del debe deben ser valores numéricos”, “¡Atención!” ,
MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
else
{
(…)
Se han mostrado dos comprobaciones pero en realidad se realizan muchas más. Si
los datos introducidos por el usuario no son válidos se muestra un mensaje de error al
usuario y no se lleva a cabo la acción requerida por él. Un mensaje de error se muestra con
“MessageBox.Show(this,” seguido del mensaje que se va a mostrar al usuario, la cabecera
del mensaje, el tipo de botón que se muestra en el mensaje y el tipo de icono o imagen que
se muestra en el mensaje.
Las comprobaciones que se realizan una a una por este orden son:
•
Que los campos de nº de cuenta y de valor del debe estén rellenos.
•
Que los campos de nº de cuenta y de valor del debe sean valores numéricos.
•
Que el número de cuenta introducido pertenezca al Plan General Contable.
72
•
Que el valor del debe introducido no sea una cantidad superior o igual a un billón.
•
Que el valor del debe introducido no sea una cantidad negativa o nula.
•
Que la explicación introducida no sea demasiado larga. Se permiten hasta 65
caracteres.
•
Que el nº de cuenta introducido no coincida con el de una operación ya definida
para ese mismo asiento. No tiene sentido que haya dos operaciones de la misma
cuenta en el mismo asiento.
•
Que no se introduzca una operación cuya explicación sea igual a la de los asientos
de apertura o de cierre.
Una vez que se han superado con éxito todos los filtros se pasa a generar la nueva
operación en la base de datos. Lo primero es buscar un nuevo código para la operación:
ind=0;
repetido=1;
while(repetido==1)
{
if(operaciones[ind]== 0)
{
operaciones[ind]= 1;
repetido=0;
}
else
{
ind++;
}
}
Una vez que se tiene el nuevo código se pasa a guardar la nueva operación en la
base de datos:
DataRow NuevaFila = conect.data.Tables[“Operaciones”].NewRow();
NuevaFila[“Codigo_operacion”]=ind;
NuevaFila[“Tipo”]=”Debe”;
NuevaFila[“Valor”]=t_valor.Text;
NuevaFila[“NºCuenta”]=t_numero.Text;
73
NuevaFila[“Asiento”]=n_asiento;
if(rB_exp1.Checked==true)
{
NuevaFila[“Explicacion”]=textBox5.Text;
}
else
{
NuevaFila[“Explicacion”]=”No”;
}
conect.data.Tables[“Operaciones”].Rows.Add(NuevaFila);
Es posible que sea necesario añadir operación de IVA si el “checkbox”
correspondiente está marcado:
if(checkBox1.Checked)
{
ind=0;
repetido=1;
while(repetido==1)
{
if(operaciones[ind]== 0)
{
operaciones[ind]= 1;
repetido=0;
}
else
{
ind++;
}
}
NuevaFila = conect.data.Tables[“Operaciones”].NewRow();
NuevaFila[“Codigo_operacion”]=ind;
NuevaFila[“Tipo”]=”Debe”;
double valorIVA;
if(comboBox1.Text.Equals(“IVA: 4%”))
{
valorIVA=Convert.ToDouble(t_valor.Text)* 0.04;
}
else
{
if(comboBox1.Text.Equals(“IVA: 7%”))
{
valorIVA=Convert.ToDouble(t_valor.Text)* 0.07;
}
else
{
valorIVA=Convert.ToDouble(t_valor.Text)* 0.16;
}
}
NuevaFila[“NºCuenta”]=”472”;
NuevaFila[“Asiento”]=n_asiento;
double valorIVA2=buscarIVA(“Debe”);
74
Ahora hay que ver si había operaciones de IVA existentes previamente; para ello se
usa la función “buscarIVA” que recorre las operaciones buscando alguna que pertenezca a
la cuenta 472. Si es así borra esa operación y devuelve el valor de IVA en la operación
borrada. Si no encuentra ningún IVA anterior devuelve un 0:
if(valorIVA2>0)
{
NuevaFila[“Explicacion”]=”IVA sobre varias cuentas”;
NuevaFila[“Valor”]= valorIVA + valorIVA2;
}
else
{
NuevaFila[“Explicacion”]=”IVA sobre cuenta “ + t_numero.Text;
NuevaFila[“Valor”]= valorIVA;
}
conect.data.Tables[“Operaciones”].Rows.Add(NuevaFila);
}
conect.a_operaciones.Update(conect.data,”Operaciones”);
conect.data.AcceptChanges();
Una vez que se ha registrado la operación en la base de datos sólo queda actualizar
el datagrid para que la muestre por pantalla. Esto se hace mediante un sentencia Select
(SQL), que selecciona sólo las operaciones del “Debe” del asiento que se está creando. Para
rellenar el datagrid con la nueva información se borra completamente con “Clear” y se
vuelve a llenar de datos con “Fill”. Por último se utiliza el método “Refresh” del datagrid
para que muestre las operaciones actualizadas:
string selectSQL = “SELECT NºCuenta, Valor, Explicacion FROM Operaciones
WHERE (Asiento = ?) AND (Tipo = ?)”;
selectCMD = new OleDbCommand(selectSQL, oleDbConnection1);
this.oleDbDataAdapter1.SelectCommand = selectCMD;
selectCMD.Parameters.Add(“@Asiento”, OleDbType.VarChar, 15).Value =
n_asiento;
selectCMD.Parameters.Add(“@Tipo”, OleDbType.VarChar, 15).Value = “Debe”;
dataSet21.Clear();
oleDbDataAdapter1.Fill(dataSet21);
this.dataGrid1.Refresh();
Otras funcionalidades del código de este formulario se aclararán al explicar
funciones análogas de otros formularios. Si no se confirma finalmente la creación del
75
asiento, todas las operaciones pertenecientes a este asiento provisional, que se ha ido
creando en el formulario, serán eliminadas. Si la suma de las operaciones de debe del
asiento no es igual a la suma de las operaciones de haber del asiento, o si no existen
operaciones, entonces no se permitirá que el asiento sea creado.
3.2.2.4 “Ayuda”
En este formulario se presentan los distintos contenidos de ayuda. Consiste en
incorporar una serie de pestañas (“TabControl”) al formulario y en cada una de ellas
colocar un “RichTextBox”. Sobre cada RTF se carga un documento de ayuda de la
siguiente forma:
OpenFileDialog openFile1 = new OpenFileDialog();
openFile1.DefaultExt = “*.rtf”;
openFile1.Filter = “RTF Files|*.rtf”;
try
{
openFile1.FileName=”.\\Archivos_aplicación\\Parte1.rtf”;
richTextBox1.LoadFile(openFile1.FileName,
RichTextBoxStreamType.PlainText);
}
catch(System.IO.FileNotFoundException fne)
{
MessageBox.Show(this, “Error al cargar los archivos de ayuda.
Asegúrese de que se encuentran en la carpeta
\”Archivos_aplicación\”.”, “Imposible abrir pantalla de ayuda” ,
MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
La clase “OpenFileDialog” permite abrir un archivo de texto. Con sus propiedades
de “Filter” y de “DefaultExt” se indica que se abrirá un archivo de tipo y extensión .rtf. Con
la propiedad “FileName” se especifica el nombre y directorio del archivo que se va a
cargar. Si el archivo no se encuentra en el directorio especificado o no tiene el nombre
76
indicado saltará un excepción que es controlada mediante un “catch”, lanzando un mensaje
de error al usuario y cerrando el formulario.
3.2.2.5 “Balance de sumas y saldos”
Recibe un array con todas las operaciones del libro diario (array_filas) y otro array
con todas las cuentas que tienen alguna operación (array_cuentas). Muestra el balance de
sumas y saldos provisional de un libro diario. Para ello cuenta con un datagrid que obtiene
sus datos del siguiente método:
private void cargarDatagrid()
{
total_debe=0;
total_haber=0;
total_deudor=0;
total_acreedor=0;
for(int j=0; j < array_cuentas.Length; j++)
{
saldo_debe=0;
saldo_haber=0;
for(int i=0;© < array_filas.Length; i++)
{
if(Convert.ToDouble(array_filas[i][“NºCuenta”])==
array_cuentas[j])
{
if(Convert.ToDouble(array_filas[i][“Debe”])>0)
{
saldo_debe = saldo_debe +
Convert.ToDouble(array_filas[i][“Debe”]);
}
if(Convert.ToDouble(array_filas[i][“Haber”])>0)
{
saldo_haber = saldo_haber +
Convert.ToDouble(array_filas[i][“Haber”]);
}
}
}
DataRow NuevaFila = dataSet51.Tables[“Saldos”].NewRow();
NuevaFila[“NombreCuenta”]
=Global.getInfoCuenta(array_cuentas[j])[0];
NuevaFila[“NºCuenta”]=array_cuentas[j];
NuevaFila[“Debe”]=saldo_debe;
NuevaFila[“Haber”]=saldo_haber;
total_debe = total_debe + saldo_debe;
total_haber = total_haber + saldo_haber;
77
if(saldo_debe>saldo_haber)
{
NuevaFila[“Deudor”]=saldo_debe – saldo_haber;
NuevaFila[“Acreedor”]= 0;
total_deudor = total_deudor + (saldo_debe –
saldo_haber);
}
else
{
NuevaFila[“Deudor”]= 0;
NuevaFila[“Acreedor”]= saldo_haber – saldo_debe;
total_acreedor = total_acreedor + (saldo_haber –
saldo_debe);
}
dataSet51.Tables[“Saldos”].Rows.Add(NuevaFila);
}
label2.Text
label3.Text
label4.Text
label5.Text
=
=
=
=
Convert.ToString(total_debe);
Convert.ToString(total_haber);
Convert.ToString(total_deudor);
Convert.ToString(total_acreedor);
}
El datagrid donde se muestran los datos tiene su origen de datos en un DataSet5, al que se
van añadiendo sus filas una a una (sin utilizar una sentencia SQL). Se van recorriendo todas
las filas del “array_filas” y para cada cuenta del “array_cuentas” se va llevando la cuenta
del saldo del debe, del haber, el acreedor y el deudor. Finalmente se muestra en unas
etiquetas el valor de los totales.
Para deshabilitar el botón de cierre de la ventana utilizando la clase “CloseButton” se
utiliza el siguiente código:
private void BalanceSaldos_Form_Load(object sender,System.EventArgs e)
{
CloseButton.Disable(this);
}
3.2.2.6 “Ficha de la Empresa”
Tiene dos constructores. El primero de ello se utiliza en caso de que se vaya a crear
una empresa. El segundo se utiliza cuando se van a modificar los datos de una empresa ya
78
existente. En este caso recibe como argumento de entrada una instancia de “Empresa” que
hace referencia a la empresa que se ha de modificar.
Si se quiere crear una empresa nueva, los campos de la empresa se mostrarán vacíos
y será el usuario el encargado de rellenarlos. Si, después, el usuario pulsa el botón de
“Aceptar” y los datos de entrada son correctos, la nueva empresa se creará como una nueva
entrada de la tabla “Empresas” en la base de datos.
Si se está modificando una empresa, al cargar el formulario se mostrará en los
campos de la empresa los datos existentes de la empresa. Si el usuario pulsa el botón de
“Aceptar” y los datos son correctos (la aplicación hace los filtros de entrada pertinentes) se
modificarán los datos de la empresa. El código necesario para modificación de una empresa
en la base de datos es:
d1.BeginEdit();
d1[“CodigoEmpresa”]=empresa_a_modificar.getCodigo();
d1[“Nombre”]=t_nombre.Text + cB_tipo.Text;
d1[“Creador”]=t_creador.Text;
d1[“Inicio”]=cB_año.Text;
d1.EndEdit();
conect.a_empresas.Update(conect.data,”Empresas”);
conect.data.AcceptChanges();
Donde d1 es la fila que representa a la empresa en la tabla “Empresas” de la base de
datos. Un caso excepcional y que requiere gran cantidad de operaciones es cuando una
empresa cambia de año de inicio. Es ese caso, si el nuevo año de inicio es menor hay que
crear nuevos libros diarios desde el nuevo año de inicio hasta el anterior. Esto se debe a que
desde el primer libro diario de una empresa hasta el último deben existir los libros diarios
referentes a todos los años. Si el nuevo año de inicio es posterior, hay que borrar aquellos
libros diarios que son anteriores a la nueva fecha de inicio.
79
3.2.2.7 “Empresas Existentes”
Este formulario muestra las empresas existentes en un datagrid que carga la tabla de
“Empresas” del DataSet1 utilizado en “conect” pero con la novedad de que el campo del
código de la empresa no se muestra ya que a esa columna se le ha dado un valor de 0 para
definir la anchura de la columna, por lo que no se ve. Por lo demás, este formulario, no
incorpora conceptos de programación que no se hayan visto ya en otros formularios ya
analizados.
3.2.2.8 “Evolución del libro diario”
Muestra todos los asientos de un libro diario. Por cada asiento se ven todas sus
operaciones. Un concepto importante de este formulario es que utiliza dos DataSet3. Uno
de ellos lo utiliza para cargar las operaciones del “haber” de todos los asientos y otro lo
utiliza para cargar todas las operaciones del “debe” de todos los asientos. A continuación
fusiona estos dos DataSet3 en el primero de ellos. Para realizar esto cargamos el primer
DataSet con la siguiente sentencia SQL:
“SELECT
Operaciones.Codigo_operacion
AS
Codigo_operacion,
Asientos.NumeroAsiento AS Asiento, Asientos.Fecha AS Fecha, 0 AS
NombreCuenta, Operaciones.NºCuenta AS NºCuenta, Operaciones.Valor AS
Debe, 0 AS Haber, Operaciones.Explicacion AS Explicacion FROM (Asientos
INNER JOIN Operaciones ON Asientos.NumeroAsiento = Operaciones.Asiento)
WHERE (Operaciones.Tipo = ‘Debe’) AND (Asientos.LibroDiario = ¿) ORDER BY
Operaciones.Asiento, Asientos.Fecha”
El segundo DataSet se carga con esta otra sentencia SQL:
“SELECT Operaciones.Codigo_operacion AS Codigo_operacion,
Asientos.NumeroAsiento AS Asiento, Asientos.Fecha AS Fecha,0 AS
NombreCuenta, Operaciones.NºCuenta AS NºCuenta, 0 AS Debe,
Operaciones.Valor AS Haber, Operaciones.Explicacion AS Explicacion FROM
80
(Asientos INNER JOIN Operaciones ON Asientos.NumeroAsiento =
Operaciones.Asiento) WHERE (Operaciones.Tipo = ‘Haber’) AND
(Asientos.LibroDiario = ¿) ORDER BY Operaciones.Asiento, Asientos.Fecha”
Para juntarlos sobre el primero se utiliza:
dataSet31.Merge(dataSet32, true);
Otro aspecto Nuevo que introduce este formulario es cómo rellenar la lista de
cuentas del “ComboBox”. Para ello hay que recorrer todas las operaciones, llevar la cuenta
de las operaciones que intervienen y añadirlas como elementos del “ComboBox”. El
método que se ha implementado para realizar esto es el siguiente:
private void cargarCuentas()
{
cuentas_saldos = new int[8000];
n_cuentas = 0;
darray=dataSet31.Tables[“Asientos”].Select(null, “NºCuenta”,
DataViewRowState.CurrentRows);
for (int i=0; i< darray.Length; i++)
{
if (cuentas_saldos[Convert.ToInt16(darray[i][“NºCuenta”])]
==0)
{
comboBox1.Items.Add(darray[i][“NºCuenta”]);
cuentas_saldos[Convert.ToInt32(darray[i][“NºCuenta”])]
=1;
n_cuentas++;
}
}
}
3.2.2.9 “Libros Diarios”
En este formulario se muestran todos los libros diarios de una empresa. Para cargar
los libros diarios se utiliza un DataSet6 y sobre el libro diario seleccionado por el usuario se
le permite al usuario realizar diferentes opciones. Para cargar el DataSet6 se utiliza una
sentencia SQL que se puede ver en el código utilizado:
81
string selectSQL = “SELECT Año, CodigoLibrodiario, Empresa FROM
LibrosDiarios WHERE (Empresa = ¿) ORDER BY Año”;
selectCMD = new OleDbCommand(selectSQL, oleDbConnection1);
this.oleDbDataAdapter1.SelectCommand = selectCMD;
selectCMD.Parameters.Add(“@Empresa”, OleDbType.VarChar, 15).Value =
emp.getCodigo();
this.oleDbDataAdapter1.Fill(dataSet61);
this.dataGrid1.Refresh();
Cabe destacar que al pulsar el botón de “Cambiar Año” cambia el tamaño del
formulario y se pueden visualizar nuevos elementos en la parte inferior de la pantalla que
permiten al usuario meter el nuevo año para el libro diario. Esto se consigue cambiando
simplemente la altura del formulario hasta que se puedan ver los nuevos elementos (que
antes quedaban fuera del tamaño del formulario):
this.Height = 464;
3.2.2.10 “Resumen Anual”
Genera un documento con el resumen anual de la empresa y lo carga sobre un
“RichTextBox” que lo muestra por pantalla. Lo complicado es la generación del
documento, ya que hay que escribir carácter a carácter todo el resumen anual cuidando el
espaciado y la tabulación. De hecho es necesario realizar dos documentos. El primero de
ellos ajusta su espaciado y tabulaciones a un documento que será visualizado en Word. El
segundo de ellos se preparará para que pueda ser visualizado por pantalla con la aplicación.
Las diferencias están, por ejemplo, en que en Word un carácter se corresponde en longitud
con un espacio, mientras que en RTF mostrado por pantalla un carácter se corresponde con
casi 2 espacios. Hubiera sido mucho más fácil poder cargar en la pantalla de la aplicación
un archivo Word, pero la tecnología disponible no lo ha permitido.
82
Lo primero, antes de empezar a escribir en el documento, es crear un nuevo
documento con el nombre adecuado. El nombre del archivo para Word estará formado por
el de la empresa concatenado con el del creador y con el del año del libro diario, con
extensión rtf. Si ya existe en la carpeta un archivo con el mismo nombre, se le añadirá un
“(1)” al final, si ya existe así entonces un “(2)” y así sucesivamente hasta llegar a diez, en
cuyo caso se sobrescribe el documento existente indicándoselo al usuario.
El nombre del archivo RTF que se carga en pantalla será “temporal” (dado que no está
pensado para ser usado por el usuario en otra aplicación). El código de la elección de
nombres es el siguiente:
string nombre_sin_comprobar =”.\\” + d[“Nombre”]+ “-“ + d[“Creador”] + ““ + ld.getAño();
bool repe = true;
int n_veces=0;
do
{
if((repe==true)&&(n_veces>0))
{
if(n_veces>1)
{
char[] c = nombre_sin_comprobar.ToCharArray ();
c[nombre_sin_comprobar.Length-2]=(Char)(n_veces +48);
string s=new string(c);
nombre_sin_comprobar=s;
}
else
{
nombre_sin_comprobar = nombre_sin_comprobar + “(“ +
n_veces + “)”;
}
}
try
{
if(n_veces<10)
{
OpenFileDialog openFile1 = new OpenFileDialog();
openFile1.DefaultExt = “*.rtf”;
openFile1.Filter = “RTF Files|*.rtf”;
openFile1.FileName=(nombre_sin_comprobar + “.rtf”);
this.richTextBox1.LoadFile(openFile1.FileName,
RichTextBoxStreamType.PlainText);
}
}
catch(IOException e)
83
{
repe = false;
}
n_veces++;
}while((repe == true)&&(n_veces<10));
if(n_veces>9)
{
MessageBox.Show(this, “No puede tener más de 10 documentos para el
mismo libro diario. El nuevo libro diario se sobreescribirá sobre
el primero de todos”, “¡Atención!” , MessageBoxButtons.OK,
MessageBoxIcon.Stop);
nombre_sin_comprobar =”.\\” + d[“Nombre”]+ “-“ + d[“Creador”] + “-“
+ ld.getAño();
}
nombre = nombre_sin_comprobar+ “.rtf”;
nombre2 = “.\\temporal”;
break;
Una vez abiertos los documentos se realizará la escritura sobre ellos. Es un proceso
lento y que requiere muchas líneas de código.
Un esquema del funcionamiento sería:
•
Se escriben las cabeceras del Libro diario
•
Se escribe el asiento de apertura con su correspondiente etiqueta de “Apertura de
balance”.
•
Se escriben todos los asientos normales.
•
Se escribe el valor parcial de la suma del debe y de la suma del haber.
•
Se escribe el primer asiento de cierre de cuentas temporales con su correspondiente
etiqueta de “Cierre de cuentas temporales (p y g) al haber”.
•
Se escribe el segundo asiento de cierre de cuentas temporales con su
correspondiente etiqueta de “Cierre de cuentas temporales (p y g) al debe”.
•
Se vuelve a escribir el valor parcial de la suma del debe y de la suma del haber.
•
Se escribe el asiento de cierre de cuentas permanente con su correspondiente
etiqueta de “Cierre de cuentas temporales”.
84
•
Se escribe el valor final de la suma del debe y de la suma del haber.
•
Se escribe la cabecera del libro mayor.
•
Para cada cuenta se escribe una cabecera con el número y nombre de la cuenta y, a
continuación, todas las cantidades de las operaciones en las que interviene dicha
cuenta, con una referencia al asiento al que pertenecen. Las cantidades del debe irán
a la izquierda y las del haber a la derecha.
•
Se escribe el balance de comprobación antes de cierre de cuentas de pérdidas y
ganancias (con su cabecera). Es el balance de sumas y saldos. No se contabilizan las
operaciones de ningún asiento de cierre.
•
Se escribe el balance de comprobación después del cierre de cuentas de pérdidas y
ganancias (con su cabecera). Es el balance de sumas y saldos. Se contabilizan los
asientos de cierre de cuentas temporales, pero no el de cierre de cuentas
permanente.
Todo este proceso se realiza primero para el documento que se prepara para Word y
luego se repite para el documento que se prepara para ser cargado en el “RichTextBox” del
formulario. A lo largo de la impresión se tienen en cuenta la longitud de las palabras y de
los números para igualar todas las filas con espacios y tabulaciones donde es necesario.
Para ello se utilizan una serie de métodos que en función de la longitud de una palabra o un
número escriben espacios o tabulaciones en diferentes partes del documento.
85
3.2.2.11 “Saldo de una Cuenta”
Muestra todas las operaciones de un libro diario en las que interviene una
determinada cuenta. Utiliza una DataSet3 pero no muestra todas las columnas (se ayuda de
anchos de columnas nulos). Filtra que sólo se muestren las operaciones de la cuenta
seleccionada y va llevando la cuenta de las sumas del haber y el debe para, al final,
mostrarlas en la parte inferior del formulario junto con el saldo final de la cuenta
(especificando si es acreedor a deudor).
3.2.2.12 “Situación inicial de la empresa”
Muestra la situación inicial de la empresa. Para ello muestra los estados que afectan
al “Debe” a la izquierda del formulario con un DataSet4 y los que afectan al “Haber” a la
derecha del formulario con otro DataSet4. Realiza todos los filtros pertinentes para
asegurarse que los datos introducidos por el usuario son correctos y que no se produzcan
excepciones. No deja abandonar este formulario mientras la suma de los estados del “Debe”
no sea igual a la suma de los estados del “Haber”.
Con el fin de acceder a la base de datos para cargar la información en el DataSet4 se
utiliza el siguiente código:
string selectSQL1 = “SELECT CodigoEstado, NombreCuenta, Cantidad,
NºCuenta FROM Estados WHERE (CodigoEmpresa = ¿) AND (Tipo = ?)”;
selectCMD1 = new OleDbCommand(selectSQL1, oleDbConnection1);
this.oleDbDataAdapter1.SelectCommand = selectCMD1;
selectCMD1.Parameters.Add(“@CodigoSituacion”, OleDbType.VarChar,
15).Value = ld.getN_empresa();
selectCMD1.Parameters.Add(“@CodigoSituacion”, OleDbType.VarChar,
15).Value = “Debe”;
dataSet41.Clear();
oleDbDataAdapter1.Fill(dataSet41);
86
this.dataGrid1.Refresh();
En este caso se han cargado los estados iniciales del “Debe” para la empresa que se
está referenciando. Por eso es necesario incluir dos parámetros a la sentencia SQL utilizada.
3.2.2.13 “Cuentas”
Este formulario carga un documento (que contiene todas las cuentas del Plan
General Contable ordenadas por el código de cuenta) sobre un “RichTextBox” que muestra
su contenido.
3.2.2.14 “Cuentas2”
Este formulario carga un documento (que contiene todas las cuentas del Plan
General Contable ordenadas por orden alfabético) sobre un “RichTextBox” que muestra su
contenido.
87
ANEXO A
Introducción a la tecnología .NET
A finales del año 2000 Microsoft publicó los primeros documentos acerca de la
tecnología “.NET” en un intento de hacer frente al éxito que estaba teniendo el lenguaje
Java impulsado por la compañía Sun. La idea de .NET se parece bastante a la tecnología
empleada con Java. Tanto .NET como Java compilan el código fuente a un código
intermedio en vez de compilarlo directamente a código máquina. En Java el código
intermedio es llamado “bytecode” y en .NET recibe el nombre de CIL (Common
Intermediate Language).
Para ejecutar este código intermedio es necesario un entorno que lo interprete y así
poder pasar al código máquina correspondiente al sistema/arquitectura donde se este
ejecutando. De esta forma se consigue independencia del ejecutable en contraposición al
tradicional compilado a código máquina, ya que este último solo podría ser utilizado en
máquinas que soporten el mismo conjunto de instrucciones y en sistemas que conozcan el
formato de ese ejecutable. Pero .NET va más allá, su objetivo no es sólo la independencia
del compilado sino también la independencia del lenguaje de alto nivel, es decir, CIL ha
sido especialmente diseñado para proporcionar todo lo necesario a la mayoría de lenguajes
actuales.
88
1. Compatibilidad entre lenguajes
Microsoft ha diseñado un lenguaje de programación que busca aprovechar toda la
potencia del CIL. Este lenguaje es el C# (pronunciado C Sharp). Esto no impide que todo
aquél que quiera formar parte de la plataforma .NET construya un compilador de su
lenguaje a código intermedio CIL. Esto proporciona por ejemplo la posibilidad de poder
reutilizar clases programadas en lenguaje C# desde Visual Basic.NET de forma muy
sencilla, cosa que hasta el momento sólo era posible mediante complejos mecanismos poco
flexibles y que ahora es posible tener de forma nativa a la plataforma.
.NET tiene definidos un Common Type System (CTS) con los tipos de datos
soportados, los cuales son suficientes para cubrir cualquier lenguaje actual. Pero esto no es
suficiente para garantizar la interoperabilidad entre lenguajes, porque por ejemplo imaginar
que hay un lenguaje que soporta el tipo entero sin signo y otro que no, esto impediría la
interoperabilidad entre ambos lenguajes. Por ese motivo también se ha definido el Common
Language Specification (CLS), el cual es necesario que cumplan todos los lenguajes que
quieran poder disfrutar de dicha interoperabilidad. Esta es una de las ventajas de .NET con
respecto a Java de Sun, ya que en ésta no es posible la compilación de cualquier lenguaje
actual a bytecode.
2. Ventajas globales de .NET
Las ventajas globales que tiene .NET son muy importantes:
•
Independencia del sistema o arquitectura. Para todo sistema o arquitectura donde
esté implementado un intérprete de código CIL se podrá ejecutar nuestro programa.
89
•
Independencia del lenguaje. Sería posible mezclar grupos de programadores
expertos en diferentes lenguajes.
•
Reutilización de código. Por ejemplo, seria posible utilizar código antiguo
implementado en lenguaje Visual Basic.NET en otro proyecto actual que este
trabajando con el lenguaje C#.
A continuación se pasará a analizar la arquitectura de la plataforma .Net y después se
indicaran otras ventajas más específicas.
3. Arquitectura básica de la plataforma .Net.
Además de las ventajas ya mencionadas, la tecnología .NET ofrece soluciones a los
problemas de programación actuales, como son la administración de código o la
programación para Internet. Para aprovechar al máximo las características de .Net es
necesario entender la arquitectura básica en la que está implementada esta tecnología.
El Framework de .Net es una infraestructura sobre la que se reúne todo un conjunto
de lenguajes y servicios que simplifican enormemente el desarrollo de aplicaciones.
Mediante esta herramienta se ofrece un entorno de ejecución altamente distribuido, que
permite crear aplicaciones robustas y escalables. Los pilares fundamentales del entorno
.NET son tres:
•
Lenguajes de compilación.
•
Biblioteca de clases de .Net.
90
•
CLR (Common Language Runtime).
Actualmente, el Framework de .Net es una plataforma no incluida en los diferentes
sistemas operativos distribuidos por Microsoft, por lo que es necesaria su instalación previa
a la ejecución de programas creados mediante .Net. El Framework se puede descargar
gratuitamente desde la web oficial de Microsoft (ver link de descarga en los recursos del
final).
Lenguajes de programación
Como se ha comentado anteriormente, .Net Framework soporta múltiples lenguajes
de programación y, aunque cada lenguaje tiene sus características propias, es posible
desarrollar cualquier tipo de aplicación con cualquiera de estos lenguajes. Existen más de
30 lenguajes adaptados a .Net, desde los más conocidos como C#, Visual Basic o C++
hasta otros lenguajes menos conocidos como Perl o Cobol.
91
Common Language Runtime (CLR)
Es el verdadero núcleo del Framework de .Net, ya que es el entorno de ejecución en
el que se cargan las aplicaciones desarrolladas en los distintos lenguajes, ampliando el
conjunto de servicios que ofrece el sistema operativo estándar Win32. La herramienta de
desarrollo compila el código fuente de cualquiera de los lenguajes soportados por .Net en
un mismo código, denominado código intermedio (MSIL, Microsoft Intermediate
Lenguaje). Para generar dicho código el compilador se basa en el Common Language
Specification (CLS) que determina las reglas necesarias para crear código MSIL
compatible con el CLR.
De esta forma, indistintamente de la herramienta de desarrollo utilizada y del
lenguaje elegido, el código generado es siempre el mismo, ya que el MSIL es el único
lenguaje que entiende directamente el CLR. Este código es transparente al desarrollo de la
aplicación ya que lo genera automáticamente el compilador.
Sin embargo, el código generado en MSIL no es código máquina y por tanto no
puede ejecutarse directamente. Se necesita un segundo paso en el que una herramienta
denominada compilador JIT (Just-In-Time) genera el código máquina real, que se ejecuta
en la plataforma que tenga la computadora. De esta forma se consigue con .Net cierta
independencia de la plataforma, ya que cada plataforma puede tener su compilador JIT y
crear su propio código máquina a partir del código MSIL. La compilación JIT se realiza por
el CLR a medida que se invocan los métodos en el programa; el código ejecutable obtenido,
se almacena en la memoria caché de la computadora, siendo recompilado sólo cuando se
produce algún cambio en el código fuente.
92
Biblioteca de clases de .Net
Cuando se está programando una aplicación muchas veces se necesita realizar
acciones como manipulación de archivos, acceso a datos, conocer el estado del sistema,
implementar seguridad, etc. El Framework organiza toda la funcionalidad del sistema
operativo en un espacio jerárquico de nombres. De esta forma a la hora de programar
resulta bastante sencillo encontrar lo que se necesita.
Para ello, el Framework posee un sistema de tipos universal, denominado Common
Type System (CTS). Este sistema permite que el programador pueda interactuar los tipos
que se incluyen en el propio Framework (biblioteca de clases de .Net) con los creados por
él mismo (clases). De esta forma se aprovechan las ventajas propias de la programación
orientada a objetos, como la herencia de clases predefinidas para crear nuevas clases, o el
polimorfismo de clases para modificar o ampliar funcionalidades de clases ya existentes.
93
La biblioteca de clases de .Net Framework incluye, entre otros, tres componentes
clave:
•
ASP.NET para construir aplicaciones y servicios Web.
•
Windows Forms para desarrollar interfaces de usuario.
•
ADO.NET para conectar las aplicaciones a bases de datos.
La forma de organizar la biblioteca de clases de .Net dentro del código es a través
de los espacios de nombres (namespaces), donde cada clase está organizada en espacios de
nombres según su funcionalidad. Por ejemplo, para manejar ficheros se utiliza el espacio de
nombres System.IO y, si lo que se quiere es obtener información de una fuente de datos, se
utilizará el espacio de nombres System.Data.
La principal ventaja de los espacios de nombres de .Net es que de esta forma se
tiene toda la bliblioteca de clases de .Net centralizada bajo el mismo espacio de nombres
(System). Además, desde cualquier lenguaje se usa la misma sintaxis de invocación, ya que
a todos los lenguajes se aplica la misma biblioteca de clases.
Ensamblados (o Assemblies)
Uno de los mayores problemas de las aplicaciones actuales es que en muchos casos
tienen que tratar con diferentes archivos binarios (DLL´s), elementos de registro,
conectividad abierta a bases de datos (ODBC), etc.
Para solucionarlo el Framework de .Net maneja un nuevo concepto denominado
“ensamblado”. Los ensamblados son ficheros con forma de EXE o DLL que contienen toda
94
la funcionalidad de la aplicación de forma encapsulada. Por tanto la solución al problema
puede ser tan fácil como copiar todos los ensamblados en el directorio de la aplicación.
Con los ensamblados ya no es necesario registrar los componentes de la aplicación.
Esto se debe a que los ensamblados almacenan dentro de sí mismos toda la información
necesaria en lo que se denomina el manifiesto del ensamblado. El manifiesto recoge todos
los métodos y propiedades en forma de meta-datos junto con otra información descriptiva,
como permisos, dependencias, etc.
Para gestionar el uso que hacen la aplicaciones de los ensamblados, .Net utiliza la
llamada caché global de ensamblados (GAC, Global Assembly Cache). Así, .Net
Framework puede albergar en el GAC los ensamblados que puedan ser usados por varias
aplicaciones e incluso distintas versiones de un mismo ensamblado, algo que no era posible
con el anterior modelo COM.
Ventajas e inconvenientes de la plataforma .Net
Se han indicado en un apartado anterior algunas de las ventajas globales que aporta .NET.
Ventajas más específicas que proporciona .Net Framework:
•
Código administrado: El CLR realiza un control automático del código para que
este sea seguro, es decir, controla los recursos del sistema para que la aplicación se
ejecute correctamente.
•
Interoperabilidad multilenguaje: El código puede ser escrito en cualquier
lenguaje compatible con .Net, ya que siempre se compila en código intermedio
(MSIL).
95
•
Compilación just-in-time: El compilador JIT incluido en el Framework compila el
código intermedio (MSIL) generando el código máquina propio de la plataforma. Se
aumenta así el rendimiento de la aplicación al ser específico para cada plataforma.
•
Garbage collector: El CLR proporciona un sistema automático de administración
de memoria denominado recolector de basura (garbage collector). El CLR detecta
cuándo el programa deja de utilizar la memoria y la libera automáticamente. De esta
forma el programador no tiene por qué liberar la memoria de forma explícita,
aunque también sea posible hacerlo manualmente; (mediante el método disponse()
liberamos el objeto para que el recolector de basura lo elimine de memoria).
•
Seguridad de acceso al código: Se puede especificar que una pieza de código tenga
permisos de lectura de archivos pero no de escritura. Es posible aplicar distintos
niveles de seguridad al código, de forma que se puede ejecutar código procedente
del Web sin tener que preocuparse por si esto va a estropear el sistema.
•
Despliegue: Por medio de los ensamblados resulta mucho más fácil el desarrollo de
aplicaciones distribuidas y el mantenimiento de las mismas. El Framework realiza
esta tarea de forma automática mejorando el rendimiento y asegurando el
funcionamiento correcto de todas las aplicaciones.
Pero no todo son ventajas; procesos como la recolección de basura de .Net o la
administración de código introducen factores de sobrecarga que repercuten en la demanda
de más requisitos del sistema. El código administrado proporciona una mayor velocidad de
desarrollo y mayor seguridad de que el código sea bueno. En contrapartida el consumo de
recursos durante la ejecución es mucho mayor, aunque con los procesadores actuales esto
cada vez es menos inconveniente. El nivel de administración del código dependerá en gran
96
medida del lenguaje que se utilice para programar. Por ejemplo, mientras que Visual Basic
.Net es un lenguaje totalmente administrado, C# permite la administración de código de
forma manual, siendo por defecto también un lenguaje administrado, C++ es un lenguaje no
administrado en el que se tiene un control mucho mayor del uso de la memoria que hace la
aplicación.
4. Características de C#
Una vez que se ha explicado la tecnología .NET, se pasará a exponer las características de
C# y su perfecta complicidad con .NET.
Origen y necesidad de un nuevo lenguaje
Aunque es posible escribir código para la plataforma .NET en muchos otros
lenguajes, C# es el único que ha sido diseñado específicamente para ser utilizado en ella,
por lo que programarla usando C# es mucho más sencillo e intuitivo que hacerlo con
cualquiera de los otros lenguajes ya que C# carece de elementos heredados innecesarios en
.NET. Por esta razón, se suele decir que C# es el lenguaje nativo de .NET.
La sintaxis y estructuración de C# es muy similar a la C++, ya que la intención de
Microsoft con C# es facilitar la migración de códigos escritos en estos lenguajes a C# y
facilitar su aprendizaje a los desarrolladores habituados a ellos. Sin embargo, su sencillez y
el alto nivel de productividad son equiparables a los de Visual Basic.
Un lenguaje que hubiese sido ideal utilizar para estos menesteres es Java, pero
debido a problemas con la empresa creadora del mismo –Sun-, Microsoft ha tenido que
97
desarrollar un nuevo lenguaje que añadiese a las ya probadas virtudes de Java las
modificaciones que Microsoft tenía pensado añadirle para mejorarlo aún más y convertirlo
en un lenguaje orientado al desarrollo de componentes.
En resumen, C# es un lenguaje de programación que toma las mejores características de
lenguajes preexistentes como Visual Basic, Java o C++ y las combina en uno solo. El hecho
de ser relativamente reciente no implica que sea inmaduro, pues Microsoft ha escrito la
mayor parte de la BCL usándolo, por lo que su compilador es el más depurado y
optimizado de los incluidos en el .NET Framework SDK.
Características de C#
Se van a exponer de manera resumida las principales características de C#. Algunas
de las características aquí señaladas no son exactamente propias del lenguaje sino de la
plataforma .NET en general. Sin embargo, también se comentan aquí en tanto que tienen
repercusión directa en el lenguaje, aunque se indicará explícitamente cuáles son este tipo de
características cada vez que se toquen:
•
Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son
innecesarios en .NET. Por ejemplo:
o
El código escrito en C# es autocontenido, lo que significa que no necesita de
ficheros adicionales al propio fuente.
o
El tamaño de los tipos de datos básicos es fijo e independiente del
compilador, sistema operativo o máquina para quienes se compile (no como
en C++), lo que facilita la portabilidad del código.
98
o
No se incluyen elementos poco útiles de lenguajes como C++, tales como
macros, herencia múltiple o la necesidad de un operador diferente del punto
(.) para acceder a miembros de espacios de nombres (::)
•
Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los
años ha ido demostrándose son muy útiles para el desarrollo de aplicaciones y que
en otros lenguajes como Java o C++ hay que simular, como son: un tipo básico
decimal que permita realizar operaciones de alta precisión con reales de 128 bits
(muy útil en el mundo financiero), la inclusión de una instrucción foreach que
permite recorrer colecciones con facilidad y es ampliable a tipos definidos por el
usuario, la inclusión de un tipo básico string para representar cadenas o la distinción
de un tipo bool específico para representar valores lógicos.
•
Orientación a objetos: Como todo lenguaje de programación de propósito general
actual, C# es un lenguaje orientado a objetos, aunque eso es más bien una
característica del CTS que de C#. Una diferencia de este enfoque orientado a
objetos respecto al de otros lenguajes como C++ es que el de C# es más puro en
tanto que no admite ni funciones ni variables globales sino que todo el código y
datos han de definirse dentro de definiciones de tipos de datos, lo que reduce
problemas por conflictos de nombres y facilita la legibilidad del código.
C# soporta todas las características propias del paradigma de programación
orientada a objetos: encapsulación, herencia y polimorfismo.
En lo referente a la encapsulación es importante señalar que aparte de los típicos
modificadores public, private y protected, C# añade un cuarto modificador llamado
internal, que puede combinarse con protected e indica que al elemento a cuya
definición precede sólo puede accederse desde su mismo ensamblado.
99
Respecto a la herencia –a diferencia de C++ y al igual que Java- C# sólo admite
herencia simple de clases ya que la múltiple provoca más quebraderos de cabeza
que facilidades y en la mayoría de los casos su utilidad puede ser simulada con
facilidad mediante herencia múltiple de interfaces. De todos modos, esto vuelve a
ser más bien una característica propia del CTS que de C#.
Por otro lado y a diferencia de Java, en C# se ha optado por hacer que todos los
métodos sean por defecto sellados y que los redefinibles hayan de marcarse con el
modificador virtual (como en C++), lo que permite evitar errores derivados de
redefiniciones accidentales. Además, un efecto secundario de esto es que las
llamadas a los métodos serán más eficientes por defecto al no tenerse que buscar en
la tabla de funciones virtuales la implementación de los mismos a la que se ha de
llamar. Otro efecto secundario es que permite que las llamadas a los métodos
virtuales se puedan hacer más eficientemente al contribuir a que el tamaño de dicha
tabla se reduzca.
•
Orientación a componentes: La propia sintaxis de C# incluye elementos propios
del diseño de componentes que otros lenguajes tienen que simular mediante
construcciones más o menos complejas. Es decir, la sintaxis de C# permite definir
cómodamente propiedades (similares a campos de acceso controlado), eventos
(asociación controlada de funciones de respuesta a notificaciones) o atributos
(información sobre un tipo o sus miembros)
•
Gestión automática de memoria: Como ya se comentó, todo lenguaje de .NET
tiene a su disposición el recolector de basura del CLR. Esto tiene el efecto en el
lenguaje de que no es necesario incluir instrucciones de destrucción de objetos. Sin
embargo, dado que la destrucción de los objetos a través del recolector de basura es
100
indeterminista y sólo se realiza cuando éste se active –ya sea por falta de memoria,
finalización de la aplicación o solicitud explícita en el fuente-, C# también
proporciona un mecanismo de liberación de recursos determinista a través de la
instrucción using.
•
Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos
a tipos de datos siempre se realicen correctamente, lo que permite evitar que se
produzcan errores difíciles de detectar por acceso a memoria no perteneciente a
ningún objeto y es especialmente necesario en un entorno gestionado por un
recolector de basura. Para ello se toman medidas del tipo:
o
Sólo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo
y antecesores suyos, entre tipos para los que explícitamente se haya definido
un operador de conversión, y entre un tipo y un tipo hijo suyo del que un
objeto del primero almacenase una referencia del segundo (downcasting)
Obviamente, lo último sólo puede comprobarlo en tiempo de ejecución el
CLR y no el compilador, por lo que en realidad el CLR y el compilador
colaboran para asegurar la corrección de las conversiones.
o
No se pueden usar variables no inicializadas. El compilador da a los campos
un valor por defecto consistente en ponerlos a cero y controla mediante
análisis del flujo de control del fuente que no se lea ninguna variable local
sin que se le haya asignado previamente algún valor.
o
Se comprueba que todo acceso a los elementos de una tabla se realice con
índices que se encuentren dentro del rango de la misma.
o
Se puede controlar la producción de desbordamientos en operaciones
aritméticas, informándose de ello con una excepción cuando ocurra. Sin
101
embargo, para conseguirse un mayor rendimiento en la aritmética estas
comprobaciones no se hacen por defecto al operar con variables sino sólo
con constantes (se pueden detectar en tiempo de compilación)
o
A diferencia de Java, C# incluye delegados, que son similares a los punteros
a funciones de C++ pero siguen un enfoque orientado a objetos, pueden
almacenar referencias a varios métodos simultáneamente, y se comprueba
que los métodos a los que apunten tengan parámetros y valor de retorno del
tipo indicado al definirlos.
o
Pueden definirse métodos que admitan un número indefinido de parámetros
de un cierto tipo y a diferencia lenguajes como C/C++, en C# siempre se
comprueba que los valores que se les pase en cada llamada sean de los tipos
apropiados.
•
Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto
una serie de restricciones en el uso de las instrucciones de control más comunes. Por
ejemplo, la guarda de toda condición ha de ser una expresión condicional y no
aritmética, con lo que se evitan errores por confusión del operador de igualdad (==)
con el de asignación (=); y todo caso de un switch ha de terminar en un break o
goto, que indique cuál es la siguiente acción a realizar, lo que evita la ejecución
accidental de casos y facilita su reordenación.
•
Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos
que se definan siempre derivarán, aunque sea de manera implícita, de una clase base
común llamada System.Object, por lo que dispondrán de todos los miembros
definidos en esta clase (es decir, serán “objetos”)
102
A diferencia de Java, en C# esto también es aplicable a los tipos de datos básicos
Además, para conseguir que ello no tenga una repercusión negativa en su nivel de
rendimiento, se ha incluido un mecanismo transparente de boxing y unboxing con el
que se consigue que sólo sean tratados como objetos cuando la situación lo requiera,
y mientras tanto puede aplicárseles optimizaciones específicas.
El hecho de que todos los tipos del lenguaje deriven de una clase común facilita
enormemente el diseño de colecciones genéricas que puedan almacenar objetos de
cualquier tipo.
•
Extensibilidad de tipos básicos: C# permite definir, a través de estructuras, tipos
de datos para los que se apliquen las mismas optimizaciones que para los tipos de
datos básicos. Es decir, que se puedan almacenar directamente en pila (luego su
creación, destrucción y acceso serán más rápidos) y se asignen por valor y no por
referencia. Para conseguir que lo último no tenga efectos negativos al pasar
estructuras como parámetros de métodos, se da la posibilidad de pasar referencias a
pila a través del modificador de parámetro ref.
•
Extensibilidad de operadores: Para facilitar la legibilidad del código y conseguir
que los nuevos tipos de datos básicos que se definan a través de las estructuras estén
al mismo nivel que los básicos predefinidos en el lenguaje, al igual que C++ y a
diferencia de Java, C# permite redefinir el significado de la mayoría de los
operadores –incluidos los de conversión, tanto para conversiones implícitas como
explícitas- cuando se apliquen a diferentes tipos de objetos.
Las redefiniciones de operadores se hacen de manera inteligente, de modo que, a
partir de una única definición de los operadores ++ y --, el compilador puede deducir
automáticamente cómo ejecutarlos de manera prefija y postfija; definiendo
103
operadores simples (como +), el compilador deduce cómo aplicar su versión de
asignación compuesta (+=). Además, para asegurar la consistencia, el compilador
vigila que los operadores con opuesto siempre se redefinan por parejas (por
ejemplo, si se redefine ==, también hay que redefinir ¡=) .
También se da la posibilidad, a través del concepto de indizador, de redefinir el
significado del operador [] para los tipos de dato definidos por el usuario, con lo que
se consigue que se pueda acceder al mismo como si fuese una tabla. Esto es muy
útil para trabajar con tipos que actúen como colecciones de objetos.
Extensibilidad de modificadores: C# ofrece, a través del concepto de atributos, la
posibilidad de añadir, a los metadatos del módulo resultante de la compilación de
cualquier fuente información, adicional a la generada por el compilador, que luego
podrá ser consultada en tiempo ejecución a través de la librería de reflexión de
.NET . Esto, que más bien es una característica propia de la plataforma .NET y no
de C#, puede usarse como un mecanismo para definir nuevos modificadores.
•
Versionable: C# incluye una política de versionado que permite crear nuevas
versiones de tipos sin temor a que la introducción de nuevos miembros provoque
errores difíciles de detectar en tipos hijos previamente desarrollados y ya extendidos
con miembros de igual nombre a los recién introducidos.
Si una clase introduce un nuevo método, cuyas redefiniciones deban seguir la regla
de llamar a la versión de su padre en algún punto de su código, difícilmente
seguirían esta regla miembros de su misma signatura definidos en clases hijas
previamente a la definición del mismo en la clase padre; o si introduce un nuevo
campo con el mismo nombre que algún método de una clase hija, la clase hija dejará
de funcionar. Para evitar que esto ocurra, en C# se toman dos medidas:
104
o
Se obliga a que toda redefinición deba incluir el modificador override, con
lo que la versión de la clase hija nunca sería considerada como una
redefinición de la versión de miembro en la clase padre, ya que no incluiría
override. Para evitar que por accidente un programador incluya este
modificador, sólo se permite incluirlo en miembros que tengan la misma
signatura que miembros marcados como redefinibles mediante el
modificador virtual. Así, además se evita el error tan frecuente en Java de
creerse haber redefinido un miembro, pues si el miembro con override no
existe en la clase padre se producirá un error de compilación.
o
Si no se considera redefinición, entonces se considera que lo que se desea es
ocultar el método de la clase padre, de modo que para la clase hija sea como
si nunca hubiese existido. El compilador avisará de esta decisión a través de
un mensaje de aviso que puede suprimirse incluyendo el modificador new en
la definición del miembro en la clase hija para así indicarle explícitamente la
intención de ocultación.
•
Eficiente: En principio, en C# todo el código incluye numerosas restricciones para
asegurar su seguridad y no permite el uso de punteros. Sin embargo, y a diferencia
de Java, en C# es posible saltarse dichas restricciones manipulando objetos a través
de punteros. Para ello basta marcar regiones de código como inseguras (modificador
unsafe) y podrán usarse en ellas punteros de forma similar a cómo se hace en C++,
lo que puede resultar vital para situaciones donde se necesite una eficiencia y
velocidad de procesamiento muy grandes.
•
Compatible: Para facilitar la migración de programadores, C# no sólo mantiene
una sintaxis muy similar a C, C++ o Java que permite incluir directamente en
105
código escrito en C# fragmentos de código escrito en estos lenguajes, sino que el
CLR también ofrece, a través de los llamados Platform Invocation Services
(Pinvoke), la posibilidad de acceder a código nativo escrito como funciones sueltas
no orientadas a objetos tales como las DLLs de la API Win32. Nótese que la
capacidad de usar punteros en código inseguro permite que se pueda acceder con
facilidad a este tipo de funciones, ya que éstas muchas veces esperan recibir o
devuelven punteros.
También es posible acceder desde código escrito en C# a objetos COM. Para
facilitar esto, el .NET Framework SDK incluye unas herramientas llamadas tlbimp y
regasm mediante las que es posible generar automáticamente clases proxy que
permitan, respectivamente, usar objetos COM desde .NET como si de objetos .NET
se tratase y registrar objetos .NET para su uso desde COM.
Finalmente, también se da la posibilidad de usar controles ActiveX desde código
.NET y viceversa. Para lo primero se utiliza la utilidad aximp, mientras que para lo
segundo se usa la ya mencionada regasm.
106
ANEXO B:
Manual de Usuario
1.
Introducción a la aplicación
La función principal de la aplicación desarrollada es la de automatizar la forma de
procesar los datos contables de una empresa, de una manera sencilla y de fácil utilización.
De esta forma, puede ser utilizada tanto por personas que quieran registrar las cuentas de
una empresa real o, por otro lado, puede ser utilizada con fines lectivos para realizar
ejercicios en asignaturas de contabilidad. En el primer caso, el beneficio principal es poder
llevar las cuentas de una empresa de una forma ordenada. En el segundo caso, el profesor
se beneficia de tener la posibilidad de llevar a cabo ejercicios de cierta complicación de una
forma ordenada, siendo mucho más fácil evaluar y corregir a los alumnos. También se
benefician los alumnos, ya que debido a la automatización del proceso, pueden seguirlo con
mucha mayor facilidad y adquirir conocimientos de una forma más rápida, sencilla y
dinámica.
La aplicación permite el almacenamiento en una base de datos de diferentes
empresas con sus respectivos libros diarios, en donde quedan registradas todas las
operaciones de la empresa. El funcionamiento de la aplicación va ligado estrictamente al
funcionamiento del proceso contable: se va definiendo la información de la empresa, su
situación inicial y por cada año de funcionamiento de la empresa se busca registrar todas
sus operaciones para poder generar un documento final que contiene el libro diario, el libro
mayor y el balance de comprobación de cada año.
107
Una de las principales ventajas que aporta este programa es que se encarga de
detectar muchos de los errores que el usuario puede cometer. Así, cada vez que se introduce
algún dato u operación, la aplicación comprueba su validez y, en caso de no serlo, se lo
comunica al usuario. Con el fin de facilitar el funcionamiento al usuario, la aplicación
también contiene una sección de ayuda acerca del proceso general contable con el fin de
solucionar, en la medida de lo posible, las dudas que le surjan al usuario.
Es importante que el usuario tenga claro que los hechos contables de una empresa
están contenidos en los libros diarios de dicha empresa. Cada libro diario está constituido
por asientos y cada asiento está formado por operaciones. Éstas son los hechos contables
“atómicos” (o aislados) en el sentido de que no están compuestos por otros hechos
contables. Una operación puede ser, por ejemplo, apuntar 300 unidades monetarias en el
debe de una cuenta.
Por otro lado, a la hora de registrar las operaciones y los asientos, la aplicación
combina procesos manuales con procesos automáticos. Los asientos de operaciones
tangibles realizadas han de ser introducidos por el usuario pero los asientos de apertura, de
cierre de cuentas temporales y de cierre de cuentas permanente son generados
automáticamente por la aplicación y no pueden ser creados, modificados o eliminados por
el usuario.
108
2. Ejecución de la aplicación
Para comenzar a utilizar el programa se debe ejecutar el archivo ejecutable
“Aplicación contable”. Este es el archivo que lanza la aplicación. Así mismo en el mismo
directorio que el ejecutable de la aplicación debe existir una carpeta denominada
“Archivos_aplicación” que guarda la base de datos y los documentos de texto que se van a
cargar en la aplicación. Es muy importante que la base de datos denominada “bbdd” se
encuentre en dicha carpeta
El usuario debe ejecutar la aplicación sobre un dispositivo que permita tanto lectura
como escritura; no se podrá ejecutar, por ejemplo, estando guardada en un CD. También es
muy importante que el usuario no ejecute el programa desde un dispositivo de poca
velocidad como puede ser un dispositivo USB de almacenamiento externo; en caso de
hacerlo la velocidad de la aplicación en ciertos momentos puede ser muy lenta. Se
recomienda que la aplicación y los archivos necesarios mencionados se guarden en disco
duro para que la aplicación pueda ser ejecutada a una velocidad adecuada.
Por otra parte, la base de datos no debe ser modificada en ningún momento por el
usuario, es la aplicación la que se encarga se registrar y guardar en ella toda la información
necesaria. El usuario ha de interactuar con el programa ejecutable, no con la base de datos.
No es recomendable tener varias ejecuciones de la aplicación abiertas en el mismo
momento e interactuar con ellas ya que se pueden producir pérdidas o errores en los datos
de la base de datos.
109
3. Utilización de la aplicación
A continuación se irán explicando las diferentes pantallas de la aplicación con sus
respectivas funcionalidades. Al iniciar el programa se mostrará el menú principal; a partir
de ese momento el usuario irá recorriendo diferentes pantallas. Es muy importante que el
usuario tenga en cuenta que, a la hora de realizar operaciones con la aplicación, no se dará
la posibilidad de deshacer las operaciones realizadas. Por otro lado, también es importante
que el usuario sepa que las operaciones que va realizando son guardadas en la base de datos
en el mismo momento en que las realiza.
3.1 Menú Principal
Es la pantalla de inicio de la aplicación. En ella se muestran diferentes opciones. El
funcionamiento del programa va referido a una empresa, por tanto es muy importante que
el usuario tenga claro que antes de empezar a registrar operaciones hay que seleccionar la
empresa sobre la que se va a trabajar. Para ello se puede cargar una ya existente o definir
una nueva.
110
Figura1. Pantalla Principal
Existen cinco botones diferentes sobre los que pulsar con el fin de elegir una de las
opciones. Éstas son:
•
Nueva empresa. Permitirá al usuario introducir los datos de una nueva empresa
sobre la que llevar las cuentas.
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Ayuda. Mostrará una pantalla con los diferentes documentos de ayuda.
111
•
Acerca de la aplicación. Muestra una breve información sobre la autoría de la
aplicación.
•
Salir. Termina la aplicación.
3.2 Ficha de la empresa
A esta pantalla se puede acceder para crear una nueva empresa o para modificar los
datos de una empresa ya existente. En el primer caso, se presenta una pantalla que permitirá
al usuario rellenar los datos de la nueva empresa que quiere crear. En el segundo caso, se
muestran los campos con la información actual de la empresa y se da la posibilidad al
usuario para que los modifique. Es importante que el usuario rellene todos los campos. En
caso contrario, el programa no permitirá que se cree o modifique la empresa.
Figura 2. Ficha de la empresa
112
Como se aprecia en la figura 2, la empresa requiere de cuatro campos de información
para poder ser definida. Es obligatorio rellenar todos los campos:
•
Nombre. Es el nombre que tendrá la empresa. A éste se le añadirá S.A. o S.L. al
final en función del tipo de sociedad seleccionada.
•
Tipo. Se refiere al tipo de sociedad de la empresa. Sólo se contemplan dos posibles
opciones: S.A. (Sociedad Anónima) y S.L. (Sociedad Limitada). El nombre
completo de la empresa estará compuesto por el nombre introducido seguido del
tipo elegido.
•
Año Inicio. Es el primer año de funcionamiento de la empresa. El primer libro
diario con el que se trabajará se corresponde con este año. Es importante definir
bien el año de inicio ya que no podrán registrarse operaciones anteriores a este año.
En caso de que se modifique el año de inicio de una empresa ya existente, esto
puede acarrear consecuencias importantes. Si la empresa cambia su año de inicio
por un año anterior se crearán libros diarios vacíos para los años que van desde el
nuevo año de inicio hasta el año de inicio previo a la modificación. Si la empresa
cambia su año de inicio por uno posterior, se borrarán todos los libros diarios
existentes anteriores a la nueva fecha de inicio, por lo que es posible que el usuario
pierda operaciones de su empresa al realizar esta acción. Con el fin de que esto no
pase, el usuario deberá cambiar la fecha de los libros diarios que quiere conservar
antes de cambiar la fecha inicial de funcionamiento de la empresa.
•
Creador. Indica el nombre del creador de la empresa. Es el nombre del usuario. Así
se sabrá quién es el “dueño” de la empresa o de la persona que ha realizado el
ejercicio.
113
En la figura 2 se pueden ver también dos botones. Las funciones de estos botones son
las siguientes:
•
Borrar. Si el usuario pulsa este botón, el contenido de los cuatro campos quedará
borrado.
•
Aceptar. Es el botón que ha de pulsar el usuario para confirmar la creación de la
empresa con los datos introducidos. Si los cuatro campos están completos, el
programa mostrará dos mensajes informativos. El primero de ellos (Figura 3)
informa sobre la creación de la empresa y que, a continuación, se pasará a definir la
situación inicial de la empresa. El segundo de los mensajes (Figura 4) indica la
creación un libro diario vacío para el año de inicio de la empresa.
Figura 3. Mensaje informativo 1.
Figura 4. Mensaje informativo 2.
114
A lo largo de la ejecución de la aplicación se mostrarán diversos mensajes
informativos como los de las imágenes 3 y 4. También se mostrarán mensajes de error o
mensajes pidiendo al usuario la confirmación para realizar alguna acción. Por la
simplicidad de estos mensajes y su contenido auto-explicativo se van a obviar las
explicaciones al respecto en el este manual.
En esta pantalla existen dos menús. Uno de ellos se denomina “Archivo” y tiene tres
operaciones o submenús definidos que son:
•
Empresas Existentes. Pasa a la pantalla donde se muestran todas las empresas
existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
•
Salir de la aplicación. Cierra la aplicación.
Si se selecciona alguna de estas opciones se abandonará la pantalla actual sin crear
ninguna empresa.
El otro menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla de
ayuda”, en cuyo caso se abrirá una nueva ventana que contendrá los diferentes contenidos
de ayuda de la aplicación.
3.3 Empresas existentes
En esta pantalla se muestran todas las empresas que existen en la base de datos. Para
cada una de ellas se muestra el nombre completo, el año de inicio de la empresa y el
115
nombre del creador de la empresa. Pinchando en la cabecera de cada columna se puede
hacer que las filas de la tabla queden ordenadas respecto al campo de esa columna.
A esta pantalla se puede acceder desde el menú principal o desde los menús del
resto de aplicaciones.
Figura 5. Empresas Existentes
Como se ve en la figura 5 se puede encontrar cinco botones, cada uno nos da la
posibilidad de hacer una opción diferente:
116
•
Eliminar. Borra la empresa seleccionada de la base de datos. No se ofrecerá
posibilidad de recuperarla en un futuro. Al eliminar la empresa se eliminan todas las
operaciones e información asociada a ella.
•
Modificar datos. Permite reescribir la ficha de la empresa pudiendo modificar
nombre, tipo, año de inicio de la empresa o nombre del creador.
•
Situación inicial. Abre una pantalla en la que se muestra el balance inicial (o
situación inicial) definido para la empresa.
•
Ver libros diarios. Muestra en una nueva pantalla todos los libros diarios que han
sido creados para esa empresa. Cabe recordar que cada uno de los años de
funcionamiento de la empresa deben llevar asociado un libro diario.
•
Añadir libro diario. Añade un libro diario a continuación del último. Por ejemplo
si la empresa Sociedad Comercial S.A. tiene definidos un libro diario para el 2001 y
otro para el 2002, si se pulsa sobre este botón se creará un libro diario para el 2003.
Para que cada uno de estos botones pueda realizar su función es necesario que una de
las filas de la matriz de empresas esté seleccionada o se haya pinchado sobre ella. En caso
de que no haya ninguna empresa creada y, por tanto, no haya filas en la matriz, los botones
estarán deshabilitados ya que sus acciones van ligadas a la existencia de alguna empresa.
En esta pantalla existen dos menús. Uno de ellos se denomina “Archivo” y tiene tres
operaciones o submenús definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
117
•
Salir de la aplicación. Cierra la aplicación.
El otro menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla de
ayuda”, en cuyo caso se abrirá una nueva ventana que contendrá los diferentes contenidos
de ayuda de la aplicación.
3.4 Libros diarios de una empresa
Para acceder a esta pantalla hay que pulsar el botón “Ver libros diarios” desde la
pantalla de “Empresas existentes” o desde el menú “Libros diarios de la empresa” desde las
pantallas de “Evolución del libro diario”, de “Resumen anual” y de “Situación inicial”.
Aquí se muestran todos los libros diarios que pertenecen a la empresa seleccionada. Cada
libro diario se identifica por el año al que pertenece. También se muestra la información
definida como ficha de la empresa:
Figura 6. Libros diarios de una empresa
118
En la figura 6 se puede ver que existen seis botones con diferentes funciones:
•
Situación inicial. Muestra la pantalla donde se define la situación inicial de la
empresa.
•
Borrar diario. Borra el libro diario seleccionado. Es necesario que se haya
pinchado o seleccionado alguna fila de la matriz de libros diarios. Al borrar un libro
diario se borran todas las operaciones asociadas a él. La aplicación considera que
una empresa ha de tener libros diarios (aunque no tengan operaciones definidas) a lo
largo de todos sus años de funcionamiento, por lo que si se borra un libro diario se
borrarán también todos los libros diarios de la empresa para los años posteriores.
•
Añadir diario. Añade un libro diario vacío a la empresa. Se corresponderá con el
año siguiente al del último libro diario de la empresa.
•
Borrar asientos. Elimina todas las operaciones del libro diario seleccionado. Es
necesario que se haya pinchado o seleccionado alguna fila de la matriz de libros
diarios. Deja el libro diario vacío, sólo contará con el asiento de apertura si es
necesario.
•
Ver asientos. Abre una nueva pantalla donde se muestran todas las operaciones del
libro diario correspondiente. Es necesario que se haya pinchado o seleccionado
alguna fila de la matriz de libros diarios. Esta operación puede tardar unos segundos
ya que hay que reestructurar el asiento de apertura y cargar todos los demás.
•
Cambiar año. Es necesario que se haya pinchado o seleccionado alguna fila de la
matriz de libros diarios. Permite cambiar el año al que pertenece el libro diario. Al
pulsar este botón se extiende la pantalla mostrando un campo donde se ha de
119
introducir el nuevo año del libro diario y dos nuevos botones. Los botones ya
descritos se deshabilitan. Todo esto se puede observar en la figura 7.
Figura 7. Libros diarios de una empresa, cambiar año.
El nuevo campo está destinado a introducir el nuevo año del libro diario. La aplicación
comprobará que sea un año válido. Como se puede ver en la figura también se incorporan
dos nuevos botones:
•
Cambiar. Una vez que el usuario haya introducido el nuevo año, ha de pulsar en
este botón para realizar el cambio. La aplicación pedirá una confirmación mediante
un mensaje de interrogación. Si el año nuevo introducido coincide con un libro
120
diario existente éste será sobrescrito perdiendo sus operaciones. Para el año
(anterior a la modificación) del libro diario seleccionado, se dejará un libro diario
vacío.
•
Cancelar. Se debe pulsar para indicar que finalmente no se quiere cambiar el libro
diario de año. Al pulsarlo la pantalla vuelve a su tamaño anterior (con lo que no se
ven los elementos relacionados con el “nuevo año del asiento”) y se vuelven a
habilitar el resto de botones.
En esta pantalla existen dos menús. Uno de ellos se denomina “Archivo” y tiene cuatro
operaciones o submenús definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
•
Salir de la aplicación. Cierra la aplicación.
El otro menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla de
ayuda”, en cuyo caso se abrirá una nueva ventana que contendrá los diferentes contenidos
de ayuda de la aplicación.
121
3.5 Situación inicial de la empresa
A esta pantalla se accede justo después de crear una nueva empresa. También se
puede acceder a ella desde el botón de “Situación inicial” en la pantalla de “Empresas
existentes”, desde el botón “Situación inicial” de la pantalla “Libros diarios de una
empresa” o desde el botón “Ver Situación inicial” de la pantalla “Evolución del Libro
diario”.
En esta pantalla se puede definir la situación inicial de la empresa a 1 de enero del
primer año de funcionamiento. En la parte superior izquierda se muestra una tabla o matriz
con los estados iniciales del debe donde el usuario ha de registrar todas aquellas cuentas
que inicialmente van a tener un valor positivo para el debe. En la parte superior derecha se
puede ver una tabla o matriz con los estados iniciales del haber para todas aquellas cuentas
que vayan a comenzar con un valor positivo en el haber. Ambas matrices tienen dos
columnas: Nombre de la cuenta y Cantidad asociada al debe o al haber. En caso de pinchar
en alguna de las cabeceras de las columnas de la tabla, las filas de la tabla quedarán
ordenadas según la columna seleccionada.
122
Figura 8. Situación inicial de una empresa.
En la parte inferior se muestran los campos a rellenar para añadir una nueva cuenta
al balance inicial. Los campos que se pueden ver son:
•
Nº Cuenta. A rellenar por el usuario para indicar la cuenta cuyo valor inicial de
debe o haber se quiere definir.
•
Nombre. Muestra automáticamente el nombre de la cuenta que se corresponde con
el número de cuenta introducido por el usuario en “Nº Cuenta”. Esto sólo sucede en
caso de que la cuenta introducida sea una cuenta existente en el plan general
contable.
123
•
Tipo. Muestra automáticamente el tipo de la cuenta que se corresponde con el
número de cuenta introducido por el usuario en “Nº Cuenta”. Esto sólo sucede en
caso de que la cuenta introducida sea una cuenta existente en el Plan General
Contable. El tipo de la cuenta puede ser activo, pasivo, ingreso o gasto y estará entre
paréntesis en caso de que su valor se vaya a introducir de manera negativa.
•
Cantidad. Es un campo que el usuario debe rellenar para indicar la cantidad de
unidades monetarias que le corresponden a la situación inicial de la cuenta indicada.
A continuación se explican las funciones de los botones existentes en la figura 8:
•
Añadir a debe. Añade la nueva entrada a la matriz del debe. Sólo permite hacer
esto si la cuenta introducida puede tener definido un valor para el debe en la
situación inicial. En caso de ser necesario según el tipo de cuenta que sea, el valor
se registrará de forma negativa en el debe. La aplicación controlará que tanto el
valor como el número de cuenta introducidos sean correctos y que esa cuenta no
esté registrada ya en la situación inicial.
•
Borrar de debe. Elimina la fila seleccionada de la matriz del debe. Si no hay filas
en la matriz este botón estará deshabilitado.
•
Añadir a haber. Añade la nueva entrada a la matriz del haber. Sólo permite hacer
esto si la cuenta introducida puede tener definido un valor para el haber en la
situación inicial. En caso de ser necesario según el tipo de cuenta que sea, el valor
se registrará de forma negativa en el haber. La aplicación controlará que tanto el
valor como el número de cuenta introducidos sean correctos y que esa cuenta no
esté registrada ya en la situación inicial.
124
•
Borrar de haber. Elimina la fila seleccionada de la matriz del haber. Si no hay filas
en la matriz este botón estará deshabilitado.
•
Ver cuentas. Muestra una pantalla con las diferentes cuentas del Plan General
Contable y sus números de cuenta correspondientes.
•
Ir a Diario de año siguiente. Al pulsar este botón se pasa a seguir la evolución del
libro diario del primer año de funcionamiento de la empresa.
En esta pantalla existen tres menús. Uno de ellos se denomina “Archivo” y tiene
cuatro operaciones o submenús definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
•
Salir de la aplicación. Cierra la aplicación.
El segundo menú es el de “Libros Diarios” que cuenta con una operación o
submenú denominado “Libros diarios de la empresa” que abre la ventana con dicho nombre
donde se muestran todos los libros diarios pertenecientes a esa empresa.
El tercer menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla
de ayuda” en cuyo caso se abrirá una nueva ventana que contendrá los diferentes
contenidos de ayuda de la aplicación.
125
Cada vez que se pulsa un botón o una opción de menú que haga abandonar la
pantalla de “Situación inicial de la empresa” el programa comprobará que la suma de las
cantidades del haber es equivalente a la suma de las cantidades del debe. En caso de no ser
así, el programa no permitirá abandonar la pantalla. Si la aplicación es forzada a terminar
desde el sistema operativo, cuando se vuelva a reiniciar la aplicación, ésta borrará todas
aquellas situaciones iniciales que no estén correctamente balanceadas.
Cabe la posibilidad de dejar la situación inicial sin ninguna fila en las tablas. En este
caso la ejecución del programa continuará normalmente y simplemente no habrá asiento de
apertura definido para el primer año de funcionamiento de la empresa.
3.6 Evolución del Libro diario
En esta pantalla se muestra una tabla con los diferentes asientos del libro diario y
sus correspondientes operaciones. En caso de que corresponda hacer un asiento de apertura
para el libro diario, esto lo hará la aplicación automáticamente y lo mostrará con la
explicación pertinente. La tabla con los asientos está constituida por siete columnas:
•
Nº Asiento. Especifica el número de asiento. Los asientos se van enumerando en
orden creciente según su fecha. El asiento de apertura, si es que existe, siempre será
el asiento número 1.
•
Fecha. Indica la fecha de asiento. El asiento de apertura siempre tendrá la fecha del
1 de enero del año al que pertenece.
•
Nombre cuenta. Indica el nombre de la cuenta que interviene en cada operación.
•
Nº Cuenta. Indica el número de la cuenta que interviene en cada operación.
126
•
Debe. Contiene el valor del debe en unidades monetarias para cada operación.
•
Haber. Contiene el valor del haber en unidades monetarias para cada operación.
•
Explicación. Contiene una explicación para cada una de las operaciones de los
asientos. En caso de que la operación no cuente con una explicación, el campo
contendrá la palabra “No”.
Figura 9. Evolución de un libro diario
Como se ve en la figura 9 existen seis botones, cada uno con una función diferente:
•
Ver Saldo. Abre una pantalla con el saldo provisional para la cuenta seleccionada
en la etiqueta desplegable de la izquierda del botón. Para ello es preciso haber
seleccionado un número de cuenta con anterioridad en dicha etiqueta.
•
Ver situación inicial. Cambia a la pantalla de “Situación inicial de la empresa” a la
que pertenece el libro diario actual.
127
•
Balance sumas/saldos. Muestra el balance de sumas y saldos provisional del libro
diario.
•
Borrar asiento. Elimina el asiento correspondiente a la operación de la matriz que
esté seleccionada. Es preciso que se haya seleccionado alguna fila. En caso de que
la operación pertenezca al asiento de apertura la aplicación no permitirá que el
asiento sea borrado. El asiento de apertura se genera automáticamente y no se le
permite al usuario eliminarlo o modificarlo.
•
Añadir asiento. Abre la pantalla que va a permitir al usuario crear un nuevo asiento
y añadirlo al libro diario.
•
Cerrar ejercicio. “Cierra” (en términos de contabilidad”) el libro diario o ejercicio
actual y pasa a la pantalla en la que se muestra el resumen anual (libro diario, libro
mayor y balance de comprobación para el año de actividad de la empresa).
En esta pantalla existen tres menús. Uno de ellos se denomina “Archivo” y tiene
cuatro operaciones o submenús definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
•
Salir de la aplicación. Cierra la aplicación.
128
El segundo menú es el de “Libros Diarios” que cuenta con una operación o
submenú denominado “Libros diarios de la empresa” que abre la ventana con dicho nombre
donde se muestran todos los libros diarios pertenecientes a esa empresa.
El tercer menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla
de ayuda” en cuyo caso se abrirá una nueva ventana que contendrá los diferentes
contenidos de ayuda de la aplicación.
3.7 Saldo de la Cuenta
Esta ventana se abre sobre la pantalla de “Evolución del libro diario” y muestra las
operaciones de la cuenta seleccionada y el saldo total indicando si es deudor o acreedor.
Las operaciones las muestra en una tabla similar a la de “Evolución del libro diario” que
cuenta con cinco columnas: Debe, Haber, Nº Asiento, Fecha, Explicación. La ventana sólo
cuenta con un botón que al pulsarlo cierra la ventana.
Figura 10. Saldo de una cuenta.
129
3.8 Balance de Sumas y saldos
Esta ventana se abre sobre la pantalla de “Evolución del libro diario” y contiene una
tabla con el balance provisional de sumas y saldos. Esta tabla contiene seis columnas:
•
Nombre de la cuenta. Indica el nombre de cada cuenta que interviene en el libro
diario.
•
Nº cuenta. Indica el número de cada cuenta que interviene en el libro diario.
•
Debe. Representa la suma de todos los valores del debe en las operaciones del libro
diario.
•
Haber. Representa la suma de todos los valores del haber en las operaciones del
libro diario.
•
Deudor. Si el saldo de la cuenta es deudor, esta columna muestra el saldo, si no
mostrará 0.
•
Acreedor. Si el saldo de la cuenta es acreedor, esta columna muestra el saldo, si no
mostrará 0.
Debajo de la tabla se muestran los totales que representan la suma de las operaciones
del debe, la suma de las operaciones del haber, la suma de todos los saldos deudores y la
suma de todos los saldos acreedores.
130
Figura 11. Balance de sumas y saldos.
3.9 Añadir Asiento
Esta pantalla permite al usuario crear un asiento nuevo que se añadirá al libro diario
correspondiente. Para definir un asiento es necesario indicar la fecha del asiento y las
operaciones que lo componen. En la figura 12 se puede ver la pantalla al completo pero se
analizarán las distintas partes con nuevas imágenes.
131
Figura 12. Añadir Asiento.
En primer lugar, en la parte superior izquierda, existe un calendario desplegable en
el cual el usuario debe seleccionar la fecha del asiento. Sólo se admitirán fechas
pertenecientes al año del libro diario al que va a pertenecer el asiento. Se puede ver el
calendario desplegable en la figura 13.
132
Figura 13. Añadir asiento, elegir fecha.
En la figura 12 se puede ver, en la parte superior, un grupo de elementos necesarios
para definir las operaciones que tienen valores distintos de cero en su “debe”. En la parte
inferior (encima de los cuatro botones) existe otro grupo de elementos que se utilizan para
definir las operaciones que tienen valores distintos de cero en su “haber”. Dado que ambos
grupos funcionan de la misma manera, se analizará sólo uno de ellos, en concreto el del
Haber.
Figura 14. Añadir asiento, operaciones del Haber.
133
En la parte derecha de la figura 14 se ve una tabla o matriz que representa las
operaciones ya añadidas al asiento para el haber. Si se pincha en la cabecera de cada
columna las filas se ordenaran según los valores de esa columna. La tabla cuenta con tres
columnas:
•
NºCuenta. Especifica el número de la cuenta que interviene en la operación.
•
Valor. Especifica el valor del haber de la operación.
•
Explicación. Contiene una breve explicación de carácter opcional sobre la
operación. Si contiene el valor “No” es que ninguna explicación ha sido introducida
por el usuario.
Una vez que el usuario haya introducido el número de cuenta y el valor en los
campos “Nº de cuenta” y “Valor haber” (que se explicarán a continuación) podrá añadir
la nueva operación a la tabla pulsando en el botón “Añadir ”. Al hacer esto, el programa
comprobará la validez de la operación y, si es una operación posible, la añadirá a la tabla.
En caso contrario, dará un mensaje de error.
El usuario también podrá borrar operaciones de la tabla pulsando el botón “Borrar”
después de haber seleccionado alguna operación. Si la tabla está vacía, este botón estará
deshabilitado
Para añadir una operación con valor no nulo en el haber, el usuario primero tendrá
que rellenar los campos:
•
Nº de cuenta: se escribe el número de la cuenta que interviene en la operación.
134
•
Valor haber: se escribe la cantidad de unidades monetarias que irán al haber de la
cuenta.
Al modificar el campo “Nº de cuenta” y escribir un número de cuenta válido del
Plan General Contable, los siguientes campos tomarán nuevos valores:
•
Nombre. Mostrará el nombre de cuenta correspondiente a la cuenta introducida por
el usuario en el campo “Nº de cuenta”.
•
Tipo. Mostrará el tipo de cuenta correspondiente a la cuenta introducida por el
usuario en el campo “Nº de cuenta”. El tipo puede ser: activo, pasivo, gasto o
ingreso. Si el tipo indicado va entre paréntesis entonces el valor especificado por el
usuario en el campo “Valor haber” pasará a ser negativo al añadirse la nueva
operación al asiento. Es decir, si el usuario se encuentra, por ejemplo, con un tipo
que sea “(Activo)”, e introduce la cantidad 200 en “Valor haber” entonces al pulsar
el botón “Añadir” la cantidad que pasará a formar parte de la columna “Valor” de la
tabla para la nueva operación será -200.
En la figura 14 se puede encontrar también una casilla que se puede marcar. A su
derecha se puede leer “Incluir IVA”. Si se marca esa casilla se habilitará una pestaña
desplegable a la derecha de la casilla que incluye los valores 16%, 7% y 4%. Si la opción
de “Incluir IVA” está marcada, al añadir la operación a la tabla se añadirá otra operación
que contendrá el valor correspondiente al IVA (de la operación introducida por el usuario)
con un valor del 16%, 7% o 4% (según haya indicado el usuario en la pestaña desplegable)
sobre lo introducido en el campo “Valor haber”. Si se generan varias operaciones de IVA
135
en la tabla, todas las operaciones se agruparán sobre una sola operación que llevará la suma
de todas ellas. Es importante que el usuario sepa que estas operaciones de IVA se generan
automáticamente pero, en caso de que se las quiera eliminar, deben ser borradas
manualmente por el usuario.
En la figura 14 se puede ver, por último, dos círculos en la parte inferior derecha.
Uno de ellos se corresponde con “Incluir explicación” y el otro se corresponde con “No
incluir explicación”. Por defecto, el segundo de ellos estará marcado. En todo momento uno
de los dos estará marcado y el usuario será el que elija entre uno de los dos. Si el que está
marcado es el de “Incluir explicación”, se incluirá la explicación de la caja de texto de la
derecha (que el usuario puede pinchar y escribir para modificarla) en el campo Explicación
de la tabla de operaciones (en la columna de explicación).
Para continuar con la explicación de la pantalla de “Añadir asiento” se analizará la
función de los cuatro botones que aparecen en la parte inferior de la pantalla:
•
Volver. Hace que el programa vuelva a la pantalla anterior de “Evolución del libro
diario”. En este caso el asiento no se genera a pesar de que tuviera operaciones
definidas en las tablas.
•
Ver Cuentas. Abre la ventana con la tabla de cuentas.
•
Borrar todo. Borra el contenido de la tabla del haber y del debe.
•
Generar asiento. Si la suma de las cantidades del haber cuadra con la suma de las
cantidades del debe y la fecha es correcta se generará una nuevo asiento en la base
136
de datos. Después se vuelve a la pantalla de “Evolución del libro diario” donde se
podrá visualizar el nuevo asiento añadido.
Para finalizar con esta pantalla se explicarán sus menús. En esta pantalla existen dos
menús. El primero se denomina “Archivo” y tiene cuatro operaciones o submenús
definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio.
•
Salir de la aplicación. Cierra la aplicación.
Si se selecciona cualquiera de estas cuatro opciones, el asiento no se completará y se
perderán las operaciones definidas en las tablas.
El segundo menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver
pantalla de ayuda” en cuyo caso se abrirá una nueva ventana que contendrá los diferentes
contenidos de ayuda de la aplicación.
137
3.10 Cuadro de Cuentas
Esta ventana se abre cuando se pulsa el botón “Ver Cuentas” existente en las
pantallas de “Situación inicial de la empresa” y de “Añadir asiento”. Muestra un documento
de texto con todas las cuentas del Plan General Contable, ordenadas y clasificadas según
sus números de cuenta. Si se pulsa sobre el botón “por orden alfabético” se muestra el
cuadro de cuentas ordenadas por orden alfabético.
Figura 15. Cuadro de Cuentas.
138
3.11 Cuadro de Cuentas (por orden alfabético)
Esta ventana se abre cuando se pulsa el botón “Por orden alfabético” existente en las
pantallas de “Situación inicial de la empresa” y de “Añadir asiento”. Muestra un documento
de texto con todas las cuentas del plan general contable, ordenadas y clasificadas por orden
alfabético.
Figura 16. Cuadro de Cuentas (por orden alfabético).
139
3.12 Resumen Anual
Esta pantalla presenta el documento generado como resumen anual de la actividad
de la empresa en el año especificado. Abrir esta pantalla puede tardar unos segundos ya que
hay que recalcular los asientos de cierre con el fin de mostrarlos actualizados. El resumen
anual está estructurado en tres partes:
•
Libro Diario. Se muestran los asientos del libro diario ordenados por orden
cronológico (el asiento de apertura siempre será el primero). Para cada asiento se
muestra su número, su fecha y todas sus operaciones. De cada operación se muestra
la siguiente información: el número y el nombre de la cuenta que interviene en la
operación, la cantidad asociada al “haber” o al “debe” de la operación y la
explicación de la operación en caso de que haya sido definida por el usuario
previamente.
Cabe destacar que es éste el único momento en que se pueden ver los asientos de
cierre temporales y el de cierre permanente, que son generados automáticamente por
la aplicación y que no se han mostrado en la pantalla de “Evolución del libro diario”
dado que son asientos que se han de generar a cierre de ejercicio. El asiento de
apertura, en caso de existir, será siempre el primero e irá seguido del comentario
“Apertura de balance”. Los asientos de cierre de cuentas temporales, en caso de
existir, irán antes que el de cierre de cuentas permanente y estarán identificados por
los comentarios “Cierre de cuentas temporales (p y g) al haber” y “Cierre de cuentas
temporales (p y g) al debe”. El asiento de cierre permanente, en caso de existir
siempre será el último. El asiento de apertura se puede ver en la figura 17 y los
asientos de cierre en la 18.
140
Hay tres puntos en la escritura de los asientos en los que se hace un recuento de los
asientos escritos hasta el momento y se muestra la suma de las columnas del debe y
la suma de las columnas del haber. El primero es antes de los asientos de cierre de
cuentas temporales. El segundo es después de estos asientos (pero sólo en caso de
que alguno de ellos exista) y el tercer punto es después del asiento de cierre de
cuentas permanente (sólo si este asiento existe). Se pueden apreciar estas sumas en
el segundo y el tercer punto mencionados en la figura 18.
Figura 17. Libro diario, parte inicial.
141
Figura 18. Libro diario, parte final.
•
Libro mayor. Se muestran todas las cuentas que han intervenido en el libro diario
una a una, ordenadas de menor a mayor por su número de cuenta. Para cada cuenta
se muestra también su nombre y dos columnas con las referencias a los asientos en
los que intervienen y con qué cantidades. La columna de la izquierda se refiere a
operaciones del debe y la columna de la derecha se refiere a operaciones del haber.
142
Figura 19. Libro mayor, parte inicial
•
Balance de comprobación. Cuenta con seis columnas que expresan el número, el
nombre, la suma del debe, la suma del haber y el saldo deudor o acreedor de cada
cuenta. Al final se contabiliza la suma total de las sumas del debe, las sumas del
haber, los saldos deudores y los saldos acreedores. En primer lugar se muestra el
balance de sumas y saldos antes del cierre de las cuentas de gastos e ingresos. Es
decir, que no contempla los asientos de cierre de cuentas temporales ni el asiento de
cierre de cuentas permanente. En segundo lugar se muestra el balance de sumas y
saldos después del cierre de las cuentas de gastos e ingresos, contabilizando ya los
asientos de cierre de cuentas temporales pero no el de cierre de cuentas permanente.
143
Figura 20. Balance de comprobación antes del cierre de las cuentas de gastos e ingresos.
Figura 21. Balance de comprobación después del cierre de las cuentas de gastos e ingresos.
144
El mismo documento que se muestra por pantalla se puede encontrar en un archivo
Word que se encontrará en el mismo directorio donde se haya ejecutado la aplicación. El
nombre del archivo está formado por el nombre de la empresa a la que pertenece el
resumen anual seguido del nombre del creador de dicha empresa y tendrá extensión rtf.
Cuando se abra este documento con Microsoft Word se deberá abrir con codificación
Unicode (UTF-8).
Esta pantalla, además de mostrar el documento con el resumen anual, posee tres
botones:
•
Menú principal. Cierra la ventana actual y abre la pantalla del menú principal.
•
Diarios de la empresa. Muestra una pantalla con todos los años de funcionamiento
definidos para la empresa, con la posibilidad de seleccionar alguno de ellos y seguir
la evolución del libro diario de ese año.
•
Diario año siguiente. Pasa a la pantalla que sigue la evolución del libro diario del
año siguiente. En caso de que para el año siguiente no exista ya un libro diario, se
creará uno nuevo vacío (sólo con el asiento de apertura si éste ha de crearse).
En esta pantalla existen tres menús. Uno de ellos se denomina “Archivo” y tiene
cuatro operaciones o submenús definidos que son:
•
Nueva Empresa. Pasa a la pantalla de “Ficha de la empresa” para que se pueda
registrar una nueva empresa en la base de datos.
145
•
Empresas existentes. Esta opción ha de ser seleccionada en caso de que se quiera
cargar una empresa definida con anterioridad. Se pasará a una pantalla donde se
mostrará una lista con todas las empresas existentes en la base de datos.
•
Menú Principal. Vuelve a la pantalla de inicio, igual que el botón de “Menú
principal
•
Salir de la aplicación. Cierra la aplicación.
El segundo menú es el de “Libros Diarios” que cuenta con una operación o
submenú denominado “Libros diarios de la empresa” que abre la ventana con dicho nombre
donde se muestran todos los libros diarios pertenecientes a esa empresa. Tiene la misma
función que el botón “Diarios de la empresa”
El tercer menú es el de “Ayuda” que da la posibilidad de pulsar sobre “Ver pantalla
de ayuda” en cuyo caso se abrirá una nueva ventana que contendrá los diferentes
contenidos de ayuda de la aplicación.
146
3.13 Ayuda
Muestra una serie de pestañas, cada una con un contenido diferente de ayuda. Por
ejemplo, la primera pestaña está constituida por otras seis subpestañas. En éstas se pueden
ver una serie de documentos del “Plan General Contable” que cuenta con una introducción
y cinco partes diferenciadas:
•
Primera parte. Son los “Principios contables”. Se enuncian una serie de principios
que han de cumplirse con el fin de conducir a que “las Cuentas Anuales, formuladas
con claridad, expresen la figura fiel del patrimonio, de la situación financiera y de
los resultados de la empresa”.
•
Segunda parte. Es el “Cuadro de cuentas”. Muestra todas las cuentas definidas en el
plan contable ordenadas y clasificadas por sus números de cuenta.
•
Tercera parte. Son las “Definiciones y relaciones contables”. Analiza la forma de
operar con las cuentas.
•
Cuarta parte, cuyo título es “Cuentas anuales”. Establece cómo se debe realizar los
documentos que recojan las cuentas anuales de una empresa y qué información
deben contener.
•
Quinta parte. Son las “Normas de valoración” que representan ciertas reglas a
aplicar al valorar determinadas cuentas.
147
Figura 22. Ayuda, pestaña de introducción al Plan General Contable.
En otras pestañas se pueden ver las Normas Internacionales de Contabilidad (NICs)
y las resoluciones del ICAC desde el año 1992 hasta el 2005.
3.14 Acerca de la aplicación
Muestra cierta información básica sobre la autoría de la aplicación. Su contenido se puede
ver en la figura:
148
Figura 23. Acerca de la aplicación.
4. Ejemplo – Ejercicio Resuelto
En esta sección se mostrará, paso a paso, cómo se realiza un ejercicio sencillo de
contabilidad. Se mostrará el enunciado y después se expondrá cómo resolverlo paso a paso
con la aplicación.
4.1 Enunciado
El ejercicio que se va a resolver es muy sencillo ya que sólo se pretende mostrar el
funcionamiento de la aplicación. El ejercicio es una simplificación de otro ejercicio más
complejo que contaba con libros diarios para tres años. El presente ejercicio sólo tiene en
cuenta el primer año. El enunciado es el siguiente:
149
El 1 de enero de 2002 comienza a funcionar la empresa “Comercial S.A.”. En su
situación inicial se presenta una aportación de 4000 unidades monetarias por parte de los
socios de la empresa como capital. Durante el año 2002 se realizaron las siguientes
operaciones
1. 1 de Febrero. La sociedad tomó un préstamo bancario por un principal de 1.000 u.m.
2. 3 de Febrero. Un fabricante suministró a crédito a la sociedad 100 unidades de un
artículo al precio unitario de 6 u.m.
3. 4 de Febrero. Los gastos de constitución de la sociedad supusieron un desembolso de
50 u.m.
4. 1 de Junio. La sociedad adquirió y pagó por caja un terreno por 1.000 u.m.
5. 15 de Agosto. Asimismo adquirió y pagó por caja un edificio sobre dicho terreno por
2.000 u.m.
6. 11 de Noviembre. La sociedad también adquirió y pagó por caja muebles de oficina
por importe de 200 u.m.
Se pide, para el año 2002:
1. Libro diario
2. Libro mayor
3. Balances de situación
Supuesto: Estas operaciones no tienen IVA.
4.2 Crear la empresa
Para comenzar el ejercicio es necesario crear la empresa con la que se va a trabajar
en el ejercicio. Para ello al abrir la aplicación se escoge la opción de “Crear empresa” del
150
Menú principal. Se introducen los datos de la nueva empresa (como se ve en la figura 24) y
se pulsa el botón Aceptar.
Figura 24. Creando la empresa Comercial S.A.
Una vez que se ha pulsado el botón Aceptar y dado que los datos son correctos, la
aplicación muestra los mensajes informativos de las figuras 25 y 26 y pasa a la pantalla que
permitirá definir la situación inicial de la empresa.
151
Figura 25. Empresa Comercial S.A. creada.
Figura 26. Libro diario para el 2002 generado automáticamente
4.3 Definir Situación inicial
Una vez en la pantalla de Situación inicial de la empresa, se debe registrar la
aportación de 4000 unidades monetarias por parte de los socios de la empresa como capital
social. Esto se puede ver en la figura 27. Después se pulsa el botón “Ir a Diario 2002” para
empezar a introducir los asientos del primer libro diario de la empresa.
152
Figura 27. Situación inicial de la empresa
4.4 Evolución del libro diario para el año 2002
Cuando se abre la pantalla con el libro diario del 2002, sólo contendrá el asiento de
apertura definido automáticamente por la aplicación. Esto se puede ver en la figura 28.
153
Figura 28. Libro diario con asiento de apertura
A continuación se han de introducir los asientos con las operaciones que realiza la
empresa, tal como se dice en el enunciado del ejercicio. El primer asiento reflejará las
operaciones necesarias de:
“1 de Febrero. La sociedad tomó un préstamo bancario por un principal de 1.000 u.m.”
En la figura 29 se puede ver las dos operaciones introducidas al asiento y la fecha
seleccionada.
154
Figura 29. Creando el primer asiento.
De la misma forma se van creando todos los asientos de la empresa hasta que, como
se puede ver en las figuras 30a y 30b, se han completado todas las operaciones de la
empresa en el año 2002. El último asiento es el de recuento de existencias físicas del
almacén de las mercaderías compradas. Se entiende que no se ha consumido ni vendido
ninguna de ellas, por lo que el inventario físico de fin de año equivale exactamente a las
unidades monetarias de la operación de compra del 3 de Febrero.
155
Figura 30a. Asientos del libro diario de 2002.
Figura 30b. Asientos del libro diario de 2003.
En la figura 31 se muestra, como ejemplo, el resultado de ver el saldo de la cuenta
570.
156
Figura 31. Saldo de la cuenta 570.
En la figuras 32a y 32b se muestra el balance de sumas y saldos del libro diario.
Figura 32a. Balance de sumas y saldos.
157
Figura 32b. Balance de sumas y saldos.
Una vez que ya no se quiere visualizar o añadir asientos se realiza la generación del
resumen anual de la actividad para el año 2002. Para ello se pulsa el botón “Cerrar
ejercicio” que se puede ver en la figura 30. La aplicación mostrará un mensaje informativo
como el de la figura 33.
Figura 33. Se va a generar un documento de texto
158
4.5 Resumen anual del 2002
A continuación se muestra una pantalla en la que se puede ver el resumen anual del
libro diario del 2002. Este mismo resumen se almacena sobre un documento que se crea en
el directorio donde se encuentra el ejecutable de la aplicación. El nombre del documento
será “Comercial S.A.-Alumno X-2002” y tendrá extensión RTF. Se podrá abrir con
Microsoft Word con codificación unicode UTF-8. La pantalla con el resumen se puede ver
en la figura 34.
Figura 34. Resumen anual para el año 2002.
A continuación se muestra el contenido íntegro del documento con el resumen
anual:
159
LIBRO DIARIO (Año 2002)
N As
Fecha
N Cuenta
Debe
1
01/01/2002
570
4000
2
01/02/2002
570
1000
Haber
Caja, euros.
a
100
4000
Capital social.
------- Apertura de Balance -------
170
3
03/02/2002
600
1000
600
400
4
04/02/2002
200
01/06/2002
220
6
15/08/2002
221
11/11/2002
226
1000
Terrenos y bienes naturales.
a
Caja, euros.
2000
Construcciones.
a
Caja, euros.
200
570
8
50
Gastos de constitución.
a
Caja, euros.
2000
570
7
600
1000
570
Caja, euros.
a
Deudas a l.p. con entidad.
Compras de mercaderías.
a
Proveedores.
50
570
5
Cuentas
200
Mobiliario.
a
Caja, euros.
31/12/2002
300
300
Mercaderías A.
(Explicación: Cierre de inventario de existencias)
a
610
300
Var. de exist. de merc.
(Explicación: Cierre de inventario de existencias)
-----9150
-----9150
9
31/12/2002
610
300
Variación de exist. de merc.
a
129
300
Pérdidas y ganancias.
------- Cierre de cuentas temporales (p y g) al haber -------
160
10
31/12/2002
129
600
Pérdidas y ganancias.
a
600
600
Compras de mercaderías.
------- Cierre de cuentas temporales (p y g) al debe -----------10050
-----10050
11
31/12/2002
Total debe
Total haber
100
170
400
4000
1000
600
Capital social.
Deudas a l.p. con entidad.
Proveedores.
a
129
300
Pérdidas y ganancias.
200
50
Gastos de constitución.
220
1000
Terrenos y bienes.
221
2000
Construcciones.
226
200
Mobiliario.
300
300
Mercaderías A.
570
1750
Caja, euros.
------- Cierre de cuentas permanente -----------15650
-----15650
LIBRO MAYOR (Año 2002)
100. Capital social
------------------------------------------------------------------------4000 (11)
4000 (1)
129. Pérdidas y ganancias
------------------------------------------------------------------------600 (10)
300 (9)
300 (11)
170. Deudas a largo plazo con entidades de crédito
------------------------------------------------------------------------1000 (11)
1000 (2)
200. Gastos de constitución
------------------------------------------------------------------------50 (4)
50 (11)
161
220. Terrenos y bienes naturales
------------------------------------------------------------------------1000 (5)
1000 (11)
221. Construcciones
------------------------------------------------------------------------2000 (6)
2000 (11)
226. Mobiliario
------------------------------------------------------------------------200 (7)
200 (11)
300. Mercaderías A
------------------------------------------------------------------------300 (8)
300 (11)
400. Proveedores
------------------------------------------------------------------------600 (11)
600 (3)
570. Caja, euros
------------------------------------------------------------------------1000 (2)
50 (4)
4000 (1)
1000 (5)
2000 (6)
200 (7)
1750 (11)
600. Compras de mercaderías
------------------------------------------------------------------------600 (3)
600 (10)
610. Variación de existencias de mercaderías
------------------------------------------------------------------------300 (9)
300 (8)
162
BALANCE DE COMPROBACION (Año 2002)
Antes del cierre de las cuentas de ingresos y gastos
SUMAS
NºCuenta
100
170
200
220
221
226
300
400
570
600
610
TOTALES:
Debe
SALDOS
Haber
Deudor
Acreedor
0
0
50
1000
2000
200
300
0
5000
600
0
4000
1000
0
0
0
0
0
600
3250
0
300
0
0
50
1000
2000
200
300
0
1750
600
0
4000
1000
0
0
0
0
0
600
0
0
300
9150
9150
5900
5900
Nombre de Cuenta
Capital social.
Deudas a l.p. con.
Gastos de constitu.
Terrenos y bienes
Construcciones.
Mobiliario.
Mercaderías A.
Proveedores.
Caja, euros.
Compras de mercad.
Variación de exist.
BALANCE DE COMPROBACION (Año 2002)
Después del cierre de las cuentas de ingresos y gastos
SUMAS
NºCuenta
100
129
170
200
220
221
226
300
400
570
600
610
TOTALES:
Debe
SALDOS
Haber
Deudor
Acreedor
0
600
0
50
1000
2000
200
300
0
5000
600
300
4000
300
1000
0
0
0
0
0
600
3250
600
300
0
300
0
50
1000
2000
200
300
0
1750
0
0
4000
0
1000
0
0
0
0
0
600
0
0
0
10050
10050
5600
5600
Nombre de Cuenta
Capital social.
Pérdidas y gananci.
Deudas a l. p. con.
Gastos de constitu.
Terrenos y bienes.
Construcciones.
Mobiliario.
Mercaderías A.
Proveedores.
Caja, euros.
Compras de mercade.
Variación de exist.
Una vez que se ha obtenido el documento con el resumen anual se puede:
•
Salir del programa.
163
•
Volver al menú principal.
•
Pasar a ver el libro diario para el año 2003 (en cuyo caso se crea automáticamente
dicho libro diario)
•
Ver todos los libros diarios de la empresa.
•
Crear otra empresa para realizar otro ejercicio.
164
ANEXO C
Valoración económica
El coste directo (correspondiente a los costes de las personas y sistemas
involucrados directamente en el diseño y desarrollo del proyecto) se puede dividir en:
o Desarrollo de la aplicación. Por una parte, un coste asociado se corresponde con el
salario de un “Analista programador júnior” que desarrolle la aplicación. Por otro
lado, dado que la aplicación está orientada a un uso lectivo en asignaturas de
Economía, se requiere la supervisión de, al menos, un profesor que vaya a emplear
la aplicación en sus clases. Así podrá orientar y corregir al programador en los
objetivos del programa.
o Implantación de la aplicación. Debido a que la aplicación no necesita instalación
de ningún tipo, sólo hace falta distribuir la aplicación entre los profesores y
alumnos. El coste relativo correspondiente es despreciable.
Por tanto, el coste asociado a la realización del proyecto es la suma del coste del trabajo del
analista-programador, de los supervisores y del equipo informático requerido para
desarrollar la aplicación. Los costes indirectos asociados a la aplicación se consideran
despreciables.
Para llevar a cabo la aplicación se ha requerido realizar distintas fases que se muestran a
continuación, junto con el número de horas que ha necesitado el analista-programador para
lograr la consecución de cada fase:
Horas
Tarea
o Cinco entrevistas con los directores de proyecto
165
10
o Análisis de requisitos (incluyendo el estudio del funcionamiento
del plan general contable y el estudio del estado del arte)
50
o Diseño del modelo lógico
10
o Elección de la tecnología y de la arquitectura
6
o Diseño del interfaz gráfico
50
o Diseño de la base de datos
6
o Programación
300
o Pruebas, ajustes y correcciones
80
o Elaboración de la memoria
60
TOTAL
572 horas
Si un “analista programador júnior” en una empresa de consultoría cobra alrededor
de 22000 euros brutos al año y se ha de pagar un coste adicional de un 28% de dicho
sueldo en concepto de Seguridad Social con cargo a la empresa, el coste anual asciende
a 28160 €. Dado que dicha persona trabaja en torno a 1750 horas al año, el coste por
hora de trabajo es de 16 €. Teniendo en cuenta las 572 horas empleadas por el analistaprogramador para desarrollar la aplicación, el coste asociado es de 9152 €.
La supervisión ha sido llevada a cabo por dos profesoras de Economía de ICAI que
han sido las directoras del proyecto. Cada una de ellas ha empleado alrededor de 30
horas entre entrevistas, llamadas telefónicas y comunicación vía e-mail. Si se considera
un coste de 40 € por cada hora de trabajo de las directoras, habría un coste de 2400 €
por este concepto.
El equipo informático necesario para llevar a cabo el proyecto ha sido un ordenador
portátil y una impresora. Estimando un coste de 2000 € por ambos y un tiempo de vida
166
de 4 años, el coste anual es de 500 € al año. Suponiendo que el analista-programador
utiliza en exclusiva el equipo informático durante un año, el coste asociado es de 500 €.
Por tanto el coste total del proyecto asciende a 12052 €.
167
ANEXO D
Planificación
La realización de este proyecto se ha desarrollado mientras el autor residía entre
Madrid y Göteborg (Suecia), ya que el autor cursó el quinto curso de la carrera en la
universidad de “Chalmers” gracias a una beca Erasmus.
Este proyecto se inició el 30 de Junio de 2005 con la primera entrevista con las
directoras del proyecto. En ella se establecieron los objetivos y funcionalidades de la
aplicación. En los siguientes días se llevó a cabo el análisis de requisitos. Después de una
pausa, debido a las vacaciones de verano, se llevó a cabo la segunda entrevista en la que se
planteó a las directoras la primera aproximación de cuáles serían los requisitos concretos de
la aplicación y de qué forma se cubrirían.
Durante el mes de Septiembre, ya en Suecia, se llevó a cabo el estudio y
entendimiento del sistema definido por el Plan General Contable, con el fin de conocer
exactamente el funcionamiento de la contabilidad financiera. Después se analizaron las
distintas herramientas de contabilidad financiera existentes en el mercado.
A partir de este momento, una vez conocidos los objetivos del sistema, el
funcionamiento del Plan General Contable (respecto a contabilidad financiera) y cómo
orientar la aplicación (para que tuviera un enfoque de mayor dedicación a la docencia que
otras aplicaciones), se definieron la arquitectura y la tecnología que se iba a utilizar para
desarrollar la aplicación. Antes de las vacaciones de Navidad se diseñaron el interfaz
gráfico de la aplicación y el modelo de la base de datos.
Aprovechando las vacaciones invernales en Suecia (un mes entero), se realizó la
tercera entrevista con las directoras en Madrid, mostrando la evolución de la aplicación.
168
Conforme a esta entrevista se hicieron una serie de cambios en el diseño de la aplicación;
unos días después se realizó la cuarta entrevista con las directoras en la que se aceptaron las
ideas del funcionamiento de las distintas partes de la aplicación. Una vez realizado esto, a
partir de finales de Diciembre de 2005, se comenzó con la fase de programación. Esta fase
duró tres meses y medio. Cuando la programación estuvo terminada, se dedicó un mes a
seguir el funcionamiento de la aplicación e ir corrigiendo y mejorando la funcionalidad de
la aplicación.
Entre finales de Abril y principios de junio se elaboró el documento de la memoria
del proyecto. Una vez terminado el quinto curso en la universidad de Chalmers, a principios
de Junio, se produjo la última reunión con las directoras del proyecto para presentar la
aplicación en funcionamiento. Los días siguientes se arreglaron pequeños detalles del
funcionamiento de la aplicación y el día 14 de Junio de 2006 se procedió a la firma del
proyecto por parte de las directoras.
Para llevar a cabo la planificación se ha utilizado el programa “Project Planner”. A
continuación se muestra una tabla con las distintas fases de la planificación:
169
Gracias al programa “Project Planner”, se ha realizado un diagrama de Gantt, que se
muestra a continuación:
Meses de Junio a Septiembre
170
Meses de Septiembre a Diciembre
Meses de Enero a Abril
171
Meses de Mayo y Junio
172
ANEXO E
Conclusiones
En primer lugar, se ha obtenido una aplicación de calidad que cubre los objetivos
que se habían planteado, en especial el que se pueda gestionar un ejercicio de contabilidad
financiera de una forma sencilla y fácil. El interfaz gráfico es intuitivo y la aplicación
verifica que el usuario está utilizando el programa con corrección. Gracias a la buena
planificación, la fase de “Pruebas del sistema” ha sido extensa y la aplicación se puede
considerar fiable.
Por otro lado, la arquitectura de la aplicación hace que ésta no requiera instalación y
que el coste de la implantación sea despreciable. Simplemente con tener el ejecutable en el
disco duro, con sus archivos correspondientes, la aplicación puede funcionar sin problemas.
También se ha de destacar el aprendizaje del alumno, ya que por primera vez ha
realizado todo el proceso de desarrollo de una aplicación compleja de principio a fin. Así
mismo, el alumno ha obtenido un conocimiento razonable de las distintas posibilidades
que ofrece la plataforma .NET con C#. Por último, cabe destacar también el que el alumno
ha obtenido un buen conocimiento sobre el funcionamiento de la contabilidad financiera y
del Plan General Contable.
173
Bibliografía
[TORR05]
Ángel Sáez Torrecilla, Contabilidad General, Volúmenes 1 y 2.
McGraw Hill, 2001(Vol.1)/2005(Vol.2).
[RODR02]
Miguel Rodríguez Gómez-Stern, Marco Antonio Besteiro Gorostizaga,
“Desarrollo de aplicaciones .NET con Visual C#”
McGraw Hill, 2002.
[BARR02]
Jesús Barranco, “Metodología del análisis estructurado de sistemas”
Universidad de Comillas, 2002.
[VITT02]
David Vitter y Julian Templeman, Visual “Studio .NET”
Anaya Multimedia, 2002.
[BLAN03]
Sergio Blanco Cuaresma, “Mono: La plataforma .NET libre”
2003
[RECI05]
Francisco Recio y David Provencio,
distintos informes en www.desarrolloweb.com
2001-2005
174
[CWAL05]
Krzysztof Cwalina y Brad Abrams, “Framework Design Guidelines:
Conventions, Idioms, and Patterns for Reusable .NET Libraries”
Addison-Wesley, 2005
También se han utilizado diferentes páginas webs como ayuda para la programación. Las
páginas más consultadas han sido:
o “Visual C# Developer Center” (msdn.microsoft.com/vcsharp/)
o www.programacion.com, página oficial de .NET Framework
(http://msdn.microsoft.com/netframework)
o “C# Corner” (www.c-sharpcorner.com/)
Con el fin de recopilar el estado de arte, se han utilizado las distintas páginas webs de las
aplicaciones mencionadas (de las que se ha podido obtener una descripción general de cada
una).
175