La prestigiosa empresa Realce Online eMarketing y Diseño lanza un nuevo curso de desarrollo y diseño de aplicaciones multimedia con la tecnología flash 8.

Es un curso completamente online del que los estudiantes podrán convalidar hasta 5 créditos de libre configuración en la Universidad de Huelva.

Ni que decir tiene que todo programador debe saber todo tipo de tecnologías y también diseñar. Con éste curso conseguirá dar el salto definitivo de calidad que necesita y podrán ampliar su abanico de posibilidades laborales.

Curso de Introducción al Diseño Multimedia Con Flash 8

Objetivos del Curso de Introducción al Diseño Multimedia con Flash 8

El Curso está indicado para todos aquellos usuarios que desean aprender a crear presentaciones multimedia avanzadas para la web y el mundo de Internet principalmente.

Tanto para los usuarios más experimentados como para los noveles, el objetivo final del Curso de Flash 8 es el mismo: Un profundo conocimiento teórico/práctico de Flash 8, que permita emprender proyectos profesionales de envergadura, con garantías de éxito.

¿A quién va dirigido este curso?

El Curso Flash 8 on-line está dirigido a:

Estudiantes que pretendan ampliar sus conocimientos en entornos multimedia

Desarrolladores de sitios Web.

Diseñadores gráficos.

Usuarios de antiguas versiones de Flash.

Desarrolladores Multimedia

Programadores en entornos gráficos.

En cualquier caso, el curso no requiere un conocimiento previo ya que abarca desde los principales conocimientos teóricos a técnicas avanzadas para alcanzar resultados pero detalladamente explicadas, en un incremento del nivel paulatino para que puedan realizarlas los alumnos que no tengan experiencia anterior en Flash 8 o alguna versión anterior o posterior.

Duración y Evaluación

La duración del curso suponen 75 horas, y su desarrollo tiene lugar en una de aprendizaje, donde el alumno cuenta con plena libertad horaria, lo adaptarse a las necesidades del alumno.

Las 75 horas lectivas se pueden repartir a lo largo de 2,5 meses aproximadamente, de Marzo de 2009 a 1 de Junio de 2009, fecha límite para entregar la practica evaluada, conjuntamente con el aprovechamiento del periodo lectivo de forma evaluar finalmente al alumno con una calificación en una escala de 0 a 10.

Créditos de libre configuración

Si eres estudiante de la UHU podrás, con el certificado de haber aprobado el curso, convalidar hasta 5 créditos para lo que tienes que dirigirte a secretaria, solicitar la convalidación y abonar las tasas (30% del precio normal del crédito).

Matriculación

Para matricularte puedes seguir las instrucciones que encontraras  visitando la web:

http://www.cursostecnologicos.com

Saludos y espero que la información sea de su agrado.

En primer lugar deberíamos definir formal y brevemente qué es y para que sirven los proveedores de perfiles en ASP.NET y como están realizados por dentro.

Los proveedores de perfiles, sin querer entrar en mucho detalle, engloban una serie de funcionalidad específica, para guardar datos de un posible perfil de un usuario de un sitio Web. Entre estos datos, los más comunes son por ejemplo: el tema de la página que tiene seleccionado, el nombre, apellidos, edad, y todas las preferencias que se nos ocurran.

Este proveedor de perfiles, por defecto, está implementado para que guarde los datos en la base de datos por defecto de ASP.NET, la base de datos de SQL Server ASPNETDB, y de esta limitación, nos viene al caso este post.

Existen muchas ocasiones en las que no usamos sql Server por especificaciones del diseño y tenemos que usar otro motor de base de datos distinto, o queremos ampliar esa funcionalidad que ya trae para que además de guardar en la bbdd por defecto de sql Server, guarde otros datos en otras tablas de nuestra base de datos propia. En fin, se me ocurren multitud de escenarios en los que sería beneficioso poder agregar funcionalidad o cambiarla por completo para adecuar el adaptador de perfiles a nuestras necesidades.

Gracias a que el proveedor de perfiles por defecto de Microsoft ASP.NET está basado en el patrón “Strategy”, que a groso modo dice que para resolver un problema determinado (en nuestro caso guardar preferencias de nuestros usuarios para mas tarde aplicarlas cuando vuelva al sitio) se le puede conectar diferentes algoritmos , según nos convenga. Cualquier programa que ofrezca un servicio o función determinada, que pueda ser realizada de varias maneras, es candidato a utilizar el patrón Strategy. Puede haber cualquier número de estrategias y cualquiera de ellas podrá ser intercambiada por otra en cualquier momento, incluso en tiempo de ejecución.

Después de esta pequeña introducción me voy a referir al motivo de este post, que es crear un proveedor de perfiles que en vez de guardar los datos en una base de datos, pueda guardarlos en una cookie, para luego volver a recuperarlos en posteriores ocasiones siempre que la cooki siga existiendo.

