Creación de relaciones entre tablas

 Solo puse claves foraneas en las tablas pedidos (para referencias al cliente y a los prodcutos) y en factura (para referenciar a pedidos que ya referencia a los clientes y productos)

private const val PEDIDOS_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS ${FerreteriaContract.PedidoEntry.TABLE_NAME} (" +
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_DESCRIPCION} TEXT,"+
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_FECHA} DATE,"+
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_COD_CLIENTE} INTEGER, "+
            "FOREIGN KEY (${FerreteriaContract.PedidoEntry.COLUMN_NAME_COD_CLIENTE}) "+
            "REFERENCES ${FerreteriaContract.ClienteEntry.TABLE_NAME} " +
            " (${FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO}))"


private const val FACTURAS_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS ${FerreteriaContract.FacturaEntry.TABLE_NAME} (" +
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_FECHA} DATE,"+
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_VALOR} DECIMAL,"+
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_COD_PEDIDO} INTEGER, "+
            "FOREIGN KEY (${FerreteriaContract.FacturaEntry.COLUMN_NAME_COD_PEDIDO}) " +
            "REFERENCES ${FerreteriaContract.PedidoEntry.TABLE_NAME} " +
            "(${FerreteriaContract.PedidoEntry.COLUMN_NAME_CODIGO}));"

Tabla intermedia entre pedidos y productos

private const val PEDIDO_PRDUCTO_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS pedidos_productos("+
            "id INTEGER PRIMARY KEY AUTOINCREMENT,"+
            "cod_pedido INTEGER,"+
            "cod_producto INTEGER, "+
            "FOREIGN KEY (cod_pedido) " +
            "REFERENCES ${FerreteriaContract.PedidoEntry.TABLE_NAME} " +
            "(${FerreteriaContract.PedidoEntry.COLUMN_NAME_CODIGO}),"+
            "FOREIGN KEY (cod_producto)" +
            "REFERENCES ${FerreteriaContract.ProductoEntry.TABLE_NAME} " +
            "(${FerreteriaContract.ProductoEntry.COLUMN_NAME_CODIGO}))"

Creación de una base de datos

Al declarara un clase que implemente el SQLiteOpenHelper de la siguiente manera ya crea la base de datos (Kotlin)

class FerreteriaDBHelper(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {

detalle de las variables

donde el contexto es la actividad que se esta ejecutando y

const val DATABASE_VERSION = 1
const val DATABASE_NAME = "Ferreteria.db"

Creación de Tablas

 En la implementación de SQLiteOpeneHelper se ejecutan las queries de creación de las tablas

override fun onCreate(db: SQLiteDatabase) {
    db.execSQL(Companion.CLIENTES_SQL_CREATE_ENTRIES)
    db.execSQL(Companion.PEDIDOS_SQL_CREATE_ENTRIES)
    db.execSQL(Companion.PRODUCTOS_SQL_CREATE_ENTRIES)
    db.execSQL(Companion.FACTURAS_SQL_CREATE_ENTRIES)
    db.execSQL(Companion.PEDIDO_PRDUCTO_SQL_CREATE_ENTRIES)

}

Para el caso de practica prouesto las queries fueron las siguientes

private const val CLIENTES_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS ${FerreteriaContract.ClienteEntry.TABLE_NAME} (" +
            "${FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.ClienteEntry.COLUMN_NAME_NOMBRE} TEXT,"+
            "${FerreteriaContract.ClienteEntry.COLUMN_NAME_DIRECCION} TEXT,"+
            "${FerreteriaContract.ClienteEntry.COLUMN_NAME_TELEFONO} INTEGER )"


private const val PRODUCTOS_SQL_CREATE_ENTRIES =
    "CREATE TABLE  IF NOT EXISTS ${FerreteriaContract.ProductoEntry.TABLE_NAME} (" +
            "${FerreteriaContract.ProductoEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.ProductoEntry.COLUMN_NAME_FABRICANTE} TEXT,"+
            "${FerreteriaContract.ProductoEntry.COLUMN_NAME_VALOR} DECIMAL,"+
            "${FerreteriaContract.ProductoEntry.COLUMN_NAME_COD_PEDIDO} INTEGER)"


private const val PEDIDOS_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS ${FerreteriaContract.PedidoEntry.TABLE_NAME} (" +
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_DESCRIPCION} TEXT,"+
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_FECHA} DATE,"+
            "${FerreteriaContract.PedidoEntry.COLUMN_NAME_COD_CLIENTE} INTEGER, "+
            "FOREIGN KEY (${FerreteriaContract.PedidoEntry.COLUMN_NAME_COD_CLIENTE}) "+
            "REFERENCES ${FerreteriaContract.ClienteEntry.TABLE_NAME} " +
            " (${FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO}))"


private const val FACTURAS_SQL_CREATE_ENTRIES =
    "CREATE TABLE IF NOT EXISTS ${FerreteriaContract.FacturaEntry.TABLE_NAME} (" +
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_CODIGO} INTEGER PRIMARY KEY AUTOINCREMENT," +
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_FECHA} DATE,"+
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_VALOR} DECIMAL,"+
            "${FerreteriaContract.FacturaEntry.COLUMN_NAME_COD_PEDIDO} INTEGER, "+
            "FOREIGN KEY (${FerreteriaContract.FacturaEntry.COLUMN_NAME_COD_PEDIDO}) " +
            "REFERENCES ${FerreteriaContract.PedidoEntry.TABLE_NAME} " +
            "(${FerreteriaContract.PedidoEntry.COLUMN_NAME_CODIGO}));"

