• Código https://github.com/jafrancov/Google-Apps-Scripts/blob/master/forms/notifyOnFormSubmit.js
• Uno de tantos editores WYSIWYG de HTML https://html5-editor.net/
• Límite de envíos diarios https://developers.google.com/apps-script/guides/services/quotas

Enjoy!

En resumen:

• Configuración básica de entorno virtual y Django.
• Instalación y configuración de AllAuth.
• Integración de Bootstrap y Crispy Forms.
• Configuración y autenticación con Google Oauth 2.0

Enjoy!

Código: Github @jafrancov

Uno de los retos con los que me topé es usar GridFS que podemos entenderlo así:

MongoDB puede ser utilizado con un sistema de archivos, tomando la ventaja de la capacidad que tiene MongoDB para el balanceo de carga y la replicación de datos utilizando múltiples servidores para el almacenamiento de archivos. Esta función (que es llamada GridFS ) está incluida en los drivers de MongoDB y disponible para los lenguajes de programación que soporta MongoDB. Esta base de datos expone funciones para la manipulación de archivos y contenido a los desarrolladores. En un sistema con múltiple servidores, los archivos pueden ser distribuidos y copiados entre los mismos varias veces y de una forma transparente, de esta forma se crea un sistema eficiente que maneja fallos y balanceo de carga.

Bien, en resumen, es un sistema de archivos de MongoDB.

Mi problema era publicar las imágenes dado que no las almacena en una carpeta pública por así decirlo, así que había que buscar la solución vía programación. Antes de seguir, los paquetes que estoy usando son los siguientes:

• Django
• MongoDB
• mongoengine
• django-mongodbforms
• PIL

Para el caso usé un modelo bastante sencillo, digamos que mi aplicación es un Blog y mi modelo es de un Post

from mongoengine import *
from mongodbforms import DocumentForm


class Post(Document):
    title = StringField(max_length=160, required=True)
    body = StringField(required=True)
    image = ImageField(size=(800, 600, True), thumbnail_size=(150, 112, True))


class PostForm(DocumentForm):
    class Meta:
        document = Post

Hay 2 maneras de realizar la tarea:

1. Sin thumbnail (miniatura), donde es 100% django.
2. Con thumbnail, donde tendremos que recurrir a pymongo + django

La primera es muy sencilla, si tu aplicación no requiere de miniaturas, esta es la mejor opción, simplemente requieres conocer el ID de tu imagen:

''' blog/views.py '''
def view_post(request, id):
    post = get_document_or_404(Post, pk=id)
    # img_id temporal para mandar llamar la imagen
    # Si no contiene imagen el post, no muestra nada
    try:
        post.img_id = post.image._id
    except AttributeError:
        post.img_id = False
    return render_to_response('post.html', {'post': post})


def display_image(request, id):
    image = get_document_or_404(Post, image=ObjectId(id)).image
    return HttpResponse(image.read(), content_type=image.contentType)


''' blog/urls.py '''
# ...
                       url(r'^post/(?P<id>\w+)/$', 'view_post'),
                       url(r'^media/(?P<id>\w+)$', 'display_image'),
# ...


''' blog/templates/post.html '''
<p><a href="/blog/">View all posts</a></p>

<p><h2>{{ post.title }}</h2></p>
<p>{{ post.body }}</p>
{% if post.img_id %}
<p style="text-align: center"><img src="/blog/media/{{ post.img_id }}"></p>
{% endif %}

Si por alguna razón requieres el uso de las miniaturas, esta es la receta de cocina para obtener la imagen regular o la miniatura, esto es debido a que directamente con el ORM de Django con mongoengine no hay manera de hacer referencia a la miniatura:

''' blog/views.py '''
def view_post_th(request, id):
    post = get_document_or_404(Post, pk=id)
    # img_id temporal para mandar llamar la imagen
    # Si no contiene imagen el post, no muestra nada
    try:
        post.img_id = post.image._id
    except AttributeError:
        post.img_id = False
    try:
        post.thumbnail_id = post.image.thumbnail_id
    except AttributeError:
        post.thumbnail_id = False
    return render_to_response('post2.html', {'post': post})


def display_image_m2(request, id):
    # Conexión adicional al sistema de archivos de MongoDB
    mongo_con = Connection()
    # Si tu campo en el modelo es ImageField, la collección es 'images'
    grid_fs = gridfs.GridFS(mongo_con.servemedia, collection='images')
    if not grid_fs.exists(ObjectId(id)):
        raise Exception("Mongo file does not exist! {0}".format(ObjectId(id)))
    image = grid_fs.get(ObjectId(id))
    try:
        # Con esta validación sabemos si es miniatura o imagen original,
        # el thumbnail por default se guarda sin el contentType
        content_type = image.contentType
    except AttributeError:
        # Con esto buscamos la imagen original para obtener el contentType del thumbnail
        for grid_out in grid_fs.find({'thumbnail_id': ObjectId(id)}).limit(1):
            content_type = grid_out.contentType
    return HttpResponse(image.read(), content_type=content_type)


''' blog/urls.py '''
# ...
                       url(r'^post2/(?P<id>\w+)/$', 'view_post_th'),
                       url(r'^media2/(?P<id>\w+)$', 'display_image_m2'),
# ...


''' blog/templates/post2.html '''
<p><a href="/blog/">View all posts</a></p>

<p><h2>{{ post.title }}</h2></p>
<p>{{ post.body }}</p>
{% if post.thumbnail_id %}
<p style="text-align: center"><img src="/blog/media2/{{ post.thumbnail_id }}"></p>
{% endif %}
{% if post.img_id %}
<p style="text-align: center"><img src="/blog/media2/{{ post.img_id }}"></p>
{% endif %}

El código completo puedes encontrarlo en mi GitHub  https://github.com/jafrancov/Serve-Media-Django-MongoDB-GridFS espero les sirva y sea de su agrado, cualquier duda, deja tu comentario.

Enjoy!

La respuesta siempre caía en “hay que hacer un sistema que nos haga eso”, pues ahora pueden ahorrarse unos cuántos pesos y un tiempo considerable, les comparto un tutorial que realicé donde al momento en que se envía un formulario hecho con Google Drive, además de que tenemos un registro, le envía un correo al usuario que ha completado el formulario con un resumen de sus respuestas. Estas son las bases, si quieres hacer algo más complejo, ya dependerá de tu imaginación.

El código pueden encontrarlo en este enlace.

Enjoy!

Aquí les dejo un pequeño tutorial que hice sobre cómo hacer una combinación de correspondencia con Google Drive, espero les sirva bastante.

Enjoy!

En un post anterior, vimos cómo hacer un Geocode Simple, donde obteníamos las coordenadas a partir de una dirección dada, es decir, podríamos poner cualquier combinación de calles, colonias, ciudad, etc. y obtener las coordenadas de esa dirección para colocarlas en un mapa. En este caso es al contrario, buscar direcciones (de acuerdo a la base de datos de Google) a partir de coordenadas.

Lo que haremos se resume en: escribir coordenadas (latitud, Longitud), verificar si existe, si existe, colocar un marcador, centrar y dar zoom en el mapa en la región de la dirección obtenida, si no existe la dirección arrojar un error diciendo que no existe.

Al igual que el ejemplo anterior, es necesario crear un objeto Geocoder, que nos permitirá hacer la interpretación de lo que intentemos buscar.

var geocoder = new google.maps.Geocoder();

El objeto que se obtiene de respuesta es un JSON, donde lo manejaríamos como regularmente se hace en javascript, el resultado es algo como esto:

{
  "status": "OK",
  "results": [ {
    "types": [ "street_address" ],
    "formatted_address": "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
    "address_components": [ {
      "long_name": "1600",
      "short_name": "1600",
      "types": [ "street_number" ]
    }, {
      "long_name": "Amphitheatre Pkwy",
      "short_name": "Amphitheatre Pkwy",
      "types": [ "route" ]
    }, {
      "long_name": "Mountain View",
      "short_name": "Mountain View",
      "types": [ "locality", "political" ]
    }, {
      "long_name": "California",
      "short_name": "CA",
      "types": [ "administrative_area_level_1", "political" ]
    }, {
      "long_name": "United States",
      "short_name": "US",
      "types": [ "country", "political" ]
    }, {
      "long_name": "94043",
      "short_name": "94043",
      "types": [ "postal_code" ]
    } ],
    "geometry": {
      "location": {
        "lat": 37.4219720,
        "lng": -122.0841430
      },
      "location_type": "ROOFTOP",
      "viewport": {
        "southwest": {
          "lat": 37.4188244,
          "lng": -122.0872906
        },
        "northeast": {
          "lat": 37.4251196,
          "lng": -122.0809954
        }
      }
    }
  } ]
}

Lo único que nos faltaría es el código para validar, interpretar y dibujar. Para esto, hay 3 cosas importantes que debemos tomar en cuenta del JSON que tenemos de respuesta:

• status: contiene la respuesta del estado de la petición, si fue satisfactoria o si hubo algún error y que tipo de error.
• geometry.location: la ubicación de la dirección solicitada.
• geometry.viewport: los límites recomendados para ajustar el zoom del mapa, haciendo un cuadrante con las esquinas Noreste (superior derecha) y Suroeste (inferior izquierda).

Con esto en presente, la función siguiente nos mostrará solamente el primer resultado obtenido, quedando así :

function codeLatLng() {
   var input = $('#latlng').val();
   var latlngStr = input.split(',', 2);
   var lat = parseFloat(latlngStr[0]);
   var lng = parseFloat(latlngStr[1]);
   var latlng = new google.maps.LatLng(lat, lng);
   geocoder.geocode({'latLng': latlng}, function(results, status) {
      if (status == google.maps.GeocoderStatus.OK) {
         if (results[0]) {
            map.fitBounds(results[0].geometry.viewport);
            marker.setMap(map);
            marker.setPosition(latlng);
            $('#address').text(results[0].formatted_address);
            infowindow.setContent(results[0].formatted_address);
            infowindow.open(map, marker);
            google.maps.event.addListener(marker, 'click', function(){
               infowindow.setContent(results[0].formatted_address);
               infowindow.open(map, marker);
            });
         } else {
            alert('No results found');
         }
      } else {
         alert('Geocoder failed due to: ' + status);
      }
   });
}

Los primeros 4 renglones de la función realizan la validación y separación de latitud y longitud, para poder formar el objeto latLng, y listo con esto tenemos terminado nuestro ejercicio, puedes verificarlo en funcionamiento en la página de demos:

El código completo quedaría así:

var geocoder;
var map;
var infowindow = new google.maps.InfoWindow();
var marker = new google.maps.Marker();

function closeInfoWindow() {
      	infowindow.close();
   }

function initialize() {
  geocoder = new google.maps.Geocoder();
  var latlng = new google.maps.LatLng(20.68009, -101.35403);
  var mapOptions = {
    zoom: 8,
    center: latlng,
    mapTypeId: 'roadmap'
  }
  map = new google.maps.Map(document.getElementById('map_canvas'), mapOptions);

  google.maps.event.addListener(map, 'click', function(){
        	closeInfoWindow();
     	  });
}