1º En primer lugar, lo que vamos a hacer es crear un proyecto classlibrary con Visual Studio.

Borramos la clase que nos viene por defecto y creamos una que se llame ProfileCookieProvider y que herede de ProfileProvider.

class ProfileCookie:ProfileProvider

2º Luego sobrescribimos todos los métodos de la clase de la que heredamos.

public override int DeleteInactiveProfiles(ProfileAuthenticationOption authenticationOption, DateTime userInactiveSinceDate)

{

throw new NotImplementedException();

}

public override int DeleteProfiles(string[] usernames)

{

throw new NotImplementedException();

}

public override int DeleteProfiles(ProfileInfoCollection profiles)

{

throw new NotImplementedException();

}

public override ProfileInfoCollection FindInactiveProfilesByUserName(ProfileAuthenticationOption authenticationOption, string usernameToMatch, DateTime userInactiveSinceDate, int pageIndex, int pageSize, out int totalRecords)

{

throw new NotImplementedException();

}

public override ProfileInfoCollection FindProfilesByUserName(ProfileAuthenticationOption authenticationOption, string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)

{

throw new NotImplementedException();

}

public override ProfileInfoCollection GetAllInactiveProfiles(ProfileAuthenticationOption authenticationOption, DateTime userInactiveSinceDate, int pageIndex, int pageSize, out int totalRecords)

{

throw new NotImplementedException();

}

public override ProfileInfoCollection GetAllProfiles(ProfileAuthenticationOption authenticationOption, int pageIndex, int pageSize, out int totalRecords)

{

throw new NotImplementedException();

}

public override int GetNumberOfInactiveProfiles(ProfileAuthenticationOption authenticationOption, DateTime userInactiveSinceDate)

{

throw new NotImplementedException();

}

public override string ApplicationName

{

get

{

throw new NotImplementedException();

}

set

{

throw new NotImplementedException();

}

}

public override System.Configuration.SettingsPropertyValueCollection GetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyCollection collection)

{

throw new NotImplementedException();

}

public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection)

{

throw new NotImplementedException();

}

3º Declaramos las variables y propiedades de la clase

class ProfileCookie:ProfileProvider

{

// Declaramos las variables

private string _Nombrecookie;

public string Nombrecookie

{

get { return _Nombrecookie; }

set { _Nombrecookie = value; }

}

private int _ExpiracionCookie;

public int ExpiracionCookie

{

get { return _ExpiracionCookie; }

set { _ExpiracionCookie = value; }

}

private string _appNombre;

public string AppNombre

{

get { return _appNombre; }

set { _appNombre = value; }

}

4º Creamos el procedimiento de inicialización del proveedor, donde se le pasará un parámetro name con el nombre del proveedor y un parámetro namevaluedcollection “config” que contendrá todos los atributos del proveedor que se encuentran en el archovo de configuración Web.config de la aplicación que usa el proveedor.

public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config)

{

// Comprobar que el proveedor tiene un nombre

if(string.IsNullOrEmpty(name))

{

name= “ProfileCookieProvider”;

}

// Inicializar el método de la clase base

base.Initialize(name, config);

// Leemos el nombre de la aplicacion

_appNombre = config["aplicationName"];

if (string.IsNullOrEmpty(_appNombre))

{

_appNombre = System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath;

}

//Leemos el nombre de la cookie

_Nombrecookie = config["cookieName"];

if (string.IsNullOrEmpty(_Nombrecookie))

{

_Nombrecookie = “.Perfil”;

}

//Eliminamos el nombre de la cookie

config.Remove(“cookieName”);

// Leemos la duración de la cookie

bool sucess = Int32.TryParse(config["cookieName"], out _ExpiracionCookie);

if (!sucess)

{

_ExpiracionCookie = 10;

}

config.Remove(“cookieExpires”);

// Lanzamos una excepcion si hay algún atributo desconocido

if (config.Count > 0)

{

string atributo = config.GetKey(0);

if (!string.IsNullOrEmpty(atributo))

{

throw new ProviderException(“Atributo no reconocido : “ + atributo);

}

}

}

5º No vamos a implementar todos los métodos heredados de la clase base, lanzando un error en todas las que no implementemos.

throw new NotImplementedException();

6º Implementamos el método GetPropertyValues que devolverá el contenido del perfil del usuario. Se leerán los datos desde el almacén de datos, en este caso desde la cookie, y se devuelve en una colección de valores.

public override System.Configuration.SettingsPropertyValueCollection GetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyCollection collection)

