CRUD con Play Framework + Scala + PostgreSQL

¿Qué es Scala?

Scala es un lenguaje de programación multi-paradigma diseñado para expresar patrones comunes de programación en forma concisa, elegante y con tipos seguros. Integra sutilmente características de lenguajes funcionales y orientados a objetos. La implementación actual corre en la máquina virtual de Java y es compatible con las aplicaciones Java existentes.

más información en:
https://www.scala-lang.org/

¿Qué es Play Framework?

Play es un framework de aplicación web de código abierto, escrito en Scala y también utilizable desde otros lenguajes de programación compilados a Bytecode, p. Java (Play incluye una API de Java en versiones más recientes), que sigue el patrón de arquitectura model-view-controller (MVC). Su objetivo es optimizar la productividad del desarrollador mediante el uso de convenciones sobre la configuración, la recarga de código en caliente y la visualización de errores en el navegador

Scala y Play son una combinación perfecta para desarrollar aplicaciones que requieran de mucha demanda o millones de transacciones o peticiones por segundo, su diseño stateless (Sin estado) permite que Play Framework con Scala sean los elegidos para ambientes Cluster y que requieran de alto performance gracias a que también permiten operaciones asíncronas en el lado del servidor.

¿Qué necesitaremos para realizar nuestro CRUD?

- IntelliJ IDEA Community Edition
- Una computadora con Linux, Windows, Mac OSX o cualquier SO compatible.
- Instalar SBT http://www.scala-sbt.org/0.13/docs/es/Installing-sbt-on-Mac.html
- Necesitaras utilizar alguna plantilla, te recomiendo la Starter https://github.com/playframework/play-scala-starter-example/tree/2.6.x

La estructura de directorios final de nuestro proyecto será la siguiente:

Comenzamos

El primer paso será configurar nuestro proyecto es decir indicar las rutas y acceso a bases de datos. Esto lo realizaremos en los archivos conf/application.conf, conf/routes y build.sbt.

Configurando build.sbt

Para que nuestro proyecto se conecte apropiadamente utilizando JDBC necesitamos agregar las siguientes dependencias.

libraryDependencies += jdbc

libraryDependencies += "org.postgresql" % "postgresql" % "9.4-1206-jdbc42"


Ej.

Configurando Application.conf

El application.conf es un archivo muy útil ya que permite definir ciertas configuraciones como la conexión a base de datos de nuestro proyecto.
Ej.

Configurando routes.

El archivo routes será el que nos permitirá definir las rutas de acceso a nuestros controladores, los importantes en este proyecto son:

 style="background-color: white; font-family: Menlo; font-size: 9pt;"># Home page
GET     /                       controllers.TaskController.list
# Tasks
GET     /tasks                  controllers.TaskController.list
POST /newTask                   controllers.TaskController.newTask
GET /addTaskView                   controllers.TaskController.addTaskView
GET /updateTaskView/:id/:label     controllers.TaskController.updateTaskView(id: Long, label: String)
POST    /deleteTask/:id      controllers.TaskController.deleteTask(id:Long)
POST    /tasks/update/:id/:label       controllers.TaskController.updateTask(id: Long, label: String)

Las rutas anteriores contienen las operaciones básicas de alta, modificación y baja de datos en 

la tabla "task" que será objeto de uso en nuestro ejemplo.

Creando nuestro modelo.

Play Framework utiliza el patrón de diseño modelo - vista - controlador (MVC) por lo tanto

iniciaremos creando nuestro modelo.

Para ello en el directorio models crearemos una clase Scala llamada Task.scala.

package models

import play.api.db._
import anorm._
import anorm.SqlParser._
import javax.inject.{Inject, Singleton}
 case class TaskModel(id: Long, label: String)

@Singletonclass Task @Inject() (dBApi: DBApi){
  private val db = dBApi.database("default")
  val task = {
    get[Long]("id") ~
      get[String]("label") map {
      case id ~ label => TaskModel(id, label)
    }
  }

  def all(): List[TaskModel] = db.withConnection { implicit c =>
    SQL("select * from task").as(task *)
  }

  def create(label: String) {
    db.withConnection { implicit c =>
      SQL("insert into task (label) values ({label})").on(
        'label -> label
      ).executeUpdate()
    }
  }

  def update(id: Long, label: String){
    db.withConnection{ implicit c =>
      SQL("UPDATE task SET label = {label} WHERE id = {id}").on(
        'id -> id,
        'label -> label
      ).executeUpdate()
    }
  }

  def delete(id: Long) {
    db.withConnection { implicit c =>
      SQL("delete from task where id = {id}").on(
        'id -> id
      ).executeUpdate()
    }
  }
}

