Android desde cero

Anímate a realizar con el Android Studio tu primera aplicaión móvil

Abre el eclipse y escribe el mas simple "Hola Mundo!"con Spring MVC

Sigue 8 simples pasos para obtener al proyecto mas simple de Spring MVC con Eclipse y Maven.

Como subr una app al Google Play

Te mostramos en tres post, como subir una app en Android al Google Play

Mostrando entradas con la etiqueta heroku. Mostrar todas las entradas
Mostrando entradas con la etiqueta heroku. Mostrar todas las entradas

lunes, 4 de abril de 2016

Android, Heroku, Node.js para publicar un WebService REST (II)

En el Post Anterior buscábamos tener una API REST para consumir desde un dispositivo Android.

Con ese fin, construimos una API Sencilla con Heroku y Node.js que nos entregaba algunas imágenes relacionadas con el Ajedrez, un juego que amo. Las imágenes que entregaba la API eran de las piezas de Ajedrez....

Hoy vamos a dar un paso más con la API, para que entregue ejercicios (puzzles) de por ejemplo Mate en 1 jugada, Mate en dos jugadas, en tres ... y en cuatro jugadas.....  Obviamente, los ejercicios de mate en una jugada son mas sencillos que los de cuatro jugadas.... Con lo cual, podemos segmentar dentro de la API, algunos ejercicios con diferentes grados de complejidad. A su vez estas secciones podríamos discriminarlas dentro de la aplicación Android.

Comencemos

Utilizando la interesante librería http://chessboardjs.com/ armé varias posiciones de jaque mate. En este post comentaba el procedimiento. Si bien esta librería construye los tableros con Javascript. los recorté como imágenes para utilizarla en el ejercicio de Hoy.







Así es como tenemos la siguiente colección de problemas:

http://mw000561.ferozo.com/pncn/chess/post_chessboardjs/v2/index_mate_1.html

Y tenemos las imágenes que buscábamos generar, asociadas a esos problemas:


El diagrama que resalta, es uno de los "Mate en 2" que pueden dar las blancas.

Paso 01: Diseñamos las API

De forma local, el espacio de la API es el siguiente, muy intuitivo:
   
// - http://localhost:5000/chess/api/matesEn1/00
// - http://localhost:5000/chess/api/matesEn1/08
// ...
// - http://localhost:5000/chess/api/matesEn2/00
// - http://localhost:5000/chess/api/matesEn2/08
// ...
// - http://localhost:5000/chess/api/matesEn3/00
// - http://localhost:5000/chess/api/matesEn3/16
// ...
// - http://localhost:5000/chess/api/matesEn4/00
// - http://localhost:5000/chess/api/matesEn4/02

Recordemos que las imágenes están en:




La primera pregunta es ¿Como defino la función en Node.js? Ya que tiene que recibir el numero de problema que necesitamos:

Tenemos dos Posibilidades de patrones:

Para:
http://localhost:5000/chess/api/matesEn4/02

Posibilidades: 
'/chess/api/matesEn1/:id'
'/chess/api/matesEn2/:id'
'/chess/api/matesEn3/:id'
'/chess/api/matesEn4/:id'

O bien, mas resumido:
'/chess/api/:mates/:id'






Código Node.js de la API REST



La lista de problemas, para simplificar lo dejo en una variable de javascript, respetando el json:
   