{

System.Configuration.SettingsPropertyValueCollection settings;

settings = new System.Configuration.SettingsPropertyValueCollection();

if (collection.Count == 0)

return settings;

// Añadimos todas las porpiedades a la colección de salida,

// Garantizando que se van a crear dichas entradas en el objeto profil

foreach (System.Configuration.SettingsProperty property in collection)

{

System.Configuration.SettingsPropertyValue pv = new System.Configuration.SettingsPropertyValue(property);

settings.Add(pv);

}

// Leemos la cookie si existe

string username = (string)context["UserName"];

string cookie = Nombrecookie + ” “ + username;

System.Web.HttpCookie cookieprofile = System.Web.HttpContext.Current.Request.Cookies[cookie];

if (cookieprofile == null)

{

return settings;

}

// Descodificación en Base64 y deserialización binaria

string data = cookieprofile["SerializedData"];

byte[] bits = Convert.FromBase64String(data);

System.Collections.Hashtable table = null;

using (System.IO.MemoryStream mem = new System.IO.MemoryStream(bits))

{

System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bin;

bin = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

table = (System.Collections.Hashtable)bin.Deserialize(mem);

mem.Close();

}

// Añadimos los datos a las propiedades

foreach (System.Configuration.SettingsPropertyValue spv in settings)

{

spv.Deserialized = true;

spv.PropertyValue = table[spv.Name];

}

return settings;

}

7º Implementamos el método SetPropertyValues, que guardará el contenido de perfil del usuario al final de cada solicitud.

/// <summary>

/// Guarda el contenido de collection en una cookie

/// </summary>

/// <param name=”context”>Información contextual</param>

/// <param name=”collection”>Colección de propiedades a guardar en la cookie</param>

public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection)

{

// Obtengo información sobre el usuario

string username = (string)context["UserName"];

bool autenticado = (bool)context["IsAuthenticated"];

// Si no hay propiedades terminamos

if (String.IsNullOrEmpty(username) || collection.Count == 0)

{ return; }

// Preparo la Cookie

string cookie = Nombrecookie + “_” + username;

System.Web.HttpCookie cookiePerfil = System.Web.HttpContext.Current.Request.Cookies[cookie];

if (cookiePerfil == null)

{

cookiePerfil = new System.Web.HttpCookie(cookie);

}

cookiePerfil.Expires = DateTime.Now.AddMinutes(ExpiracionCookie);

// Preparo los datos para guardar en la cookie

System.Collections.Hashtable tabla = new System.Collections.Hashtable();

foreach (System.Configuration.SettingsPropertyValue pp in collection)

{

if (!autenticado && !(bool)pp.Property.Attributes["AllowAnonymous"])

{

continue;

}

tabla.Add(pp.Name, pp.PropertyValue);

}

// Codificar y escribir la tabla hash para la cookie

System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bin;

bin = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

System.IO.MemoryStream mem = new System.IO.MemoryStream();

bin.Serialize(mem, tabla);

string data = Convert.ToBase64String(mem.GetBuffer(), 0, (int)mem.Length);

cookiePerfil["SerializedData"] = data;

// Guardar en la cookie

System.Web.HttpContext.Current.Response.AppendCookie(cookiePerfil);

}

Ahora generamos el proyecto y nos crea una dll que es la que tendremos que usar en nuestro proyecto ASP.NET, que junto con unas configuraciones en el Web.config de nuestra aplicación harán posible el uso de perfiles de usuarios almacenados en cookies.

Esto lo explicaré en el siguiente artículo ya que éste se ha extendido demasiado.

Espero que os haya sido útil esta información y que le saquéis provecho.

Hasta pronto.

Buenas, hoy voy a poner un pequeño apunte por si a alguien pudiese interesarle y para no olvidarme de él para el futuro.

Resulta que el otro día preguntaban en el Foro de MSDN España cómo hacer que cambie el estilo de un botón cuando obtiene el foco sin tener que recargar toda la página y sin usar AJAX por exigencias del servidor.

Entonces la solución fue esta:

Nos vamos al cóodigo HTML de la página y añadimos un text box y un botón

<asp:TextBox ID=”TextBox1″ runat=”server”></asp:TextBox>
<asp:Button ID=”Button1″ runat=”server” Text=”Button” />

en el head de esta página creamos la siguiente función javascript :

<script language=”javascript” type=”text/javascript”>
function cambiarEstilo(){
document.getElementById(’Button1′).style.backgroundColor =’#FFAAFF’;
}
</script>

y por último en el page load de la página o donde nos convenga añadimos un atributo al botón de forma que el evento onfocus llame a la función de la siguiente manera :

Button1.Attributes.Add(”onfocus”, “javascript:cambiarEstilo();”);

y listo, de esta manera, cuando estemos ejecutando la página pinchamos en el textbox y le damos al tabulador para que el foco se ponga en el botón y veremos el que fondo se cambia de color automáticamente.

Es lógico pensar que puedes cambiar cualquier cosa del botón desde javascript.