Creando nuestras vistas.

Luego procedemos a crear nuestras vistas en el directorio "views". Para ello utilizaremos

una plantilla basada en el archivo main.scala.html.

Archivo main.scala.html.

@*
 * This template is called from the `index` template. This template
 * handles the rendering of the page header and body tags. It takes
 * two arguments, a `String` for the title of the page and an `Html`
 * object to insert into the body of the page.
 *@
@(title: String)(content: Html)
<!DOCTYPE html>
<html lang="en">
    <head>
        @* Here's where we render the page title `String`. *@
        <title>@title</title>
        <link rel="stylesheet" media="screen" href="@routes.Assets.versioned("stylesheets/bootstrap-theme.min.css")">
        <link rel="stylesheet" media="screen" href="@routes.Assets.versioned("stylesheets/bootstrap.min.css")">
        <link rel="stylesheet" media="screen" href="@routes.Assets.versioned("stylesheets/main.css")">
        <script src="@routes.Assets.versioned("javascripts/jquery-3.2.1.min.js")" type="text/javascript"></script>
        <script src="@routes.Assets.versioned("javascripts/bootstrap.min.js")" type="text/javascript"></script>
    </head>    <body>        @* And here's where we render the `Html` object containing
         * the page content. *@
        @content
    </body></html>

Archivo addTask.scala.html.

@(taskForm: Form[String])(implicit messages: Messages)
@import helper._
@main("Welcome to Play") {
@*
* Get an `Html` object by calling the built-in Play welcome
* template and passing a `String` message.
*@
<div id="main">
    <h2>Agregar una nueva nota</h2>

    @form(routes.TaskController.newTask) {
    <div class="form-group">
        <label for="label">Nota</label>
        <input type="text" class="form-control" name="label" id="label" required="required" placeholder="Ingresar la nota">
    </div>
    <div class="form-group">
        <input type="submit" class="btn btn-default" value="Crear">
        <input type="reset" class="btn btn-default" value="Cancelar">
    </div>
    }
    <a href='@routes.TaskController.list'>Show list</a>
</div>
}

Archivo tasks.scala.html

@(tasks: List[TaskModel])(implicit messages: Messages, req: RequestHeader)
@import helper._
@main("Welcome to Play") {
@*
* Get an `Html` object by calling the built-in Play welcome
* template and passing a `String` message.
*@
<div id="main">
<h1>@tasks.size tasks</h1>
<div class="add">
    <a href='@routes.TaskController.addTaskView'><button type="button" class="btn btn-primary">Agregar</button></a>
</div>
    <div class="table-responsive">
        <table class="table">
            <tr>
            <th>id</th><th>label</th><th>Update</th><th>Delete</th>
            </tr>
            @tasks.map { task =>
            <tr>
                <td>@task.id</td>
                <td>@task.label</td>
                <td><a href="@routes.TaskController.updateTaskView(task.id,task.label)"> <button type="button" class="btn btn-info">Actualizar</button></a></td>
                <td><button type="button" data-id="@task.id" id="btn-modal-delete" class="btn btn-danger" data-toggle="modal" data-target="#myModal">Eliminar</button></td>
            </tr>
            @*routes.TaskController.deleteTask(task.id)*@
            }

        </table>
    </div>
    <!-- Modal -->    <div id="myModal" class="modal fade" role="dialog">
        <div class="modal-dialog">

            <!-- Modal content-->            <div class="modal-content">
                <div class="modal-header">
                    <button type="button" class="close" data-dismiss="modal">&times;</button>
                    <h4 class="modal-title">Modal Header</h4>
                </div>
                <div class="modal-body">
                    <p>Esta seguro en eliminar el registro?</p>
                    <input type="hidden" id="data-id"/>
                </div>
                <div class="modal-footer">
                    <button type="button" class="btn btn-primary" id="btnEliminar" data-dismiss="modal">Aceptar</button>
                    <button type="button" class="btn btn-default" data-dismiss="modal">Cerrar</button>
                </div>
            </div>

        </div>
    </div>
</div>
<script type="text/javascript">

$(document).on('click','#btn-modal-delete', function(e){
    var taskId = $(this).data('id');
    console.log("taskId:" + taskId);
    $('.modal-body #data-id').val(taskId);
});

$('.modal-dialog .modal-footer').on('click','#btnEliminar', function(e) {
    var id = $('.modal-body #data-id').val();
    console.log(id);
    $.ajax({
        type: 'POST',
        url: '/deleteTask/'+ id,
        success: function(data) {
            document.open();
            document.write(data);
            document.close();
        }
    });
    return false;

});
</script>
}