Conexión de bases de datos en dispositivos móviles

 Esto se realiza a través de la creación de una clase que implemente

class FerreteriaDBHelper(context: Context) : 
SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {

override fun onCreate(db: SQLiteDatabase)
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int)

y luego en la actividad donde se requiera se llama a

val dbHelper = FerreteriaDBHelper(this)

Implementación de métodos

 fun insertar (view: View){

    val vdocumento = documento.text.toString();
    val vnombre = nombre.text.toString();
    val vtelefono = telefono.text.toString();
    val vdireccion = direccion.text.toString();

    if(vdocumento.isNotBlank() && vdocumento.isNotEmpty()
        && vnombre.isNotBlank() && vnombre.isNotEmpty()
        && vtelefono.isNotBlank() && vtelefono.isNotEmpty()
        && vdireccion.isNotBlank() && vdireccion.isNotEmpty()
    ){
        val db = dbHelper.writableDatabase

        var values = ContentValues().apply {
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO, vdocumento)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_NOMBRE, vnombre)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_DIRECCION, vdireccion)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_TELEFONO, vtelefono)
        }

        val newRowId = db?.insert(FerreteriaContract.ClienteEntry.TABLE_NAME, null, values)
        db.close()

        if (newRowId == null) {
            Toast.makeText(this, "No se creo el registro", Toast.LENGTH_LONG).show();
        }


        documento.text = ""
        nombre.text= ""
        telefono.text= ""
        direccion.text = ""
        Toast.makeText(this, "Nuevo cleinte creado exitosamente", Toast.LENGTH_LONG).show();

    } else {
        Toast.makeText(this, "Todos los campos son obligaotrios", Toast.LENGTH_LONG).show();
    }
}