Sin más, espero que os haya sido interesante.

Hasta la próxima !!

Como muestra un Botón :

Buenas, hoy voy a escribir como crear un informe, en este caso una factura de un pedido de una tienda virtual, en PDF con la tecnología de Microsoft ASP.NET 2.0 y una librería existente de código abierto que se llama Gios.PDF.

Comenzamos :

Antes que nada, decir que es una librería gratuita que podemos descargar el código fuente y revisarlo. Debemos agregar las DLL en el directorio BIN de nuestra aplicación.

Vamos con el código…

Lo primero que debemos crear es el documento PDF donde vamos a meter todos los datos de la factura.

PdfDocument myPdfDocument = new PdfDocument( PdfDocumentFormat.InCentimeters( 21, 29.7));

La enumeración PdfDocumentFormat indica el tamaño del documento que vamos a crear. Tiene varias opciones como son A4, A4 Horizontal, letter8,5*11

En nuestro caso, le hemos indicado el tamaño por centímetros, ya que el PDF es un formato de impresión y no dependerá de la resolución de la pantalla.

A continuación creamos una tabla donde vamos a meter el desglose de la factura :

PdfTable myPdfTable = myPdfDocument.NewTable( new Font(“Verdana”, 12), DatosDesglose.Rows.Count, 3, 4);

A la tabla le indicamos que tenemos tantas filas como tiene el datatable, las columnas se las inndicamos manualmente ya que son fijas y le damos un cellPadding de 4.

Datos desglose es un DataTable que he rellenado anteriormente con los datos del pedido realizado.

DataTable desglose

{

get

{

// Creo el DataTable

DataTable dt = new DataTable();

// Le asigno las columnas

dt.Columns.Add(“Concepto”);

dt.Columns.Add(“Precio”);

dt.Columns.Add(“cantidad”);

// Obtengo los productos del pedido

DsProductosTableAdapters.Obtener_productos_pedidoTableAdapter TAProdPed =

new DsProductosTableAdapters.Obtener_productos_pedidoTableAdapter();

DsProductos.Obtener_productos_pedidoDataTable DTProd = TAProdPed.GetData( Int32.Parse(idped));

// Recorro los productos y los añado al DataTable creado anteriormente

foreach (DsProductos.Obtener_productos_pedidoRow prod in DTProd.Rows)

{

DataRow dr = dt.NewRow();

dr[0] = prod.nombre;

dr[1] = prod.precio.ToString() + “€”;

dr[2] = prod.cantidad.ToString();

dt.Rows.Add(dr);

}

}

// Devuelvo el datatable relleno con los datos de los productos del pedido

return dt;

}

Continuamos creando el PDF…

// Importamos los datos de los datatables con las cabeceras incluidas

myPdfTable.ImportDataTable(DatosDesglose);

Le damos un poco de diseño visual a la tabla de desglose :

// Color de la cabecera

myPdfTable.HeadersRow.SetColors(Color.White, Color.Navy);

// Especificamos el color de las letras, el color de fondo y el color de fondo de las filas alternadas

myPdfTable.SetColors(Color.Black, Color.White, Color.Gainsboro);

// Establecemos el color del borde y el grosor del mismo diciendole que lo aplique a todo el grid

myPdfTable.SetBorders(Color.Black, 1, BorderType.CompleteGrid);

Asignamos el ancho de las columnas

myPdfTable.SetColumnsWidth(new int[] { 80, 20 });

El ancho de las columnas no tiene que sumar 100, sino que es un ancho relativo dentro del documento. No es muy intuitivo y suele pasar que haya que hacer varias proebas hasta que las columnas se ajustan correctamente como queremos.

Comentar que se puede tener un número de columnas en el SetColumnsWidth inferior o igual al total de columnas de la tabla, y nunca superior, ya que si lo superamos, darña un error en tiempo de ejecución que te puede volver un poco loco.

Ahora creamos otra tabla de pdf para rellenarla con los datos de la empresa que emite la factura.

// DATOS DE la empresa en CABECERA

PdfTable TablaDanosNacho = myPdfDocument.NewTable( new Font(“Verdana”, 12), 4, 2, 4);

TablaDanosNacho.HeadersRow.SetColors(Color.White, Color.BurlyWood);

Damos una alineación al contenido

TablaDanosNacho.SetContentAlignment(ContentAlignment.MiddleCenter);

Le decimos que la columna 1 deberá tener el contenido en el centro a la izquierda

TablaDanosNacho.Columns[1].SetContentAlignment(ContentAlignment.MiddleLeft);

TablaDanosNacho.ImportDataTable(DataEmpresa);

TablaDanosNacho.SetColumnsWidth(new int[] { 20, 80 });

TablaDanosNacho.SetBorders(Color.Black, 1, BorderType.Bounds);