Archivo updateTaskView.scala.html.

@(id: Long, label: String)(implicit messages: Messages)
@import helper._
@main("Welcome to Play") {
@*
* Get an `Html` object by calling the built-in Play welcome
* template and passing a `String` message.
*@
<div id="main">
    @form(routes.TaskController.updateTask(id, label)) {
    <input type="text" value="@id" name="id" class="form-control">
    <input type="text" value="@label" name="label" class="form-control">
    <input type="submit" class="btn btn-default" value="Update">
    }
</div>

}

Con esto ya tenemos listas nuestras vistas. Ahora procederemos a crear nuestros controladores


Creando nuestros controladores.

Para nuestro ejemplo sencillo solo crearemos un controlador llamado TaskController. En nuestro

controlador definiremos las diferentes acciones que realizaremos con nuestro modelo y vistas.

Los controladores por lo general deben ir en el directorio "controllers".



package controllers
import javax.inject.{Inject, Singleton}

import forms.TaskForm
import models.Task
import play.api.mvc.{Action, Controller}
import play.api.i18n.{I18nSupport, MessagesApi}

@Singletonclass TaskController @Inject()(val messagesApi: MessagesApi)(task: Task) extends Controller with I18nSupport {

  def list = Action {implicit request =>
    Ok(views.html.tasks(task.all()));
  }

  def addTaskView = Action {
    Ok(views.html.addTask(TaskForm.getForm));
  }

  def updateTaskView(id: Long, label: String) = Action {
    Ok(views.html.updateTaskView(id, label));
  }

  def newTask = Action { implicit request =>
    TaskForm.getForm.bindFromRequest.fold(
      errors => BadRequest(views.html.tasks(task.all())),
      label => {
        task.create(label)
        Redirect(routes.TaskController.list)
      }
    )
  }

  def updateTask(id: Long, label: String) = Action { implicit request =>
    TaskForm.getForm.bindFromRequest.fold(
      errors => BadRequest(views.html.tasks(task.all)),
      label => {
        task.update(id, label)
        Redirect(routes.TaskController.list)
      }
    )
  }

  def deleteTask(id: Long) = Action {request =>
    task.delete(id);
    Redirect(routes.TaskController.list)
  }

}

Listo. Ahora procederemos a crear nuestra base de datos en PGAdmin 4
para PostGreSQL. Crearemos una base de datos llamada "test" y a modo de ejemplo también
crearemos una tabla llamada "task" con dos campos llamados "id" y "label".






Luego nada más nos resta iniciar el servidor Netty, para lo cuál abrimos la consola o terminal
nos dirigimos a el path del proyecto y haremos uso de los comandos:

sbt : Para iniciar Scala Build Tools
clean: para limpiar el proyecto
compile: Para compilar nuestro proyecto
run: para iniciar el servidor de aplicación.

si probamos nuestro localhost puerto 9000 podremos notar nuestro CRUD funcionando a la perfección, cabe aclarar que se utilizaron otras herramientas como Bootstrap y JQuery Las cuales pienso explicar en otro post.

Espero les sea de utilidad y recuerden si desean un tema especifico solo escriban en los comentarios y yo procedo a hablar al respecto. También agradecerles a quienes colaboran vía PayPal y con los anuncios para que este blog siga vigente. Hasta el siguiente post.

Importancia del uso de Synchronized al implementar Threads (Hilos) en Java

Un bloque o método sincronizado en Java es aquel que utiliza la palabra reservada synchronized.