function codeLatLng() {
  var input = $('#latlng').val();
  var latlngStr = input.split(',', 2);
  var lat = parseFloat(latlngStr[0]);
  var lng = parseFloat(latlngStr[1]);
  var latlng = new google.maps.LatLng(lat, lng);
  geocoder.geocode({'latLng': latlng}, function(results, status) {
    if (status == google.maps.GeocoderStatus.OK) {
      if (results[0]) {
		map.fitBounds(results[0].geometry.viewport);
                marker.setMap(map);
                marker.setPosition(latlng);
		$('#address').text(results[0].formatted_address);
		infowindow.setContent(results[0].formatted_address);
        infowindow.open(map, marker);
		google.maps.event.addListener(marker, 'click', function(){
            infowindow.setContent(results[0].formatted_address);
	        infowindow.open(map, marker);
        });
      } else {
        alert('No results found');
      }
    } else {
      alert('Geocoder failed due to: ' + status);
    }
  });
}

$(document).ready(function(){
   initialize();
});

Y en el Body solamente esto:

<div>
   <input id="latlng" type="textbox" value="20.68009, -101.35403">
</div>
<div>
   <input type="button" value="Reverse Geocode" onclick="codeLatLng()">
</div>
<table class="width2">
   <tr><td class="unitx1"><strong>Dirección:</strong></td><td><div id="address"></div></td></tr>
</table>
<div id="map_canvas" style="width: 990px; height: 500px"></div>

Espero les sirva y cualquier cosa, ya saben cómo contactarme…

Enjoy this Life!

En esta ocasión veremos un ejemplo buscado por muchos, y que puede llegar a tener gran utilidad dependiendo de nuestra aplicación, estamos hablando de trazar rutas… dije ¿rutas?, si, rutas, direcciones, un pequeño GPS en web.

Lo que haremos es bastante sencillo de entender y lo pondremos de la manera más básica, esto para darte la amplitud a que lo mejores y le pongas la cara que desees.

El proceso es entendido por todos, es proporcionar 2 puntos, un origen y un destino, a partir de esto, que nos proporcione una ruta para ir de un lado a otro. Sin más preámbulo manos a la obra.

Lo primero (siempre usaremos los scripts de jQuery y GMaps) que haremos será crear el html sobre el cuál vamos a trabajar, para esto solamente requerimos 2 cajas de texto para escribir el origen y el destino, un botón para ejecutar el proceso, 2 combobox donde uno será para elegir el modo de viaje (auto, bicicleta, caminando) y el otro para elegir el sistema de medición (Métrico -mts, Km-, Imperial -ft, Mi-), por último 2 divs, uno para el espacio del mapa y otro para el panel de direcciones.

<div>
	<label for="origen">Origen</label>
	<input type="text" name="origen" id="origen" placeholder="calle, ciudad, estado..." />
	<br />
	<label for="destino">Destino</label>
	<input type="text" name="destino" id="destino" placeholder="calle, ciudad, estado..." />
	<br />
	<input type="button" id="buscar" value="Buscar ruta"  />
</div>
<br />
<h3>Opciones</h3>
<div id="rutaOps">
	<select id="modo_viaje" class="opciones_ruta">
		<option value="DRIVING" selected="selected">Auto</option>
      	<option value="BICYCLING">Bicicleta</option>
      	<option value="WALKING">Caminando</option>
  	</select>
  	<select id="tipo_sistema" class="opciones_ruta">
      	<option value="METRIC" selected="selected">Métrico</option>
      	<option value="IMPERIAL">Imperial</option>
  	</select>
</div>
<br />
<div>
	<div id="map_canvas" style="float:left; width:70%; height:500px"></div>
	<div id="panel_ruta" style="float:right; overflow: auto; width:30%; height: 500px"></div>
</div>

Una vez que tenemos el HTML nos enfocaremos en el la API y JS completamente, declaramos 2 objetos globales, uno es DirectionsRenderer y otro es DirectionsService. El primero nos dará las herramientas necesarias para que visualicemos en el navegador toda la información obtenida, el segundo es el servicio que buscará en las bases de datos de Google Maps tanto los puntos como la(s) rutas existentes.

var directionsDisplay = new google.maps.DirectionsRenderer();
var directionsService = new google.maps.DirectionsService();