Unimos las celdas de las columnas con esta instrucción

TablaDanosNacho.HeadersRow.MergeCells();

Le asignamos a la cabecera un titular

TablaDanosNacho.HeadersRow.SetContent(“DATOS DE LA EMPRESA.”);

La variable DataEmpresa la rellenamos de la siguiente manera :

DataTable DataNacho

{

get

{

// Creamos el Datatable

DataTable dt = new DataTable();

// Creamos las dos columnas sin texto que luego unimos en el PDFTable y le asignamos un texto

dt.Columns.Add(“”);

dt.Columns.Add(“”);

// Creamos una fila y le asignamos el nombre

DataRow dr = dt.NewRow();

dr[0] = “Nombre”;

dr[1] = “Realce Online eMarketing y Diseño”;

dt.Rows.Add(dr);

// Otra fila y le asignamos el DNI

DataRow dr1 = dt.NewRow();

dr1[0] = “DNI”;

dr1[1] = “22.345.543K”;

dt.Rows.Add(dr1);

// Otra fila con la Dirección

DataRow dr2 = dt.NewRow();

dr2[0] = “Dirección”;

dr2[1] = “C/ La Quito 17 6º A”;

dt.Rows.Add(dr2);

// Y Otra fila con el resto de datos

DataRow dr3 = dt.NewRow();

dr2[0] = “CP.- “;

dr2[1] = “28015 Localidad: Huelva Provincia: Huelva”;

dt.Rows.Add(dr3);

// Devuelvo el dataTable Relleno

return dt;

}

}

Ahora creamos otra tabla con los datos del Cliente

// DATOS DEL CLIENTE

PdfTable TablaDanosCliente = myPdfDocument.NewTable( new Font(“Verdana”, 12), 3, 2, 4);

TablaDanosCliente.HeadersRow.SetColors( Color.White, Color.BurlyWood);

TablaDanosCliente.SetContentAlignment( ContentAlignment.MiddleCenter);

TablaDanosCliente.ImportDataTable( DatosCliente);

TablaDanosCliente.SetColumnsWidth(new int[] { 20, 80 });

TablaDanosCliente.SetBorders(Color.Black, 1, BorderType.Bounds);

TablaDanosCliente.HeadersRow.MergeCells();

TablaDanosCliente.HeadersRow.SetContent(“DATOS DEL CLIENTE.”);

En este código no hay nada nuevo, y basta con decir que el DataTable DatosCliente es rellenado de la misma forma que DatosEmpresa pero con los datos del cliente obtenidos de la base de datos que estemos usando.

A continuación Creamos el resto de tablas de los importes totales con y sin los IVA y la tabla de la fecha de la factura y el número de factura obligatorios en toda factura que se precie.

// DATOS FINALES

PdfTable TablaDanosFinales = myPdfDocument.NewTable( new Font(“Verdana”, 12), 1, 3, 4);

TablaDanosFinales.HeadersRow.SetColors( Color.White, Color.BurlyWood);

TablaDanosFinales.SetContentAlignment( ContentAlignment.MiddleCenter);

TablaDanosFinales.ImportDataTable( DatosFinales);

TablaDanosFinales.SetColumnsWidth( new int[] { 40, 20, 40 });

TablaDanosFinales.SetBorders( Color.Black, 1, BorderType.Bounds);

// DATOS FECHA

PdfTable TablaDanosFecha = myPdfDocument.NewTable( new Font(“Verdana”, 12), 2, 2, 4);

TablaDanosFecha.HeadersRow.SetColors(Color.White, Color.BurlyWood);

TablaDanosFecha.SetContentAlignment(ContentAlignment.MiddleCenter);

TablaDanosFecha.ImportDataTable(DatosFecha);

TablaDanosFecha.SetColumnsWidth(new int[] { 40, 40 });

TablaDanosFecha.SetBorders(Color.Black, 1, BorderType.Bounds);

TablaDanosFecha.VisibleHeaders = false;

Ahora vamos a cargar una imagen corporativa en el documento para que de sensación de corporatividad y de empresa seria.

PdfImage Logo = myPdfDocument.NewImage( HttpContext.Current.Server.MapPath(“~/imagenes/globo.jpg”));

Debe ser una imagen JPG ya que no acepta esta versión otro formato, aunque estoy seguro que en la versión 2.0 que se está preparando (no se si ya existe) de esta librería vendrá implementada muchas mejoras.

Ahora lleha la parte delicada de esta pelicula.

Tenemos que realizar un bucle para ir generando el PDF con los datos de las tablas que hemos ido creando anteriormente y posicionarlas de forma relativa en el documento.

// Here comienza el bucle para generar la tabla

while (!myPdfTable.AllTablePagesCreated)