La importancia en su uso radica en evitar o prevenir las condiciones de carrera(race condition) al manejar hilos en Java.

La palabra reservada Synchronized.

Los bloques sincronizados en Java están marcados con la palabra clave synchronized. Un bloque sincronizado en Java se sincroniza en algún objeto. Todos los bloques synchronized sincronizados en el mismo objeto sólo pueden tener un subproceso ejecutándose dentro de ellos al mismo tiempo. 

Todos los demás hilos que intentan entrar en el bloque sincronizado se bloquean hasta que el hilo dentro del bloque sincronizado sale.

La palabra reservada synchronized puede utilizarse para cuatro tipos de bloques diferentes:

Metodos de instancia, metodos estáticos, bloques de código dentro de metodos de instancia, bloques de código dentro de metodos estáticos. 

El tipo de bloque synchronized que necesites dependerá de una situación concreta.

Ejemplo.

He aquí un ejemplo que inicia 2 subprocesos y que ambos llaman al método agregar en la misma instancia de Cobro. Sólo un hilo a la vez podrá llamar al método agregar en la misma instancia, ya que el método se sincroniza en la instancia a la que pertenece.

public class Cobro{
     
     long contar = 0;
    
     public synchronized void agregar(long valor){
       this.contar += valor;
     }
  }

public class CobroThread extends Thread{

     protected Cobro cobro = null;

     public CobroThread(Cobro cobro){
        this.cobro = cobro;
     }

     public void run() {
 for(int i=0; i<10; i++){
           cobro.agregar(i);
        }
     }
  }

  public class Ejemplo {

    public static void main(String[] args){
      Cobro cobro = new Cobro();
      Thread  threadA = new CobroThread(cobro);
      Thread  threadB = new CobroThread(cobro);

      threadA.start();
      threadB.start(); 
    }
  }

Se crean dos subprocesos. La misma instancia de cobro se pasa a ambos en su constructor. El método agregar() se sincroniza en la instancia, porque el método agregar es un método de instancia y se marca como sincronizado. Por lo tanto, sólo uno de los subprocesos puede llamar al método agregar() a la vez. El otro hilo esperará hasta que el primer hilo deje el método agregar(), antes de que pueda ejecutar el método mismo.

Si los dos subprocesos hubieran hecho referencia a dos instancias de cobro distintas, no habría problemas para llamar a los métodos agregar() simultáneamente. Las llamadas habrían sido a objetos diferentes, por lo que los métodos llamados también estarían sincronizados en diferentes objetos (el objeto que posee el método). Por lo tanto las llamadas no bloquearían. Aquí es cómo podría verse:

 public class Ejemplo {

    public static void main(String[] args){
      Cobro cobroA = new Cobro();
      Cobro cobroB = new Cobro();
      Thread  threadA = new CobroThread(cobroA);
      Thread  threadB = new CobroThread(cobroB);

      threadA.start();
      threadB.start(); 
    }
  }

 Observe cómo los dos subprocesos, threadA y threadB, ya no hacen referencia a la misma instancia de cobro. El método agregar de cobroA y cobroB se sincroniza en sus dos instancias propietarias. Llamar agregar() en cobroA no bloqueará así una llamada a agregar() en cobroB.

A modo de ejemplos de alto nivel si no usáramos synchronized cuando manipulamos hilos podría darse el caso que multiples hilos alteren el estado o las características de un mismo objeto causando problemas como los siguientes: 

Un sistema mal diseñado de reserva de entradas podría ocasionar que dos usuarios accediendo desde la web a la vez, reserven legítimamente la misma butaca. O un sistema de conteo automático de plazas libres de un parking en sus barreras de entrada y salida de vehículos podría indicar que está totalmente vacío cuando realmente está lleno (o viceversa). De igual forma, dos personas ingresando y retirando efectivo a la vez de una misma cuenta bancaria podrían ver su saldo incrementado o por el contrario su ingreso realizado pero no materializado en saldo disponible. Si bien son situaciones que pudieran ser improbables, son posibles y pueden ser y han de ser evitadas en el desarrollo de software.