var mateJuagas1 = [

  { position: '5k2/4np2/5N2/8/8/B7/7K/6R1 w - - 0 1'          , solution: '1. Rg8#'    },
  { position: '3r4/1pk5/3pP3/2N5/8/8/2R3K1/8 w - - 0 1'       , solution: '1. Nd7#'    },
  { position: '3Nnr2/R2PkP2/4p3/8/8/8/7K/3R4 w - - 0 1'       , solution: '1. dxe8=N#' },

  { position: '6r1/1Q3P2/5k2/5P2/5K2/8/8/8 w - - 0 1'         , solution: '1. fxg8=N#' },
  { position: '8/5P2/5k2/5B2/5K2/8/8/8 w - - 0 1'             , solution: '1. f8=Q#'   },
  { position: 'rnb4k/6pp/8/p3N3/8/PB6/1PP4R/2K5 w - - 0 1'    , solution: '1. Ng6# '   },

  { position: '4k3/3nn3/4N3/1N6/8/8/6K1/8 w - - 0 1'          , solution: '1. Nd6#'    },
  { position: '6k1/p1p2rpp/1q6/2p1P3/8/1Q6/PP4PP/3R3K w - - 0', solution: '1. Rd8#'    },
  { position: '8/8/8/7R/3k4/2R5/1K3P2/6B1 w - - 0 1'          , solution: '1. f3#'     }

];
A continuación las funciones de entrada de la API, observemos que solamente aceptamos GET, y también el parámetro variable definido con :id


   
var CONST_MateEn1 = "mateEn1";
var CONST_MateEn2 = "mateEn2";
var CONST_MateEn3 = "mateEn3";
var CONST_MateEn4 = "mateEn4";

app.get('/chess/api/matesEn1/:id',   function(req, res){   
res.json( getJsonDiagram(CONST_MateEn1, req, res));  
});

app.get('/chess/api/matesEn2/:id',   function(req, res){   
res.json( getJsonDiagram(CONST_MateEn2, req, res));  
});

app.get('/chess/api/matesEn3/:id',   function(req, res){   
res.json( getJsonDiagram(CONST_MateEn3, req, res)); 
 });

app.get('/chess/api/matesEn4/:id',   function(req, res){   
res.json( getJsonDiagram(CONST_MateEn4, req, res));  
});

function getColeccion(col) {

   if (col == CONST_MateEn1) {
      return mateJuagas1;
   }

   if (col == CONST_MateEn2) {
       return mateJuagas2;
   }

   if (col == CONST_MateEn3) {
       return mateJuagas3;
   }

   if (col == CONST_MateEn4) {
       return mateJuagas4;
   }

   return null;
}

function getJsonDiagram (col, req, res) {

   var mateJuagas = getColeccion(col);

   var id = req.params.id;

   var jsonAA    = mateJuagas[id];

   var position  = jsonAA.position;
   var solution  = jsonAA.solution;

   var imageName = "crossfitChess_"+col+"_"+getImageNumber(id)+".png";
   var image     = getImagePath()+"\/"+col+"\/"+imageName;

   return res.json({ position: position, solution : solution, image : image });
   // return jsonAA;
}


Probamos el ejemplo:

¿Como probamos lo que hemos construido hasta ahora? Como es un backend de una API rest, pues simplemente invocando en el browser alguna de las direcciones de la API para ver como responde:

Ejemplo:

http://localhost:5000/chess/api/matesEn2/4

Nos debería retornar el segundo problema de la serie de "Mate en 2":  OK!
Y la imagen a la que se hace referencia en el JSON es la de un Mate en 2:


... 1. Cb5+ y luego 2. Cb7# ... Nice! Son lindos los problemas como este que empiezan con Jaque, porque no hay que pensar muchas variantes y encontras la solución rápido...






¿Que falta?

Pareciera que tenemos todo lo que buscábamos dentro de este post, pero falta subir el ejemplo a la nube, ya que hemos trabajado de forma local. De ahí que las direcciones sean con localhost:5000

Para el que necesite repasar los pasos a continuación, puede ver el post específico sobre como se creó la cuenta en heroku y se hizo el upload. O también el post anterior donde nuevamente subimos la versión previa a heroku

Subimos el proyecto a Heroku