{

// Generamos una nueva página en el documento que albergará las tablas anteriores

PdfPage newPdfPage = myPdfDocument.NewPage();

// Generamos una nueva página de tablas en el documento, indicandole la posición que llevará en el documento

PdfTablePage newPdfTablePage =

myPdfTable.CreateTablePage(new PdfArea(myPdfDocument, 48, 300, 500, 670));

// CREO LA TABLA DE LOS DATOS DE LA EMPRESA

PdfTablePage newPdfTablePage2 =

TablaDanosNacho.CreateTablePage(new PdfArea(myPdfDocument, 20, 20, 260, 100));

// CREO LA TABLA DEl CLIENTE

PdfTablePage newPdfTablePage3 =

TablaDanosCliente.CreateTablePage(new PdfArea(myPdfDocument, 20, 150, 260, 200));

// CREO LA TABLA DE FECHA Y Nº FACTURA

PdfTablePage newPdfTablePage5 =

TablaDanosFecha.CreateTablePage(new PdfArea(myPdfDocument, 300, 20, 150, 150));

// AGREGAMOS LOS OBJETOS A LA PAGINA PDF CREADA AL INICIO DEL BUCLE

newPdfPage.Add(Logo, 460, 20);

newPdfPage.Add(newPdfTablePage);

newPdfPage.Add(newPdfTablePage2);

newPdfPage.Add(newPdfTablePage3);

newPdfPage.Add(newPdfTablePage5);

if (myPdfTable.AllTablePagesCreated)

{

PdfTablePage newPdfTablePage4 =

TablaDanosFinales.CreateTablePage( new PdfArea( myPdfDocument, 120, 700, 300, 80));

newPdfPage.Add(newPdfTablePage4);

}

}// Fin del bucle

Guardamos los cambios en el documento

newPdfPage.SaveToDocument();

Ahora exportamos el fichero,

documentofactura.SaveToFile( HttpContext.Current.Server.MapPath(“~/Public/factura.pdf”));

Podemos guardar en un fichero físico en nuestro servidor o podemos ponerlo a descarga directa en el navegador.

Yo en mi caso, lo he guardado en un fichero fisico, que luego leo y envio por correo electrónico (donde no voy a entrar en este artículo, ya hablaremos de ello más adelante)

FileStream fich = File.Open( HttpContext.Current.Server.MapPath(“~/Public/factura.pdf”), FileMode.Open);

Creo mi objeto de la clase que envia el correo

Mail MailSender = new Mail();

Creo el cuerpo del mensaje

string body = “<html><body>Estimado usuario, adjunto se le envía la factura de su pedido. Si detecta algún fallo o anomalía contacte con la redacción a través de la web <a href=\”http://www.realceonline.com\”>AeRoLoCoS.eS. Gracias por la compra.</a></body></html>”;

Llamo a la función que envía el pdf adjunto al mail del usuario que ha realizado el pedido

MailSender.enviarMailPdfAdjunto(fich, “correoFROM@dominio”, email, “Factura de compra en www.realceonline.com”, body, “loginmailsmtp”, “passmailsmtp”);

Una vez enviado el fichero lo libero y lo elimino

fich.Close();

fich.Dispose();

File.Delete(HttpContext.Current.Server.MapPath(“~/Public/factura.pdf”));

Ahora lo que hago es poner el documento generado anteriormente en descarga directa en el navegador

//Descargo la factura

HttpContext.Current.Response.ClearHeaders();

HttpContext.Current.Response.AppendHeader(“Content-disposition”,

string.Format(“attachment;filename={0}”, “Factura.pdf”));

Le indico al navegador que le voy a enviar datos de tipo de aplicación PDF para que reconozca con que programa asociarlo

HttpContext.Current.Response.ContentType = “application/pdf”;

Le indico el tipo de codificación

HttpContext.Current.Response.Charset = “UTF-8″;

HttpContext.Current.Response.ContentEncoding = System.Text.Encoding.Default;

Devuelvo el fichero PDF generado como un Stream en memoria y se lo asocio al OutputStream de lo que voy a delvolver al navegador documentofactura.SaveToStream(HttpContext.Current.Response.OutputStream);

Finalizo la operación

HttpContext.Current.Response.End();

Generación de PDF con ASP.NET. Desarrollo y diseño Web a medida.

Hace cosa de 1 año, descubrí un framework para realizar cosas al estilo AJAX en mis proyectos con ASP.NET. Este framework permite mostrar espectaculares pop-ups con imágenes y grupos de imágenes. Consiste en cargar una serie de ficheros de Script (JavaScript) y CSS en el código de nuestra página, que te permitirán poder mostrar una ventana por encima de la página contenedora, de forma que todo el contenido quede bloqueado centrándose en la ventana que se ha superpuesto.

Visor de Imágenes y popup de formularios son los casos de uso típicos en los que suelo usarlo.