Si los procesos que están en condición de carrera (race condition) son correctamente sincronizados, todo debería funcionar correctamente, por lo que el resultado será el esperado. Múltiples procesos se encuentran en condición de carrera si el resultado de los mismos depende del orden de su llegada y si no son correctamente sincronizados, puede producirse una corrupción de datos, que puede derivar incluso en un problema de seguridad del sistema capaz de ser explotado de forma malintencionada. Análogamente, en circuitos electrónicos se da una condición de carrera cuando la salida de un sistema o subsistema depende del orden en que se hayan mandado las solicitudes de activación o desactivación de sus componentes.

Recuerda que este blog sobrevive gracias a tus donaciones o clics en los anuncios, ya sabes como apoyar este recurso para continuar subiendo mas tutoriales. Gracias.

Elaborar el presupuesto para un proyecto de Software de pequeña o mediana escala

Muchas veces cuando realizas un proyecto tienes dudas de cuál es el monto a cobrar por tu trabajo o simplemente no encuentras la forma de organizar tus costos y gastos para luego calcular el margen de ganancia.

Este es un problema muy común en personas que inician en el desarrollo de proyectos o primeros emprendimientos o que no han recibido una capacitación adecuada sobre estimaciones en inversión de proyectos de ingeniería.

En esta entrada del blog aprenderemos con un enfoque práctico sobre como calcular los costos y por supuesto las ansiadas ganancias de un proyecto informático de pequeña o mediana escala.

PASO 1: Determinación del problema a resolver.

Vamos a suponer que el dueño de una tienda de celulares nos ha solicitado un software a la medida, en el cuál él desea llevar un control de sus productos y también de las ventas que realizan sus empleados de dichos productos.

Lo que el dueño de la tienda quiere que el Software realize es lo siguiente:

- Guardar datos sobre las marcas, modelos y compañías telefónicas de los dispositivos.
- Permitir la edición de la información de los dispositivos.
- Cambiar el estado de los dispositivos a existentes o inexistentes en bodega.
- Almacenar la cantidad de dispositivos vendidos y la persona que los vendió.
- Generar reportes de ventas diarias, mensuales, trimestrales y anuales.
- Generar reportes comparativos anuales de ventas realizadas por marca de celulares.
- Permitir la impresión de los reportes desde el Software.

Ok, ahora que sabemos lo que el cliente necesita, tenemos que elaborar una propuesta tanto técnica como económica, donde daremos a conocer como resolver el problema que el cliente nos ha planteado, cabe aclarar que debemos hacerlo de una forma clara y sin muchas palabras técnicas, ya que el "dueño de la tienda" no conoce nada de términos informáticos.

PASO 2: Elaboración de la propuesta técnica

El primer paso que debes hacer es comenzar a redactar un documento formal donde colocarás el título de la propuesta técnica, objetivo de la propuesta y soluciones alternativas.

Por ejemplo, continuando con nuestro ejemplo la propuesta técnica sería algo como:

Título: "Propuesta técnica para el desarrollo de un Software de gestión de productos de telefonía móvil".

Objetivo: Proporcionar las diferentes vías técnicas posibles para lograr el desarrollo de el Software de gestión de productos de telefonía móvil.

Soluciones alternativas: En nuestro caso a modo de ejemplo plantearemos únicamente 2 pero dependerá del proyecto que tu puedas dar mas de 2 soluciones al problema.

Características	Solución 1	Solución 2
Ambiente operativo	El entorno de escritorio es ideal para ejecutar aplicaciones que no necesiten conectarse a travéz de un navegador web sino solamente se instalen en el ordenador y estén listas para su ejecución en la máquina donde se han instalado.	El entorno web permite la ejecución de aplicaciones desde cualquier navegador web permitiendo instalar la solución a través de un servidor de aplicación o un servidor web local o en línea.
Tecnologías de desarrollo	El lenguaje de programación JAVA es utilizado a menudo en gran parte del mundo y posee elementos de seguridad integrados que le hacen una buena opción para el desarrollo del proyecto, es un lenguaje extendido a nivel mundial y cuenta con una cantidad grande de frameworks y plugins.	El lenguaje de programación PHP es utilizado en aplicaciones web de diversa indole al ser un lenguaje de scripting es ideal para la elaboración de productos de Software en tiempos cortos de desarrollo.
Almacenamiento de datos	PostGreSQL es una base de datos mundialmente utilizada y provee de un potente motor de almacenamiento para bases de datos relacionales.	MySQL es una base de datos ampliamente utilizada y cuenta con una velocidad adecuada para la ejecución con aplicaciones web y móviles.