Disculpen lo extenso del comit, pero prefiero copiarlo completo para que no se generen dudas por errores de tipeo:
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ pwd
/Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git add .
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git commit -m "API REST para Ejercicios de Mate en 1,2,3 y 4"
[master e605c25] API REST para Ejercicios de Mate en 1,2,3 y 4
 39 files changed, 159 insertions(+)
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00000.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00001.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00002.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00003.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00004.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00005.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00006.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00007.png
 create mode 100644 public/images/mateEn1/crossfitChess_MateEn1_00008.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00000.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00001.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00002.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00003.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00004.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00005.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00006.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00007.png
 create mode 100644 public/images/mateEn2/crossfitChess_MateEn2_00008.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00000.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00001.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00002.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00003.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00004.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00005.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00006.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00007.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00008.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00009.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00010.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00011.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00012.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00013.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00014.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00015.png
 create mode 100644 public/images/mateEn3/crossfitChess_MateEn3_00016.png
 create mode 100644 public/images/mateEn4/crossfitChess_MateEn4_00000.png
 create mode 100644 public/images/mateEn4/crossfitChess_MateEn4_00001.png
 create mode 100644 public/images/mateEn4/crossfitChess_MateEn4_00002.png
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git push heroku master
Counting objects: 47, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (47/47), done.
Writing objects: 100% (47/47), 1.30 MiB | 172.00 KiB/s, done.
Total 47 (delta 3), reused 0 (delta 0)
remote: Compressing source files... done.
remote: Building source:
remote: 
remote: -----> Using set buildpack heroku/nodejs
remote: -----> Node.js app detected
remote: 
remote: -----> Creating runtime environment
remote:        
remote:        NPM_CONFIG_LOGLEVEL=error
remote:        NPM_CONFIG_PRODUCTION=true
remote:        NODE_ENV=production
remote:        NODE_MODULES_CACHE=true
remote: 
remote: -----> Installing binaries
remote:        engines.node (package.json):  0.12.7
remote:        engines.npm (package.json):   unspecified (use default)
remote:        
remote:        Downloading and installing node 0.12.7...
remote:        Using default npm version: 2.11.3
remote: 
remote: -----> Restoring cache
remote:        Loading 2 from cacheDirectories (default):
remote:        - node_modules
remote:        - bower_components (not cached - skipping)
remote: 
remote: -----> Building dependencies
remote:        Pruning any extraneous modules
remote:        Installing node modules (package.json)
remote: 
remote: -----> Caching build
remote:        Clearing previous node cache
remote:        Saving 2 cacheDirectories (default):
remote:        - node_modules
remote:        - bower_components (nothing to cache)
remote: 
remote: -----> Build succeeded!
remote:        ├── cool-ascii-faces@1.3.4
remote:        ├── ejs@2.3.3
remote:        └── express@4.13.3
remote:        
remote: 
remote: -----> Discovering process types
remote:        Procfile declares types -> web
remote: 
remote: -----> Compressing...
remote:        Done: 11.8M
remote: -----> Launching...
remote:        Released v13
remote:        https://infinite-lowlands-19433.herokuapp.com/ deployed to Heroku
remote: 
remote: Verifying deploy... done.
To https://git.heroku.com/infinite-lowlands-19433.git
   6ed3a45..e605c25  master -> master
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ 






Ultimo Paso:

Finalmente, lo último que nos queda es verificar que el backend de Heroku nos esté retornando tanto los problemas con los diagramas en formato FEN como una imagen correcta del mismo:

Listado de Problemas (Mate en 2):
https://infinite-lowlands-19433.herokuapp.com/chess/api/matesEn2

Cuarto Problema de la serie de (Mate en 2):
https://infinite-lowlands-19433.herokuapp.com/chess/api/matesEn2/4

URL de la Imagen del Cuarto Problema de la serie de (Mate en 2):
https://infinite-lowlands-19433.herokuapp.com/chess/api/matesEn2/4/img

Diagrama del Problema Nro 4 de la serie de (Mate en 2):
https://infinite-lowlands-19433.herokuapp.com/images/mateEn2/crossfitChess_mateEn2_00004.png

Verificamos que esta funcionando:



Ok, en este punto finalizamos el post, con el backend comportándose tal como lo queríamos.

En el próximo post, volveremos al desarrollo sobre Andoroid, con el front end invocando a estos servicios JSon.