Permite mostrar espectaculares pop-ups con imágenes y grupos de imágenes.

Las instrucciones para usarlo son las siguientes:

Para abrir una ventana en modo popup con esta librería :

Descargar las librerías de aqui

Crear un HTML con el siguiente código en la cabecera:

<head>

<title>AJAX con LIGHTBOX</title>

<!—aquí se carga la hoja de estilos que propicia el efecto background –>

<link rel=”stylesheet” href=”css/lightbox.css” type=”text/css” media=”screen” />

<!—Aquí se cargan los 3 Javascripts que son necesarios para ejecutar el framework –>

<script src=”js/prototype.js” type=”text/javascript”></script>

<script src=”js/scriptaculous.js?load=effects” type=”text/javascript”></script>

<script src=”js/lightbox.js” type=”text/javascript”></script>

</head>

Mucho cuidado en este paso al poner las rutas tanto del fichero externo lightbox.css como el de los scripts ya que si nos equivocamos en la ruta, no funcionará ya que no encontrará los scripts a ejecutar (obvio)

En el body de la página creada anteriormente escribimos un enlace a la página que queremos mostrar como popup, con el atributo rel correspondiente

<a href=”default.aspx” rel=”lightbox_text”>Ver página popup</a>

Guardamos el Fichero creado y lo ejecutamos en el navegador.

Este debe ser el resultado Final

No está nada mal el efecto, pero lo bueno de todo esto es que se puede adaptar a nuestras necesidades solo sabiendo un poco de Javascript y cacharreando un poco. Como muestra un botón.

La librería, por defecto, te crea un botón que te cierra la ventana popup, pero si queremos crear otro botón un poco más intuitivo, lo que debemos hacer es solo que en el evento click de ese botón de cerrar, ejecute la instrucción javascript : javascript:myLightbox.end(); return false;

En mi caso, al ser un botón de ASP.NET, se puede realizar de la siguiente manera:

<asp:Button ID=”btnCancelarVotar” OnClientClick=”javascript:myLightbox.end(); return false;” runat=”server” Text=”Cancelar” />

Este es el efecto final :

Esta puede ser la revolución que el mercado estaba esperando…. A través del cuero cabelludo se recogen los estímulos nerviosos de las partes del cerebro encargadas de ciertas funciones y mediante un procesador, se convierten en instrucciones maquina.

Me imagino que cuando esto salga a la luz, el desarrollo de interfaces hombre-maquina evoloucionará considerablemente, sobretodo para sectores como los videojuegos de realdad virtual y de discapacitados.

Un bomba.

fuente : http://weblogs.madrimasd.org/sistemas_inteligentes/archive/2008/06/16/94725.aspx

 

Buenas, quería presentarme primero para que mis lectores puedan conocer a quien leen. Soy nuevo en esto de los blogs y poco a poco iré cogiendo soltura. En primer lugar mi nombre es Joaquín Salguero y vivo en Huelva. Estudié Ingeniería técnica de informática de sistemas en la escuela politécnica superior de la Rábida en Palos de la Frontera, Huelva. Durante la carrera, tuve la oportunidad, gracias al programa de prácticas de SOIPEA de la Universidad de Huelva, de realizarlas en dos de las mejores empresas de mi ciudad. CEPSA refinería de la Rábida, donde tuve mi primera toma de contacto con la administración de sistemas y con el mantenimiento informático, donde me encontraba a mis anchas. Aprendí bastante, teniendo en cuenta que por aquella época no tenía aún ni idea de nada, simplemente intentaba aprobar las que podía y me dedicaba ir saliendo del paso que ya era bastante. Al año siguiente, dada la gran experiencia tomada en las prácticas del año anterior, decidí volverme a apuntar al programa de prácticas. Mi gran suerte fue caer en una de las mejores empresas de las que podía haber caído. E.M.T.U.S.A. Allí conocí mucha gente, pero sobre todo conocí a mi gran amor desde aquel día “LA TECNOLOGÍA .NET” (Siempre después de la de carne y hueso…J). En esa empresa desarrollamos un software de gestión donde tuve la oportunidad de aportar mi granito de arena en la parte sobre todo de informes con Crystal Report, donde me convertí en un experto. La herramienta llevaba gran parte de la administración de la empresa. Usuarios, remesa de tarjetas, facturación… y tenía muchas muchas líneas de código, que inicialmente estaban un poco caóticas, pero conforme fuimos aprendiendo la tecnología ya fuimos modulando cada vez más el código hasta que quedó una aplicación bastante aceptable. En aquella época estaba muy reciente esa tecnología, y trabajábamos con el Framework 1.0 de Microsoft. Tras terminar las prácticas y el curso, a falta de 2 asignaturas para terminar la carrera, me fui a Inglaterra, más en concreto a la ciudad de Chester, donde estuve 2 meses y pude aprender a desenvolverme de forma aceptable con el Ingés. Luego regresé a España y terminé mi carrera. Nada más terminar, comencé a buscar trabajo, cosa bastante difícil en mi ciudad, Huelva. Así que decidí buscar trabajo fuera, tras varias entrevistas frustradas. En menos de un mes ya me llamaron de una gran consultora, CORITEL. Me hicieron unas pruebas escritas de tipo test de inteligencia, y más tarde una entrevista personal, tras la cual pasé a una de las famosas “becas” para luego poder pasar a plantilla ya con un contrato de los de verdad . Durante la beca realicé un mes de ANSI C con sistemas UNIX y luego pasé a Visual Basic 6, lo cual me gustaba muchísimo más que C… Tras terminar mi beca, pasé a contrato y entré en un proyecto de ASP.NET, que no conocía en profundidad y solo había podido cacharrear con un par de manuales del amigo Guille. Aquí conocí mi 2º gran amor “ASP.NET y SQL Server 2000”. Nunca había trabajado en equipo de aquella forma con un control de código fuente (Source Safe ) , con servidores disponibles, certificados de seguridad, y mucho muuucho café. Aprendí mucho la verdad con mis Jefes José Carlos y Salvador (saludos a ambos). Allí realizamos una aplicación para Recursos Humanos, donde se calculaba el banding anual de todos los empleados y se le calculaban las subidas de nivel y de salario correspondiente según unas notas y demás historias. Muy divertido e instructivo, la verdad.