La anterior tabla expresa nuestras vías o alternativas para el desarrollo de nuestro proyecto, ahora bien, se viene la decisión crucial que dependerá en gran parte de la capacidad de pago del cliente, debes analizar a profundidad que tanta es la disposición del cliente para invertir y de esta forma escoger entre tus soluciones alternativas aquella que sea acorde y no valla a sacar mas de un susto a tu cliente.

Para la problemática que hemos planteado del "Software para gestión de productos de telefonía" supondremos que el cliente es una pequeña empresa local que basa sus operaciones en un ambiente departamental únicamente con 2 sucursales. Para tal efecto elaboremos un pequeño análisis de viabilidad de nuestras soluciones alternativas.

Viabilidad	Solución 1	Solución 2
Operativa	Debido a que la empresa cuenta con 2 sucursales no es técnicamente viable una aplicación de escritorio porque dificultaría el proceso de integración de datos entre sucursales	La solución web es técnicamente viable porque permitirá una mejor distribución de la información entre las 2 sucursales de la empresa
Técnica	La solución de escritorio técnicamente es viable porque se cuentan con los recursos para su elaboración.	La solución web es viable porque se cuenta con la disponibilidad de la adquisición de un servidor por parte de la empresa para el proyecto.
Económica	Desde el punto de vista económico la solución es viable porque se procedería con un lenguaje y plataformas de desarrollo Open Source.	Desde el punto de vista económico la solución es viable porque se procedería con un lenguaje y plataformas de desarrollo Open Source. Esto reduciría significativamente los costos de desarrollo.

Como podemos observar la solución 2 es la predilecta ya que nos brinda mayores ventajas con respecto a la primera.

PASO 3: Elaboración de la propuesta económica.

Una vez elegida nuestra solución debemos determinar los costos y gastos de la misma, en este caso independientemente que nosotros cumplamos los roles de "hacer todo" porque somos emprendedores individuales o por X motivo debemos elaborar un presupuesto pensando en los salarios que deberíamos pagar como si se contratase a algunas personas para el proyecto.

Que debemos conocer para elaborar el presupuesto?
sencillo, tiempo y trabajo son las claves.

Pero como se cuánto tiempo me va a llevar terminar una solución?
fácil, en base a las actividades que debas hacer.

Para ello nos auxiliaremos del tan famoso y utilizado diagrama de actividades, empleado en diversos proyectos de ingeniería y que hasta la fecha sigue siendo una herramienta clave para el control de actividades.

Hacer un diagrama de actividades es muy sencillo, puedes utilizar cualquier herramienta como por ejemplo Excel para su elaboración, en este enlace puedes consultar como elaborarlo de acuerdo a explicaciones oficiales de Microsoft.

Manos a la obra continuando con nuestro proyecto vamos a tomar en cuenta los requerimientos que pasarán a ser parte de nuestras actividades para elaborar el diagrama de actividades. En dicho diagrama representaremos las actividades y el tiempo estimado para cada una, yo recomiendo no darle menos de 3 días o 2 a una actividad por muy pequeña que parezca por experiencia propia siempre los proyectos tienden a volverse complejos en el camino. Tampoco olvidar la fase de pruebas e implementación.

En este caso a modo de ejemplo en nuestro diagrama de actividades resumiremos el tiempo en meses y semanas, si el proyecto es menor a dos meses lo recomendable es tomar como base las semanas y días.

La parte azul significa el tiempo que nos llevaremos en la actividad correspondiente. Para las pruebas de Software es importante dejar un tiempo prudente ya que no sabemos si nos encontraremos con bugs o funcionalidades que deban mejorarse, a su vez deben ir cercanas las fechas de culminación de pruebas con la implementación para garantizar un producto de calidad.

Teniendo identificadas las actividades y el tiempo a emplear por cada una debemos elaborar el presupuesto tomando en cuenta salarios, gastos de maquinaria y otros insumos que debamos incurrir como sigue a continuación.

Con esto ya tenemos lista nuestra propuesta para el cliente sobre el sistema de gestión de productos de telefonía móvil, proyectado a 2 meses e invirtiendo el tiempo mostrado en el diagrama de actividades y los costos y gastos de nuestro presupuesto. (Recuerden también calcular cualquier tipo de impuesto como el IVA u otro aplicable a su país o algún impuesto si elaboran el proyecto por servicios profesionales).