domingo, 3 de abril de 2016

Android, Heroku, Node.js para publicar un WebService REST

En el post anterior vimos como abrir una cuenta en heroku, que nos permite tener una plataforma gratuita para publicar servicios web, lo cual nos habilita a crear un backend para desarrollo. El lenguaje que elegimos en Node.js aunque también nos ofrece Java, Rubi y varios mas

En este post, vamos a continuar los ejemplos que configuramos y vamos a crear una sencilla API REST que publicará en Node.js un listado de productos.

Aclaración:
En este post no utilizaremos una base de datos (por ejemplo MongoDB) detrás de Node.js
Esto lo realizaremos en un post posterior, donde exploraremos con instalarla localmente y en el servidor. Para los que quieran




Comencemos

Paso 01: Nuestros recursos

Creamos el código para tres productos en Node.js, el FrontEnd es una aplicación  en Android y contiene la clase producto: 
   
public class Producto {

    private int id;
    private String description;
    private double price;
    private String image;

    public Producto(){ }

    // Getter y Setter
}

Tenemos las siguientes imágenes subidas al servidor Heroku:


Que son las figuras de las piezas de Ajedrez, juego que amo:



Repasemos como subimos estas imagen desde Local (PC) a Remoto (Heroku) con Git:

  
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ pwd
/Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git commit -m "Agrego imagenes de ajedrez"
[master 70bc0ab] Agrego imagenes de ajedrez
 7 files changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 public/images/Pieza01_rey.png
 create mode 100644 public/images/Pieza02_dama.png
 create mode 100644 public/images/Pieza03_torre.gif
 create mode 100644 public/images/Pieza04_alfil.gif
 create mode 100644 public/images/Pieza05_caballo.gif
 create mode 100644 public/images/Pieza06_peon.gif
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git push heroic master
Counting objects: 11, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (11/11), done.
..
remote: Verifying deploy.... done.
To https://git.heroku.com/infinite-lowlands-19433.git
   f2abe98..70bc0ab  master -> master
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ git push heroku master
MacBook-Pro-de-Pablo:node-js-getting-started pabloin$ heroku local
[WARN] No ENV file found
[OKAY] Trimming display Output to 121 Columns
12:24:35 AM web.1 |  Node app is running on port 5000

 



Paso 02: Creamos la API

Creamos la API REST:
  • https://infinite-lowlands-19433.herokuapp.com/chess/api/productos
Y para definir un Json sencillo, con Node.js creamos:

// - http://localhost:5000/chess/api/chess
// - http://localhost:5000/chess/api/chess/dama
// - http://localhost:5000/chess/api/chess/caballo
//
// - https://infinite-lowlands-19433.herokuapp.com/chess/api/chess
// - https://infinite-lowlands-19433.herokuapp.com/chess/api/chess/dama
// - https://infinite-lowlands-19433.herokuapp.com/chess/api/chess/caballo
//
var chess =
    [
      {"id":1,"description":"Rey     ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza01_rey.png",     "price":100},
      {"id":2,"description":"Dama    ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza02_dama.png",    "price":9},
      {"id":3,"description":"Torre   ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza03_torre.gif",   "price":5},
      {"id":4,"description":"Alfil   ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza04_alfil.gif",   "price":3},
      {"id":5,"description":"Caballo ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza05_caballo.gif", "price":3},
      {"id":6,"description":"Peón    ","image":"https:\/\/infinite-lowlands-19433.herokuapp.com\/images\/Pieza06_peon.gif",    "price":1}
    ];

app.get('/chess/api/chess', function(req, res){        res.json(chess);   });

app.get('/chess/api/chess/rey',     function(req, res){   res.json(chess[0]);   });
app.get('/chess/api/chess/dama',    function(req, res){   res.json(chess[1]);   });
app.get('/chess/api/chess/torre',   function(req, res){   res.json(chess[2]);   });
app.get('/chess/api/chess/alfil',   function(req, res){   res.json(chess[3]);   });
app.get('/chess/api/chess/caballo', function(req, res){   res.json(chess[4]);   });
app.get('/chess/api/chess/peon',    function(req, res){   res.json(chess[5]);   });