Después de un tiempo, pasé a trabajar a una agencia de comunicación y marketing online, donde conocí una nueva versión de mi mismo, como coDirector del departamento de nuevas tecnologías (NNTT) junto con otros compañeros y amigos. Allí aprendí la parte de la tecnología .NET y Java aplicada a aplicaciones comerciales orientadas al marketing online. Ya por estos tiempos trabajábamos con el Framework 1.1 y C# con SQL Server 2000, XML y Flash, mucho flash ¡! Aquí trabajé para grandes clientes, como Real Madrid, ONO, UniversalMusic, Garrigues abogados, Ayuntamiento de Madrid, TELCEL de México, DECATHLON, entre otros cuantos, que realizaban sus páginas Web corporativas y campañas de publicidad online con nosotros. Cuando creí haber tocado techo en esta empresa, opté por volver a mi tierra, donde me ofrecieron ya con la experiencia adquirida un buen puesto de trabajo con contrato indefinido. Pues nada, para casa. Menos mal, pude eludir ese año el crudo verano madrileño, donde todo es calor, obras en los metros y más calor todavía. ¡Qué bien, estaba en casita ¡!! La playa, el sol, el olor a marisma, la pesca, mis amigos de toda la vida.. ¡! Esto si que es vida. El nuevo trabajo era en una empresa de Ayamonte que se dedicaba a la creación de un mega-Software para las Sociedades de Garantía Recíproca Españolas. De allí la verdad que con lo que más me quedo es con la gente que conocí. He conseguido hacer muy buenos amigos allí y aprendí mucho de ellos. Trabajábamos ya con el Framework 2.0 y el flamante Visual Studio 2005 con TFS como control de código y SQL SERVER 2005 como gestor de bases de datos. En aquel momento ya empezaba a rondar por mi cabeza y la de mi actual socio montar algo por nuestra cuenta, pero la cosa de momento no salió en una primera instancia, así que seguimos por cuenta ajena. Pasado un año de estar en Ayamonte vimos recompensados nuestros esfuerzos en la realización de planes de empresa, sobre todo de mi socio y gran amigo Rafael Vizcaíno, al cual mando un fuerte abrazo, cuando la querida Diputación de Huelva nos aprobó la concesión de un local habilitado con internet y de unos 35 metros cuadrados donde poder desempeñar nuestra actividad. Tras esto, decidimos lanzarnos a la aventura montando lo que hoy es Realce Online eMarketing y Diseño, dejando todo nuestros lazos con el mundo laboral por cuenta ajena para convertirnos en dos empresarios que trabajarían por conseguir levantar una empresa de nuevas tecnologías en un ambiente tan hostil para ello como es nuestra querida ciudad de Huelva.

A día de hoy aun no nos arrepentimos de habernos lanzado al mundo empresarial por cuenta propia, con sus pros y sus contras, pero sobre todo con la satisfacción de crear tus propias aplicaciones y luego distribuirlas, que es como ver crecer a tu perro o a tu pájaro desde pequeño.

En fin, este ha sido el resumen de mi trayectoria hasta este momento de mi vida, en el que doy el salto hacia la blogosfera, espero con buen pie. En próximos artículos daré más detalles sobre mi empresa de desarrollo de software y sobre todo, hablaremos sobre tecnologías Microsoft.

Saludos y comenzamos….