Espero haber aportado un poco con este ejemplo de como estipular y planificar nuestros proyectos para que sean exitosos, recuerden también anclar y definir los requerimientos desde un inicio para que no vean comprometido su trabajo, de ser posible manejen contratos que permitan tanto al cliente como a ustedes tener una garantía del trabajo o proyecto a realizar.

Recuerda que este blog sobrevive gracias a tus donaciones o clics en los anuncios, ya sabes como apoyar este recurso para continuar subiendo mas tutoriales. Gracias.

Como crear una aplicación basica en Swift con Xcode

Swift es el nuevo lenguaje de programación para desarrollar aplicaciones orientadas a IOS el Sistema Operativo Inteligente de Apple utilizado en sus dispositivos Iphone/Ipad.

Lo primero que debemos tener en cuenta para desarrollar una aplicación para IOS es el entorno de desarrollo, ¿Que necesitamos para iniciar?.

Basicamente necesitas lo siguiente:
- Un equipo Mac de preferencia con OSX Mavericks o superior.
- El IDE Xcode, puedes descargarla desde la App Store gratuitamente.
- Conocimientos básicos de programación.

Manos a la obra, lo primer será iniciar nuestro entorno de desarrollo Xcode y en la primera pantalla seleccionaremos "Create a new Xcode Project".

En el menú de la parte izquierda seleccionaremos IOS - Application - Single View Application

En la siguiente parte indicaremos un nombre para nuestra aplicación y la organización a la cuál pertenecerá, este paso es importante ya que lo ideal es que utilices el nombre de tu organización cliente o el de tu preferencia. Además seleccionaremos a Swift como lenguaje de programación.

Luego nos pedirá la ubicación donde guardarlo, para ello buscamos la ubicación y hacemos clic en "Create". Podremos observar la estructura básica de nuestro proyecto.

Para continuar primero debemos comprender un poco los conceptos siguientes:

Storyboard: Es una utilidad que te permite ver las diferentes vistas de la aplicación de forma gráfica.

ViewController: Es una clase que hereda de la clase UIViewController que te permitirá llevar tareas de control entre tu modelo de Negocio y tus vistas.

AppDelegate: Algunos le llaman "El corazón de una aplicación IOS" debido a que en dicha clase puedes manejar los estados para configuraciones iniciales o destrucción de objetos en tu aplicación, básicamente gestiona el ciclo de vida de tu aplicación IOS.

Ahora vamos a enfocarnos en nuestro storyboard y vamos a colocar un botón y una caja de texto desde la bandeja de widgets.

seleccionaremos la vista doble donde podremos visualizar la vista y el controlador principal.

Seleccionaremos con clic derecho la caja de texto y arrastraremos hasta la clase ViewController

Se creará un Outlet que en mi caso le pondré textBox.

Podemos ver que esta acción sencilla nos ha generado una variable que estará desde este instante haciendo referencia a nuestro objeto UITextField.

Procederemos a hacer lo mismo con el botón.

En Swift como en cualquier otro lenguaje de programación podemos declarar funciones, en este caso colocaremos una en nuestro ViewController con el nombre showMessage.

Ahora crearemos una acción(IBAction) con la cuál sabremos cuando el botón ha sido presionado.
Para ello seleccionaremos el botón con clic derecho y arrastraremos tal como se muestra.

Invocaremos nuestra función dentro del IBAction. Luego procederemos a iniciar el emulador dando clic al botón Play de la parte superior izquierda.

Y listo, si hacemos clic en el botón podremos ver nuestro mensaje en la caja de texto.

Bien terminamos nuestro "demo" de como crear una aplicación básica con Swift, ahora te queda de tarea modificar la aplicación para que permita introducir un texto en la caja y desplegarla en otro control como en un UILabel por ejemplo. Suerte, más adelante les compartiré otro tutorial más avanzado.

Conectar Oracle 11g con Android mediante Servicio Web con PHP + CodeIgniter en lista personalizada