Con este paso concluimos la creación de una API REST, algunos de los recursos son:




La intención es dejar la API pública para consumirla desde un dispositivo Android

ToDo - Próximo Paso:

En el siguiente Post, escribiremos una API que en vez de imágenes de las piezas de Ajedrez, nos entregue ejercicios de táctica de ajedrez (Mate en 1, en 2, etc) con un JSON donde tendremos las imágenes, la posición FEN y la solución





sábado, 2 de abril de 2016

Android, Heroku y Node.js para consumir webservices

Vamos a seguir un ejercicio que nos mostrará como consumir webservices REST.

Para seguir este ejercicio, vamos a ir desde atrás hacia adelante. O sea, desde el backend hacia el front end.

Comencemos:

¿Que webservice vamos a consumir?

En el curso que estoy haciendo nos publicaron la siguiente URL para hacer los ejercicios:

http://www.webkathon.com/pruebasit/products.php
http://www.webkathon.com/pruebasit/products.php?id=1

Que respeta el estándar de una API REST, y nos retorna tres productos.

En mi caso estoy haciendo el ejercicio adaptado con una juguetería, y así, antes de comenzar, creo que es válido plantearse las siguientes dos preguntas.

¿Podría tener mi propia API REST en vez de utilizar la API del curso?
¿Donde podría hostearla?





Para empezar, vamos a utilizar y probar una plataforma que nos recomendaron:


Con esta plataforma, según entiendo, se pueden hacer "mock" o backend de los servicios para poder concentrarse tan solo en el front.

En este punto, queda abierta una segunda pregunta: Si quisiéramos tener un backend propio, y a su vez con datos más reales... ¿Que plataforma deberíamos elegir.. ? ¿Podríamos hacerlo, por ejemplo, con la plataforma de Google Drive? O sea, exponiendo como json algunos datos de la hoja de cálculo. Según tengo entendido esto sería viable... y tendría un interesante nivel de escalamiento....

Quizá en una segunda parte del post, desarrollemos esta pregunta.

Paso 01: Probando Heroku - Crear cuenta

Vamos a crear una cuenta en https://www.heroku.com/ y lo primero que observamos es que nos solicita que definamos un lenguaje.... aunque programo en Java, voy a elegir Node.js así también aprovecho a "matar dos pájaros de un tiro" y aprender algo acerca de Node.js
Tenemos el siguiente escritorio:
Como dije al principio, la idea es desarrollar el backend con node.js (que entiendo que es algo así como javascript del lado del server, aunque no se mucho mas que eso...).

Mirando un Tutorial de "Getting Started" con heroku y node.js parece que necesitamos tener instalado el node.js en nuestro sisitema... Con lo cual, interrumpimos este post para instalarnos el node.js de https://nodejs.org/en/




Paso 02: Instalando node.js en la PC

Aparentemente... para poder empezar con heroku, tenemos que tener instalado node.js en nuestras PC, así que, hacia ahí vamos:
Voy a bajar la versión 4.4.2 de node.js, para ser un poco conservador... no quiero tener demasiadas sorpresas.


Finalizamos la instalación. ¿Como puedo saber si está bien instalado? Abro la terminal, y ejecuto el comando npm y lo encuentra.

Ok, además tengo que seguir instalando una Toolbar de Heroku:
Y luego:
Y probamos en la terminal:
  • npm que verifica que node.js esta instalado
  • heroku login, que pide las credenciales de nuestra cuenta
  • heroku local, lo cual baja la versión heroku de GitHub
 Ok.... y siguiendo los pasos del manual de inicio de Heroku:

https://devcenter.heroku.com/articles/getting-started-with-nodejs#prepare-the-app

Ejecutamos en la terminal los siguientes comandos que nos bajarán una aplicación de ejemplo de Heroku.