Una vez hecho esto, escribimos el código para ya tener inicializado y dibujado el mapa en nuestra página, creamos una función con el nombre que nosotros queramos, dentro de ella, vamos a colocar lo siguiente:

var request = {
 origin: $('#origen').val(),
 destination: $('#destino').val(),
 travelMode: google.maps.DirectionsTravelMode[$('#modo_viaje').val()],
 unitSystem: google.maps.DirectionsUnitSystem[$('#tipo_sistema').val()],
 provideRouteAlternatives: true
 };

Línea por línea:

1. Declaramos una variable con las opciones con las que se va a solicitar la información al objeto DirectionsServices, lo siguiente son parámetros para hacer la búsqueda de acuerdo a los datos introducidos.
2. A origin se le asigna el valor de  la caja de texto origen estableciendo el punto de partida de la ruta.
3. A destination se le asigna el valor de la caja de texto destino con el que se especifica el punto final de la ruta.
4. En la opción travelMode se asigna la opción elegida para el modo de viaje (modo_viaje), por esta razón en el valor de cada opción se definió de acuerdo al valor asignado en la API.
5. unitSystem se refiere al tipo de unidades que se utilizarán para mostrar distancias, obteniendo el valor del tipo_sistema.
6. Con la opción provideRouteAlternatives establecemos en verdadero o falso (por default false), para indicar que puede ofrecernos más resultados para las rutas (rutas alternativas).

Una vez declarada la variable con el arreglo de los parámetros, con unas cuántas líneas vamos a hacer la solicitud y plasmar el resultado:

directionsService.route(request, function(response, status) {
	if (status == google.maps.DirectionsStatus.OK) {
		directionsDisplay.setMap(map);
		directionsDisplay.setPanel($("#panel_ruta").get(0));
		directionsDisplay.setDirections(response);
	} else {
	        alert("No existen rutas entre ambos puntos");
	}
});

Recordemos que al inicio declaramos 2 objetos, teniendo en cuenta su función, les explico línea a línea:

1. directionsService.route hace la solicitud a la API con los datos que previamente establecimos (request), creamos una una función interna, que recibe los parámetros de respuesta (response) que es donde vendrían contenidos los datos y un estatus (status) que indica si fue exitosa la solicitud.
2. Si el estatus es OK procedemos, si no, mandamos un mensaje de error diciendo que no se pudo encontrar ruta entre ambos puntos. Existe una serie de estatus distintos, sin embargo y para efectos prácticos solamente usamos aquí el OK (para ver más tipos de status, hay que ir directamente a la documentación de la API).
3. directionsDisplay.setMap(map) establece el mapa sobre el cuál será trazada la ruta, la variable map debe ser un objeto tipo Mapa, además de global.
4. directionsDisplay.setPanel($(“#panel_ruta”).get(0)) indica dónde van a ser escritas las indicaciones de la ruta, aquí es necesario indicar un div disponible (panel_ruta).
5. directionsDisplay.setDirections(response) hace la magia, imprime en el mapa la ruta y escribe las indicaciones de acuerdo a las 2 instrucciones anteriores.

Por último solamente creamos un par de funciones para que al hacer click en el botón busque la ruta o la redibuje si se eligen diferentes opciones, esto es opcional, si no lo quieren así hay que hacer que indicar que al hacer click, la función central se ejecute, para mi caso, la función la llamé rockAndRoll  😀

$('#buscar').live('click', function(){
	rockAndRoll();
});

$('.opciones_ruta').live('change', function(){
	rockAndRoll();
});

Es todo por esta ocasión, espero les ayude en sus proyectos o simplemente para jugar un rato, si quieren verlo en función denle click en el botón verde, dudas y comentarios son bien recibidos, o pueden encontrarme en twitter @jafrancov

Enjoy this Life!!

Ya hemos visto el cómo obtener geolocalización para ubicar el lugar donde nos encontramos, pero, ¿qué pasa cuando buscamos una dirección diferente a donde nos encontramos?, sería necesario escribir y buscar la dirección deseada, bien pues el proceso es relativamente sencillo. (Para esto requeriremos que agregues los scripts de GMaps y de jQuery, consulta los anteriores post si tienes duda de esto).

Lo que haremos se resume en: escribir una dirección, verificar si existe, si existe, colocar un marcador, centrar y dar zoom en el mapa en la región de la dirección obtenida, si no existe la dirección arrojar un error diciendo que no existe.

La parte importante del código es generar un objeto que nos permita comunicarnos con la API  de Google Maps y nos convierta la dirección en latitud y longitud de manera que podamos maniobrarlas a placer.

var geocoder = new google.maps.Geocoder();

Cuando se genera una petición de Geocoding, pueden enviarse varios parámetros para obtener resultados más específicos, un objeto de solicitud completa comprendería:

• address (obligatorio *): es la dirección que deseas codificar de forma geográfica.
• latLng (obligatorio *): la latitud y la longitud (LatLng ) para las que deseas obtener la dirección interpretable por humanos más cercana.
• bounds (opcional): los límites de latitud y de longitud (LatLngBounds) dentro de los que quieres predeterminar los resultados de codificación geográfica con mayor importancia. Para obtener más información, consulta la sección Especificación de la ventana gráfica que encontrarás a continuación.
• language (opcional): es el idioma en el que se devuelven los resultados.
• region (opcional): el código de región, especificado como una subetiqueta region del lenguaje IANA. En la mayoría de los casos, estas etiquetas se asignan directamente a valores de dos caracteres ccTLD (“dominio de nivel superior”) ya conocidos. Para obtener más información, consulta la sección Especificación del código de región que encontrarás a continuación.

* Nota: la búsqueda funciona incluyendo solamente el campo address, aunque siempre es requisito incluir un campo address o un campo latLng obligatoriamente, si se coloca un campo latLng, el geocoder realizará el proceso conocido como codificación geográfica inversa, o sea, convertir coordenadas en direcciones, pero, eso lo veremos en otro post.

La solicitud se hace de la siguiente manera:

// Obtenemos la dirección y la asignamos a una variable
var address = $('#address').val();
// Creamos el Objeto Geocoder
var geocoder = new google.maps.Geocoder();
// Hacemos la petición indicando la dirección e invocamos la función
// geocodeResult enviando todo el resultado obtenido
geocoder.geocode({ 'address': address}, geocodeResult);

El objeto que se obtiene de respuesta es un JSON, donde lo manejaríamos como regularmente se hace en javascript, el resultado es algo como esto:

{
  "status": "OK",
  "results": [ {
    "types": [ "street_address" ],
    "formatted_address": "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
    "address_components": [ {
      "long_name": "1600",
      "short_name": "1600",
      "types": [ "street_number" ]
    }, {
      "long_name": "Amphitheatre Pkwy",
      "short_name": "Amphitheatre Pkwy",
      "types": [ "route" ]
    }, {
      "long_name": "Mountain View",
      "short_name": "Mountain View",
      "types": [ "locality", "political" ]
    }, {
      "long_name": "California",
      "short_name": "CA",
      "types": [ "administrative_area_level_1", "political" ]
    }, {
      "long_name": "United States",
      "short_name": "US",
      "types": [ "country", "political" ]
    }, {
      "long_name": "94043",
      "short_name": "94043",
      "types": [ "postal_code" ]
    } ],
    "geometry": {
      "location": {
        "lat": 37.4219720,
        "lng": -122.0841430
      },
      "location_type": "ROOFTOP",
      "viewport": {
        "southwest": {
          "lat": 37.4188244,
          "lng": -122.0872906
        },
        "northeast": {
          "lat": 37.4251196,
          "lng": -122.0809954
        }
      }
    }
  } ]
}

Lo único que nos faltaría es el código para validar, interpretar y dibujar. Para esto, hay 3 cosas importantes que debemos tomar en cuenta del JSON que tenemos de respuesta:

• status: contiene la respuesta del estado de la petición, si fue satisfactoria o si hubo algún error y que tipo de error.
• geometry.location: la ubicación de la dirección solicitada
• geometry.viewport: los límites recomendados para ajustar el zoom del mapa, haciendo un cuadrante con las esquinas Noreste (superior derecha) y Suroeste (inferior izquierda).

Con esto en presente, la función siguiente nos mostrará solamente el primer resultado obtenido, quedando así :

function geocodeResult(results, status) {
    // Verificamos el estatus
    if (status == 'OK') {
        // Si hay resultados encontrados, centramos y repintamos el mapa
        // esto para eliminar cualquier pin antes puesto
        var mapOptions = {
            center: results[0].geometry.location,
            mapTypeId: google.maps.MapTypeId.ROADMAP
        };
        map = new google.maps.Map($("#map_canvas").get(0), mapOptions);
        // fitBounds acercará el mapa con el zoom adecuado de acuerdo a lo buscado
        map.fitBounds(results[0].geometry.viewport);
        // Dibujamos un marcador con la ubicación del primer resultado obtenido
        var markerOptions = { position: results[0].geometry.location }
        var marker = new google.maps.Marker(markerOptions);
        marker.setMap(map);
    } else {
        // En caso de no haber resultados o que haya ocurrido un error
        // lanzamos un mensaje con el error
        alert("Geocoding no tuvo éxito debido a: " + status);
    }
}

Y listo con esto tenemos terminado nuestro ejercicio, puedes verificarlo en funcionamiento en la página de demos:

El código completo quedaría así:

$(document).ready(function() {
    load_map();
});

var map;

function load_map() {
    var myLatlng = new google.maps.LatLng(20.68009, -101.35403);
    var myOptions = {
        zoom: 4,
        center: myLatlng,
        mapTypeId: google.maps.MapTypeId.ROADMAP
    };
    map = new google.maps.Map($("#map_canvas").get(0), myOptions);
}

$('#search').live('click', function() {
    // Obtenemos la dirección y la asignamos a una variable
    var address = $('#address').val();
    // Creamos el Objeto Geocoder
    var geocoder = new google.maps.Geocoder();
    // Hacemos la petición indicando la dirección e invocamos la función
    // geocodeResult enviando todo el resultado obtenido
    geocoder.geocode({ 'address': address}, geocodeResult);
});

function geocodeResult(results, status) {
    // Verificamos el estatus
    if (status == 'OK') {
        // Si hay resultados encontrados, centramos y repintamos el mapa
        // esto para eliminar cualquier pin antes puesto
        var mapOptions = {
            center: results[0].geometry.location,
            mapTypeId: google.maps.MapTypeId.ROADMAP
        };
        map = new google.maps.Map($("#map_canvas").get(0), mapOptions);
        // fitBounds acercará el mapa con el zoom adecuado de acuerdo a lo buscado
        map.fitBounds(results[0].geometry.viewport);
        // Dibujamos un marcador con la ubicación del primer resultado obtenido
        var markerOptions = { position: results[0].geometry.location }
        var marker = new google.maps.Marker(markerOptions);
        marker.setMap(map);
    } else {
        // En caso de no haber resultados o que haya ocurrido un error
        // lanzamos un mensaje con el error
        alert("Geocoding no tuvo éxito debido a: " + status);
    }
}

Y en el Body solamente esto:

<div><input type="text" maxlength="100" id="address" placeholder="Dirección" /> <input type="button" id="search" value="Buscar" /></div><br/>
<div id='map_canvas' style="width:600px; height:400px;"></div>

Espero les sirva y cualquier cosa, ya saben cómo contactarme…

Enjoy this Life!