Para seguir el siguiente tutorial es necesario poseer conocimientos basicos de programacion, ademas de conocimientos basicos en el framework MVC CodeIgniter para PHP y nociones basicas del motor de base de datos Oracle Database 11g XE.

Los siguientes enlaces pueden ayudarte a conocer un poco sobre lo antes mencionado:

1-) http://ellislab.com/codeigniter/user-guide/

2-) http://docs.oracle.com/cd/E29505_01/server.1111/e25789/intro.htm

Continuemos..

Lo primero que haremos es crear un nuevo sitio web para ello necesitaremos tener instalado LAMP en Linux O XAM, WAMP en Windows.

Yo me ayudare en este caso de Dreamweaver ustedes pueden hacerlo con la IDE que crean conveniente, para ello la estructura quedara asi de acuerdo a los directorios de CodeIgniter.

En el directorio application/config/  se encuentra el archivo database.php que es donde configuraremos 

la conexion a nuestra base de datos Oracle 11g Express Edition (Previamente instalada).

Las lineas de especial cuidado son las siguientes:

$tnsname="(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))

        (CONNECT_DATA = (SERVER = DEDICATED) (SERVICE_NAME = XE)))";

En la anterior linea se define una constante que contiene la descripcion general de una conexion a Oracle.

$db['default']['dbdriver'] = 'oci8';

"oci8" es el valor por defecto que utiliza CodeIgniter con las conexiones a Oracle Database.

En mi caso habilitare el servicio de OracleXE, por razones de rendimiento siempre es preferible manejar dicho servicio configurado como "manual" para no mermar el rendimiento de nuestro equipo.

Con el servicio corriendo procedere a utilizar uno de los esquemas por defecto de Oracle (Esquema HR) 

creamos una conexion y procedemos a ejecutar una consulta a la tabla "employee" la cual posteriormente mostraremos en una lista desplegable en Android a traves del consumo de un Servicio Web en PHP(CodeIgniter).

Como pueden observar ejecutamos una consulta sencilla mostrando 2 resultados empleado y salario lo cual procederemos a utilizarlo con CodeIgniter.

Ponemos a punto nuestro servidor e iniciamos el servicio de Apache2 en Linux o WAMP, XAMP en Windows.

En mi caso utilizare WAMP Server.

Volvemos a nuestro proyecto CodeIgniter y crearemos el respectivo modelo y controlador.

Con nuestro modelo y controlador listos nos dirigimos a nuestro navegador web en mi caso Google Chrome

y buscamos la siguiente URL: http://IP_DEL_SERVIDOR/NOMBRE_SITIO_WEB/CONTROLADOR

en mi caso cumplo el estandard de la siguiente manera: http://192.168.1.2/codeigniter_oracle/empleados

Si hemos configurado bien CodeIgniter, y tenemos a punto nuestro servicio de Oracle y WAMP deberiamos observar la respuesta de nuestro servicio en formato JSON, asi.

Iniciaremos Eclipse y procederemos a crear un nuevo proyecto Android Application.

Crearemos 5 clases.

Iremos una a una, veremos como primer punto la clase URL, esta clase sera la encargada de gestionar las URL de peticion a servicios web en el caso que debamos consumir mas de un servicio.

La clase Conexion tendra simplemente un metodo que hara una peticion POST a nuestro servicio web.

La clase convertidorJSON es una clase utilitaria que la adjuntare en el codigo fuente.

En la clase AdaptadorEmpleados haremos una herencia a ArrayAdapter y utilizaremos el arreglo que parsearemos en nuestra consulta al servicio.

Nuestra actividad principal esta especificada en el codigo fuente pero en ella simplemente crearemos una clase que heredara de Asyntask para ejecutar en segundo plano la consulta a nuestro servicio web 

y parsearemos ademas los controles Android.

Nuestras vistas se conforman del activity_main.xml y un layout alternativo llamado item donde colocaremos

el DISEÑO de nuestra lista.

Si todo a salido correcto corremos nuestro emulador y veremos el resultado final de nuestro trabajo.

Adjunto enlace para descargar el codigo Fuente, espero haber aportado con este tutorial a todos aquellos

que desean adentrarse al desarrollo Android con manejo de servicios web y bases de datos.

https://mega.co.nz/#!tt0WEAaY!BCGiIKem-DhLh9WuRef64ef25muBSIQIqTsaglfZ0Io