fun buscar(view: View){

    val vdocumento = documento.text.toString();

    if(vdocumento.isNotBlank() && vdocumento.isNotEmpty()) {
        val db = dbHelper.readableDatabase
        var cursor = db.query(
            FerreteriaContract.ClienteEntry.TABLE_NAME,
            null,
            FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO + "=" + vdocumento,
            null,
            null,
            null,
            null
        )


        if (cursor.moveToNext()) {
            nombre.text =
                cursor.getString(cursor.getColumnIndexOrThrow(FerreteriaContract.ClienteEntry.COLUMN_NAME_NOMBRE))
            telefono.text =
                cursor.getString(cursor.getColumnIndexOrThrow(FerreteriaContract.ClienteEntry.COLUMN_NAME_TELEFONO))
            direccion.text =
                cursor.getString(cursor.getColumnIndexOrThrow(FerreteriaContract.ClienteEntry.COLUMN_NAME_DIRECCION))
        } else {
            Toast.makeText(this, "No se encontro el usuario", Toast.LENGTH_LONG).show();
        }
        cursor.close()
        db.close()
    }else{
        Toast.makeText(this, "el documento es requierido", Toast.LENGTH_LONG).show();
    }
}

fun actualizar(view: View){

    val vdocumento = documento.text.toString();
    val vnombre = nombre.text.toString();
    val vtelefono = telefono.text.toString();
    val vdireccion = direccion.text.toString();

    if(vdocumento.isNotBlank() && vdocumento.isNotEmpty()
        && vnombre.isNotBlank() && vnombre.isNotEmpty()
        && vtelefono.isNotBlank() && vtelefono.isNotEmpty()
        && vdireccion.isNotBlank() && vdireccion.isNotEmpty()
    ){
        val db = dbHelper.writableDatabase
        var values = ContentValues().apply {
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO, vdocumento)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_NOMBRE, vnombre)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_DIRECCION, vdireccion)
            put(FerreteriaContract.ClienteEntry.COLUMN_NAME_TELEFONO, vtelefono)
        }

        val newRowId = db?.update(FerreteriaContract.ClienteEntry.TABLE_NAME, values,FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO+"="+vdocumento,null )
        db.close()

        if(newRowId != 1){
            Toast.makeText(this,"La persona no existe",Toast.LENGTH_LONG).show();
        } else {
            Toast.makeText(this,"Persona modificada correctamente",Toast.LENGTH_LONG).show();
        }


    } else {
        Toast.makeText(this, "Todos los campos son obligatorios", Toast.LENGTH_LONG).show();
    }

}