$ git clone https://github.com/heroku/node-js-getting-started.git
$ cd node-js-getting-started

Seguimos con los pasos del Tutorial ..... creamos la aplicación de ejemplo:

$ heroku create
Creating app... done, stack is cedar-14
https://infinite-lowlands-19433.herokuapp.com/ | https://git.heroku.com/infinite-lowlands-19433.git

Ejecutamos:

$ heroku ps:scale web=1
$ heroku open

Y vemos la aplicación tipo "Hola Mundo" levantada en la URL que heroku nos asignó:

Ejecutamos también

 $ heroku logs --tail

Para verificar que 

Va contra nuestra instancia local de heroku.



Observemos en la siguiente pantalla que también está la termial:


Donde Procfile contiene:

web: node index.js

Veamos los dynos (containerss) que están detras de nuestra app: 
Es uno solo.... para escalar a varios dynos tenemos que hacer un upgrade de la cuenta/plan gratuito que nos da heroku...

Se puede ejecutar la app localmente
Como se ve a continuación en el puerto 5000
Ejecutamos algunos comandos mas, asociado a promover cambios locales en repositorios remotos ...

npm install --save --save-exact cool-ascii-faces
... etc...
 heroku open cool

Y tenemos el nuevo directorio "cool" tanto en la app local como remota:

http://localhost:5000/cool


Un poco mas... para ver addons y otros servicios de terceros que podríamos incorporar:

heroku addons:create papertrail
Igualmente para los addons necesitamos ingresar la tarjeta de crédito... en este punto finalizamos el seguimiento del tutorial:





Como cosas positivas: después de varios pasos
Instalamos y configuramos localmente
  • Node.js
  • Heroku
  • Heroku nos dio un espacio gratuito para hostear una aplicación en internet.
  • Podemos versionar con Git
Como cosas negativas... aún no hemos podido hacer nuestro backend de productos...
Aunque tengo una idea de como se podría editar el proyecto

Paso 03: Publicar un servicio JSON de Productos

Con el ejercicio anterior, tenemos al menos, las aplicaciones:

http://localhost:5000/cool
https://infinite-lowlands-19433.herokuapp.com/cool


Vamos con un par de preguntas sencillas:

¿Podemos agregarle un par de servicios JSON?

Si, sería tan sencillo como agregar:
   
app.get('/helloJson', function (req, res) {              
  req.requestTime = Date.now();                          
  var responseText = 'Hello World! + Hola Mundo! Now:' +  req.requestTime + '';                                   
  // res.send(responseText);                             
  res.json({ user: 'tobi', msg : responseText });        
});   


Mi Resumen

Agrego un resumen de los nuevos recursos instalados y publicados, con utilidad, al menos para mi:
Heroku, ejemplo "Getting Started" en la PC:
  • /Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
Local:
   
$ cd /Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
$ heroku local web
# 
# Abrir
#  --> http://localhost:5000/cool
#  --> http://localhost:5000/helloJson
#
$ npm install
$ heroku local
#
$ git add .
$ git commit -m "Demo"
$ git push heroku master
#
# Abre el Remoto en Internet
$ heroku open cool

Ampliando el contenido:


Los siguientes links me parecieron interesantes para ampliar el ejercicio:

http://webapplog.com/intro-to-express-js-simple-rest-api-app-with-monk-and-mongodb/
https://codeforgeek.com/2014/06/express-nodejs-tutorial/

Sobre Express, el framework que está por encima de Node.js comparto los links con la documentación oficial:

  • http://expressjs.com/es/starter/basic-routing.html
  • http://expressjs.com/es/4x/api.html#res.json

Con es finalizamos el ejemplo de como crear un entorno de backend con Heroku y Node.js que queda listo para ser consumido desde cualquier front, por ejemplo una aplicación Android como la que estamos armando en los post anteriores (Aplicación de Juguetería)

En un próximo post integraremos el Front Android de la Juguetería con el backend de Heroku y Node.js