fun borrar(view: View){

    val vdocumento = documento.text.toString();

    if(vdocumento.isNotBlank() && vdocumento.isNotEmpty()) {
        val db = dbHelper.writableDatabase

        val newRowId = db?.delete(FerreteriaContract.ClienteEntry.TABLE_NAME,FerreteriaContract.ClienteEntry.COLUMN_NAME_CODIGO+"="+vdocumento,null)
        db.close()
        documento.text = ""
        nombre.text= ""
        telefono.text= ""
        direccion.text = ""

        if ( newRowId != 0 ){
            Toast.makeText(this,"Se ha eliminado un registro",Toast.LENGTH_LONG).show();
        }

    } else {
        Toast.makeText(this, "el documento es requierido", Toast.LENGTH_LONG).show();

    }

Gestión de información por medio de bases de datos

Una base de datos local, como SQLlite, permite que aplicaciones sean más receptivas y menos dependientes de la conectividad de la red.

Son importante para el manejo de una cantidad de datos intermedia, que no quepan en el SharedPreferences pero si se requiere mayor cantidad de memoria hará falta recurrir a una base de datos que este alojada en un servidor  y de conexión a internet.

Mas allá de la cantidad de datos o el SGDB que se utilice, una base de datos nos permite almacenar la información que deseemos y mantenerla actualizada. Para el caso de los dispositivos móviles, la información guardada locamente es importante para indicar preferencias del usuario o guardar información particular que sea solo del usuario del dispositivo.

Ventajas de SQLite

 Es estable, multiplataforma y compatible con versiones anteriores y su código es de dominio público y gratuito.

Esto se debe a que funciona de forma independiente y que esta basado en archivos, por lo tanto no necesita un servidor. 

Como no necesita un servidor, no requiere instalación o configuración, pero Mantiene sintaxis SQL estándar con pequeñas modificaciones, lo que facilita su uso.

Es portátil, ya que al estar basado en archivos no permite almacenar grandes cantidades de información aunque no tiene incompatibilidades con los tiempos de datos

Casos en los que se recomienda el almacenamiento a través de la clase Sharedpreferences.

Cuando tenemos que almacenar una cantidad limitada de datos

Cuando lo datos que vamos a guardar son primitivos

Cuando queremos que los datos se mantengan hasta que se desinstala la aplicación.

Desventajas del trabajo con vectores.

Tienen un tamaño fijo que se determina en el momento de la creación. Esto significa que si es necesario aumentar el tamaño, se debe crear una nueva y copiar los datos de la anterior a la nueva, lo que puede consumir mucho tiempo y memoria.

La inserción o eliminación de un elemento puede ser ineficiente y llevar mucho tiempo porque todos los elementos después del punto de inserción o eliminación deben cambiarse para acomodar el cambio.

El tamaño fijo y el soporte limitado para tipos de datos complejos pueden hacer que las matrices sean inflexibles en comparación con otras estructuras de datos.

Ventajas del trabajo con vectores

Son Fácil de implementar,

Los arreglos permiten el acceso directo y eficiente a cualquier elemento..

Se pueden usar para almacenar una diferentes de tipos de datos como: números enteros, números de coma flotante, caracteres e incluso estructuras de datos complejas, como objetos.

Android Studio

Ventanjas:

Posee un emulador  que nos permite probar en tiempo real la app en una amplia variedad de dispositivos y ver como se comporta.

Soporta los siguientes lenguajes de programación: KOTLIN, SCALA,  Java, GROOVY y CLOJURE lo que permite cierta libertad para elegir el lenguaje que nos resulte mas practico codificar y tiene  un traductor entre lenguajes, si tenemos una solución o código en JAVA el IDE permite transcribirla a KOTLIN

Muestra alertas en tiempo real de errores sintácticos que nos permite detectar errores previos a la compilación lo que ahorra tiempo en reprocesos de codificación 

Tiene integrado control de versiones para configurar un repositorio y tiene integracion con Gradle que permite gestionar y automatizar la construcción de proyectos, como pueden ser las tareas de testing, compilación o empaquetado.

Control de notas

Video Control de notas

Características de los sistemas operativos

Los Sistemas operativos móviles son mucho más simples que los de PC y están más orientados a la conectividad inalámbrica, los formatos multimedia para móviles y las diferentes maneras de introducir o recuperar información en ellos

Algunas características comunes son 

• Kernel: es capa de software que permite el acceso a los diferentes elementos de hardware del teléfono.
• Middleware: es un conjunto de módulos que permite la ejecución de las aplicaciones
• Entorno de ejecución de aplicaciones. es la capa que provee los elementos necesarios para la creación y desarrollo de software.
• Interfaz de usuario: lo elementos que nos permiten interactuar con el sistema.

Ventaja del sistema operativo

 

Las principales ventajas son que es de Código abierto, multitarea y posee Integración con Google 

 De ello se desprende que posea Mayor libertad durante el desarrollo. Esto permite una mayor cantidad y variedad de apps y una gran capacidad de personalización 

Otra ventaja importante es que es Independiente del fabricante y por eso se lo puede encontrar en una mayor Diversidad de dispositivos,  los cuales varían en calidad, prestaciones y precio por tanto pueden ser mas Asequibles 

Todo lo anteriormente expuesto hace que cuente con la mayor comunidad del mundo.

Principales diagramas de UML

Las notaciones y metamodelos son el conjunto de diagramas y relaciones que se utilizan para describir un aspecto de un software.

Los diagramas pueden ser

 • Diagrama de casos de uso : incluye Actores, casos de uso

• Diagrama de clases : proporciona  diagrama de clases con atributos y operaciones para las relaciones utilizadas en POO

• Diagrama de comunicación

• Diagrama de secuencia: sirven para representas la línea de vida de un objeto y su comportamiento

• Diagrama de colaboración: Describen la interacción de los objetos pero en este caso se numeran lso mensajes.

• Diagrama de actividades: Detalla el orden en que se harán las cosas y flujos de trabajo.

• Diagrama de paquetes: muestra como ser armaran los paquetes de clases.

• Diagrama de estados: describe el comportamiento de sistemas a trabes de lso estados que puede tomar un objeto.

Diagramas para la documentación de las vistas propuestas en el modelo 4+1

Esta actividad había que realizarla a partir de un REDA (REDA Modelo 4+1 vistas) pero no estaba en la plataforma, por lo que lo realizaré a partir de la lectura propuesta.

El modelo de 4+1 vistas propone una forma de organizar la documentación de un proyecto de software en 4 vistas que abarcan aspectos particulares y una vista que relaciona a todas.

La vista que relaciona a todas se llama Vista de escenarios y va a contener los casos de uso de los cuales las otras vistas darán detalla según el aspecto que cubran.

La vista Lógica dará detalles sobre la funcionalidad y pueden incluir los diagramas de clase, comunicación o secuencia.

La vista de proceso esta orientada a describir el rendimiento y escalabilidad del sistema por medio del diagrama de actividades.

La vista de Despliegue se utilizará para la gestión o administración del Software a través de los diagramas de componentes y de paquetes.

Por ultimo en la Vista Física se representa la topología y comunicación del sistema por medio del diagrama de despliegue

Las técnicas y principios de modelado de software

 

Cronograma y presupuesto del proyecto

 

Nombre	Fecha de inicio	Fecha de fin	Costo		Duraci ón
App Restaurente Comida de Mar	1/11/22	11/1/23		48.550.000	52
Módulo de ingreso al app	1/11/22	14/11/22		6.500.000	10
Patalla de Login	1/11/22	14/11/22		6.500.000	10
Módulo de registro de clientes	8/11/22	15/11/22		1.500.000	6
Patalla Registro	8/11/22	15/11/22		1.500.000	6
Modulo de administración	15/11/22	8/12/22		9.200.000	18
Patalla Inicio Administrador	15/11/22	16/11/22		800.000	2
Administracion de Usuarios	17/11/22	28/11/22		3.200.000	8
Listar Usuarios	17/11/22	21/11/22		1.200.000	3
Formulario prar ingreso de usuarios	22/11/22	28/11/22		2.000.000	5
Administración de carta	29/11/22	8/12/22		2.000.000	8
Listado de productos	29/11/22	1/12/22		750.000	3
Formulario ingreso de productos	2/12/22	8/12/22		1.250.000	5
Administracion de pedidos	29/11/22	8/12/22		3.200.000	8
Listado de pedidos	29/11/22	1/12/22		1.200.000	3
Edicion de estado	2/12/22	8/12/22		2.000.000	5
Módulo de consulta de carta y precios	6/12/22	20/12/22		2.750.000	11
Categorias de productos	6/12/22	12/12/22		1.250.000	5
Listado de Productos	13/12/22	15/12/22		750.000	3
Detalle de Productos	16/12/22	20/12/22		750.000	3
Módulo de pedido en línea de productos	6/12/22	26/12/22		6.000.000	15
Agregar el carrito	6/12/22	12/12/22		2.000.000	5
Solicitud de datos para la entrega	13/12/22	15/12/22		1.200.000	3
Confirmacion del pedido	16/12/22	26/12/22		2.800.000	7
Módulo de pago en línea	27/12/22	9/1/23		2.600.000	10
Solicitud de datos de pago	27/12/22	29/12/22		1.200.000	3
Realizar el pago	30/12/22	9/1/23		1.400.000	7
Módulo de rastreo de pedidos.	27/12/22	11/1/23		4.400.000	12
Informcaiocion del estado del pedido	27/12/22	2/1/23		1.250.000	5
Ubicacion del pedido	3/1/23	11/1/23		3.150.000	7