martes, 25 de agosto de 2009

Usando Forms-based authentication con Active Directory

2 comentarios:
Usando Forms-based authentication con Active Directory

La autenticación de Forms es un sistema en el que las solicitudes no autenticadas se redirigen a un formulario web donde los usuarios están obligados a proporcionar sus credenciales.


Después de la presentación de la forma, y de ser adecuadamente verificada por su solicitud, un ticket de autorización es expedido por la aplicación Web, en la forma de una cookie. Esta cookie contiene las credenciales de autorización del usuario o una clave para readquirir la identidad del usuario (por lo tanto hacer de la identidad persistente del usuario). En esencia, la autenticación de formularios es un medio para el llenado de la aplicación Web con una fina capa de seguridad, que le permite tener su propia interfaz de inicio de sesión personalizado y funcionalidad de verificación.

Active Directory

Active Directory es un elemento esencial e inseparable de la arquitectura de la red de Windows que permite a las organizaciones compartir y gestionar de manera eficiente la información sobre los recursos de red y los usuarios. Básicamente se trata de un único punto de gestión para Windows basado en cuentas de usuarios, clientes y aplicaciones. También ayuda a las organizaciones a integrar la no aplicación de Windows con aplicaciones basadas en Windows y dispositivos, lo que consolida los directorios y facilitar la gestión de todo el sistema operativo de red. Las organizaciones también utilizan Active Directory para ampliar los sistemas de forma segura a Internet, al obligar a sus usuarios de la aplicación Web para autenticar contra su único punto de Active Directory.

Requisitos

Microsoft Windows
Microsoft ® Visual Studio. NET
Conocimiento de Microsoft Visual C # ™

Antes de empezar

En este artículo voy a mostrar cómo implementar la autenticación de formularios mediante las credenciales de Active Directory. Los formularios de autenticación de ASP.NET permite a los usuarios escriben sus credenciales (nombre de usuario y contraseña) en un formulario web para identificarse. La aplicación Web recibe la credencial, y se puede autenticar al usuario verificar su nombre de usuario y contraseña en un conjunto de datos disponibles. En este artículo se describe cómo autenticar a los usuarios de Microsoft ® Active Directory ® utilizando el protocolo LDAP (Protocolo ligero de acceso a datos). También se describe cómo almacenar esa información en un objeto GenericPrincipal y cómo almacenarlo en la propiedad HttpContext.Current.User que sigue a la petición de lanzar la aplicación Web ASP.NET.

Crear la página de inicio de sesión

Lo primero que tenemos que hacer es crear una nueva solución en Visual Studio 2005. Y añadir un nuevo sitio web. El sitio web debe tener una página de acceso simple, como la que muestran en la imagen siguiente. El objetivo de esta página es como cada página de inicio de sesión, para validar el nombre de usuario y contraseña en un dominio, la diferencia es que el proceso de validación validará en Active Directory.




En el evento de load de la página de acceso puede agregar el siguiente código para mostrar el dominio de la identidad y nombre de usuario asociado con la solicitud Web actual, esto con la finalidad de ayudar al usuario.



if(!Page.IsPostback())
{
string domainUser = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
string[] paramsLogin = domainUser.Split('\\');
txtUser.Text = paramsLogin[1].ToString();
txtDomain.Text = paramsLogin[0].ToString();
}

Configuración de la aplicación

Ahora tenemos que configurar la aplicación para que admite la autenticación de formularios. Usted puede hacer esto a través del archivo Web.config. Tienes que cambiar el modo de autenticación en el web.config y agregue un elemento secundario para configurar la página de acceso, el tiempo de espera de sesión y el cookie que contiene la información de autenticación.

Además, debe agregar la etiqueta para permitir que sólo los usuarios autenticados, tienen acceso a la aplicación. Si el proceso de inicio de sesión no se realizó correctamente, el usuario será redirigido a la página de inicio de sesión.
Para los que van a virtual de la aplicación de directorio en Propiedades y, a continuación, haga clic en la pestaña de seguridad en el acceso anónimo y el grupo de control de autenticación y desactive la casilla Acceso anónimo.

Después de que se necesita una pequeña modificación en el web.config. Usted tendrá que agregar un elemento debajo del elemento en Web.config y establecer el atributo impersonate en true. Esto hace que ASP.NET para suplantar la cuenta anónima especificada anteriormente.

Así que el archivo de configuración que se parece a éste:

< authentication mode="Forms" >
< forms loginUrl="logon.aspx" name="adAuthCookie" timeout="60" path="/" / >
< /authentication >

< authorization >
< deny users="?" / >
< allow users="*" / >
< /authorization >

< identity impersonate="true" / >

Como resultado de esta configuración, cada solicitud dirigida a la aplicación se ejecutará en el contexto de cuenta configurada anónimos de seguridad. El usuario deberá proporcionar credenciales a través del formulario Web para autenticarse en Active Directory, pero la cuenta que se utilizarán para tener acceso a Active Directory será la cuenta configurada de forma anónima

Implementando la validación en active directory

Llego el momento para escribir el código de autenticación del Active Directory. Va a crear una nueva clase que proporcionará un método que recibe un nombre de dominio, nombre de usuario y la contraseña como parámetro y devuelve un valor booleano que indica si existe un registro coincidente en Active Directory.

Vamos crear una Libreria de clases con una clase que implementa un método de autenticación contra AD. Usted tendrá que agregar una referencia al Asembly System.DirectoryServices.dll. Esto proporciona acceso al espacio de nombres System.DirectoryServices que contiene tipos administrados como ayuda en la consulta y el tratamiento en Active Directory.
La conexión a Active Directory es a través de LDAP. Usted tiene que especificar la ruta de conexión. Para el proceso de búsqueda de AD tendrá un atributo de filtro.



Inicialmente, el método intenta conectar con Active Directory utilizando las credenciales proporcionadas. EL método utiliza la clase administrada DirectorySearcher para buscar el objeto de usuario especificado.
Código de la clase:

using System.Text;
using System.Collections;
using System.DirectoryServices;

private string _path;
private string _filterAttribute;

public Class LdapAuthentication
{

public LdapAuthentication(string path)
{
_path = path;
}

public bool IsAuthenticated(string domain, string username, string pwd)
{
string domainAndUsername = domain + @"\" + username;
DirectoryEntry entry = new DirectoryEntry( _path,
domainAndUsername, pwd);
try
{
// Bind to the native AdsObject to force authentication.
Object obj = entry.NativeObject;
DirectorySearcher search = new DirectorySearcher(entry);
search.Filter = "(SAMAccountName=" + username + ")";
search.PropertiesToLoad.Add("cn");
SearchResult result = search.FindOne();
if(null == result)
{
return false;
}
// Update the new path to the user in the directory
_path = result.Path;
_filterAttribute = (String)result.Properties["cn"][0];
}
catch (Exception ex)
{
throw new Exception("Error authenticating user. " + ex.Message);
}
return true;
}

}

Implementando el Proceso de autenticación

En este paso se van a desarrollar plenamente el proceso de autenticación que se pondrá en marcha cuando el usuario hace clic en el botón de inicio de sesión utilizando la clase construida antes.

Para los usuarios autenticados, la autenticación de form-base será creada y el usuario será redirigido a la página original que había pedido.
Ahora abría de agregar en el botón de inicio de sesión un event handler con código que cree una nueva instancia de la clase de validación del Active Directory. El proceso de autenticación tiene que realizar los siguientes pasos:

a. Autenticar al usuario contra el Active Directory.
b. crear una credencial de FormsAuthenticationTicket que identifica al usuario.
c. Encriptar la credencial.
d. Crear una nueva cookie que contiene el Ticket.
e. Agregue la cookie a la lista de las cookies que se devuelven al explorador del usuario.

// Path to you LDAP directory server.
// Contact your network administrator to obtain a valid path.
string adPath = "LDAP://localhost;
LdapAuthentication adAuth = new LdapAuthentication(adPath);


try
{
if(true == adAuth.IsAuthenticated(txtDomainName.Text, txtUserName.Text,txtPassword.Text))
{
// Create the authetication ticket
FormsAuthenticationTicket authTicket =
new FormsAuthenticationTicket(1, // version
txtUserName.Text,
DateTime.Now,
DateTime.Now.AddMinutes(60), False , groups);
// Now encrypt the ticket.
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
// Create a cookie and add the encrypted ticket to the
// cookie as data.
HttpCookie authCookie =
new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
// Add the cookie to the outgoing cookies collection.
Response.Cookies.Add(authCookie);
// Redirect the user to the originally requested page
Response.Redirect(
FormsAuthentication.GetRedirectUrl(txtUserName.Text,false));
}
else
{
lblError.Text = ”Authentication failed, check username and password.";
}
}
catch (Exception ex)
{
lblError.Text = "Error authenticating. " + ex.Message;
}

Recuerde que debe cambiar la ruta de acceso de modo que tiene como objetivo el AD Server, y el nombre de la cookie debe ser el mismo nombre que hemos especificado en el archivo Web.config.

Implementando la solicitud de autenticación

Ahora la pregunta es cómo la aplicación sabe si el usuario está autenticado o no cada vez que la aplicación realiza una solicitud.

Se puede hacer este procedimiento en el archivo Global.asax. que tiene que implementar un evento denominado Application_AuthenticateRequest. Recuerde que en los pasos anteriores se genera una cookie de con un un Ticket de autenticación. En este evento debe extraer información de las cookies y crea un objeto GenericPrincipal de identificar al usuario autenticado.

Por último, el objeto GenericPrincipal se asociará con el objeto HttpContext actual crea para cada solicitud Web.

using System.Web.Security;
using System.Security.Principal;

// Extract the forms authentication cookie
string cookieName = FormsAuthentication.FormsCookieName;
HttpCookie authCookie = Context.Request.Cookies[cookieName];
if(null == authCookie)
{
// There is no authentication cookie.
return;
}

FormsAuthenticationTicket authTicket = null;
Try
{
authTicket = FormsAuthentication.Decrypt(authCookie.Value);
}
catch (Exception ex)
{
// Log exception details (omitted for simplicity)
return;
}
if (null == authTicket)
{
// Cookie failed to decrypt.
return;
}

// Create an Identity object
GenericIdentity id = new GenericIdentity(authTicket.Name,"LdapAuthentication");

// This principal will flow throughout the request.
GenericPrincipal principal = new GenericPrincipal(id, null);

// Attach the new principal object to the current HttpContext object
Context.User = principal;

Probando la Aplicación
Ya terminado el proceso de autenticación y es hora de probarlo. Introduzca un nombre de dominio válido, nombre de usuario y contraseña y haga clic en Iniciar sesión, si está autenticado correctamente, debería ser enviado de nuevo a la página que establece como valor predeterminado. Si intenta cambiar la URL manualmente antes de inicio de sesión, obtendrá el mismo resultado que un inicio de sesión no válida, la solicitud se tenga en cuenta que no hay ningún usuario autenticado por lo que será redirigido a la página inicio de sesión de nuevo.

Articulos relacionados

How To: Use Forms Authentication with Active Directory in ASP.NET 2.0
http://msdn.microsoft.com/en-us/library/ms998360.aspx
System.DirectoryServices Namespace
http://msdn.microsoft.com/en-us/library/system.directoryservices.aspx
http://www.15seconds.com/issue/050203.htm
http://www.beansoftware.com/ASP.NET-Tutorials/Forms-Authentication-Active-Directory.aspx
Personas participantes en el artículo:
Luis Oswaldo Gonzales
Carlos Juan Orellana
Ver

jueves, 20 de agosto de 2009

Mejorar el rendimiento en ASP.net

1 comentario:
Mientras cree cualquier sitio web, debe mantener en mente algunos puntos para mejorar su rendimiento.

1.) Configure el debug=false de la siguiente manera:

< compilation default Language="c#" debug="false" >

2.) Use Server.Transfer en vez de Response.Redirect.

3) Compruebe siempre Page.IsValid cuando se utilizan controles Validator.

4) Use Foreach loop en lugar de For loop para String Iteration.

5) Utilizar la validación del lado cliente donde sea posible.

6.)Verifique “Page.IsPostBack”. Para evitar la repetición de la ejecución de código.

7.)GIF y PNG son similares, pero PNG normalmenteson de menor tamaño. (Es verdad, pero algunos navegadores no apoyar el formato PNG)

8.)Usar el AppOffline.htm cuando se actualiza binarios.

9.)Desactivar Tracing, a menos que sea requerido. (por defecto esta desactivada, uselo en las páginas en las que es necesario)

< trace enabled="false" requestLimit="10" pageOutput="false" traceMode="SortByTime" localOnly="true"/ >

10.)Precompile las páginas y desactivar AutoEventWireup; colocar el atributo AutoEventWireup en false en el archivo Machine.config.

11.)Apague el estado de la sesión, si no es necesario.

< sessionstate timeout="20" cookieless="false" mode="Off" stateconnectionstring="tcpip=127.0.0.1:42424" sqlconnectionstring="data source=127.0.0.1;Trusted_Connection=no" >

12.)Seleccione el modo de Release (versión final) antes de hacer la construcción para su aplicación.

14.)Deshabilitar Viewstate cuando no se requiere.

EnableViewState="false"

15.)Evite frecuentes viajes de ida y vuelta a la base de datos.

16.)Use caché para mejorar el rendimiento de su aplicación.

17.)Validar todos los ingresos recibidos de los usuarios.

18.)Utilice método Finally para matar a los recursos.

19.) Use el StringBuilder en lugar del String ya que ocupan una posición de memoria diferente en cada momento de la modificación.

20.) Nunca use directamente el Objeto; primero obtenga el valor del objeto en la variable local que usara. Se tarda más tiempo entonces la lectura de variables.

21.)Evite las excepciones: Use la condición if (si se trata de comprobar la condición adecuada)

22.)Optimización de código: Evite el uso de código como x = x +1; es siempre mejor usar x + = 1.

23.)Técnicas de Acceso a datos: DataReaders proporciona un método rápido y eficaz de recuperación de datos. DataReader es mucho más rápido de DataSets en lo que refiere al rendimiento

24.)Como siempre, evitar las variables de sesión, ya que cada página ASP se ejecuta en un subproceso diferente y pide período de sesiones se serializa una por una. Así pues, este pondra mas lenta la aplicación. En lugar de las variables de sesión se puede utilizar la colección QueryString o variables ocultas en la forma que tiene los valores

25.)Habilite buffering mejorará el rendimiento.

< % response.buffer=true % >
< % response.flush=true % >


26.)Utilice el control Repeater en lugar de DataGrid, DataList, porque es eficiente, personalizable y programable.

27.)Las Lista de datos(Data listing) consumen más tiempo para grandes volúmenes de datos cuando se recupere datos de la base de datos.

Paginación mostrará sólo los datos en particular, sino tomar la carga de todos los datos.
Buscar sólo los datos que se necesita para la página actual.


28.)Evite los JavaScript y CSS en linea(Inline)

29.)Utilizan un solo archivo CSS en lugar de múltiples archivos CSS.

Lo posible se deben combinar todas las clases CSS basado en un solo css. Archivo como mucho. Archivos CSS provocará una gran cantidad de solicitudes, independientemente del tamaño de los archivos.

. archivos CSS normalmente se almacena en caché de los navegadores, así que un único y fuerte. css no causa de una larga espera en cada solicitud de página.

En línea. Clases CSS podría hacer HTML pesados, por lo que de nuevo: seguir adelante con un archivo de single.css

30) Reducir el tamaño de las cookies.

31.) Comprimir CSS, JavaScript e imágenes.

Compresores en línea están disponibles, para comprimir el archivo por favor se refiere siguientes web y reemplazar el contenido de su archivo con optimizar el código.

32.)Use Cache apropiadamente.

33.) No haga las variables public or proteted, trate de mantenerlo private y use public/proteted como propiedades.

34.)Use strString=string.Empty en lugar de strString="" [Y tal vez en lugar de strString=null tambien (?)]

35.) Hacer sus paginas lo más ligero posible. La idea es tratar de evitar márgenes innecesarias, por ejemplo, uso de elementos div en lugar de tablas.

36.)Escribir mensajes estáticos en div y hacerlo visible cuando sea necesario. Esto es más rápido que dejar que el servidor establezer la propiedad Text en el label o div.

37.)Recuperar datos de la base de datos en una sola vez, si es posible. Asi no se hacen muchos viajes a la base de datos. Para ello, se combinan los campos de datos de diferentes tablas y seleccionarlos.

Otros consejos:

HTML Page Performance
http://msdn.microsoft.com/en-us/magazine/cc163854.aspx
Ver

viernes, 14 de agosto de 2009

crear una aplicacion para usar Ftp - FtpWebRequest

No hay comentarios.:
El FtpWebRequest le permite crear conexiones de FTP a los servidores de FTP y la transferencia de archivos. Si usted está interesado en el uso de la FtpWebRequest clase para subir archivos a un servidor, aquí está un ejemplo de código:

Información Tecnica:
.NET Framework Class LibraryFtpWebRequest Class
Implements a File Transfer Protocol (FTP) client.
Namespace: System.Net
Assembly: System (in System.dll)
http://msdn.microsoft.com/en-us/library/system.net.ftpwebrequest.aspx

código de ejemplo:
FtpWebRequest ftpRequest;
FtpWebResponse ftpResponse;
try
{

//Ajustes necesarios para establecer una conexión con el servidor
this.ftpRequest = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://ServerIP/FileName"));
this.ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
this.ftpRequest.Proxy = null;
this.ftpRequest.UseBinary = true;
this.ftpRequest.Credentials = new NetworkCredential("UserName", "Password");


//Selección de archivo a ser cargado
FileInfo ff = new FileInfo("File Local Path With File Name");//e.g.: c:\\Test.txt
byte[] fileContents = new byte[ff.Length];


//destruirá el objeto inmediatamente después de ser utilizado

using (FileStream fr = ff.OpenRead())
{
fr.Read(fileContents, 0, Convert.ToInt32(ff.Length));
}


using (Stream writer = ftpRequest.GetRequestStream())
{
writer.Write(fileContents, 0, fileContents.Length);
}

//Obtiene el FtpWebResponse de la operación de carga
this.ftpResponse = (FtpWebResponse)this.ftpRequest.GetResponse();
Response.Write(this.ftpResponse.StatusDescription); //Display response
}

catch (WebException webex)
{
this.Message = webex.ToString();
}
Ver

jueves, 13 de agosto de 2009

HttpWebRequest

No hay comentarios.:
La clase HttpWebRequest le permite hacer peticiones web a un servidor HTTP, en otras palabra permite al usuario interactuar directamente con servidores que utilicen HTTP


Este código muestra cómo leer el contenido de un archivo desde un servidor web remoto utilizando la clase HttpWebRequest.

http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.aspx
Espacio de nombres: System.Net
Ensamblado: System (en system.dll)


Visual Basic:

If Not (IsPostBack) Then
Try
Dim fr As System.Net.HttpWebRequest
Dim targetURI As New Uri("http://algo.asp.net/algo.txt")
fr = DirectCast(System.Net.HttpWebRequest.Create(targetURI), System.Net.HttpWebRequest)
If (fr.GetResponse().ContentLength > 0) Then
Dim str As New System.IO.StreamReader(fr.GetResponse().GetResponseStream())
Response.Write(str.ReadToEnd())
str.Close();
End If
Catch ex As System.Net.WebException
Response.Write("File does not exist.")
End Try
End If

C#:

if (!(IsPostBack))
{
try
{

System.Net.HttpWebRequest fr;
Uri targetUri = new Uri("http://algo.asp.net/algo.txt");
fr = (System.Net.HttpWebRequest)System.Net.HttpWebRequest.Create(targetUri);
if ((fr.GetResponse().ContentLength > 0))
{
System.IO.StreamReader str = new System.IO.StreamReader(fr.GetResponse().GetResponseStream());
Response.Write(str.ReadToEnd());
if (str != null) str.Close();
}
}
catch (System.Net.WebException ex)
{
Response.Write("File does not exist.");
}
}
Ver

martes, 11 de agosto de 2009

Crear Usuario en site en Sharepoint con aspnet

1 comentario:
Cuando intente Crear un site en sharepoint rapido pense en los sharepoint web service
http://msdn.microsoft.com/en-us/library/dd878586.aspx
y puede usar el web service
http://site/_vti_bin/meetings.asmx con el siguiente codigo:

Dim cc As New System.Net.NetworkCredential
cc.UserName = "administrator"
cc.Domain = "test"
cc.Password = "test"

Dim WMService As New MeetingWebService.Meetings()
WMService.Credentials = cc
Dim tz As New MeetingWebService.TimeZoneInf()

Dim xnode As Xml.XmlNode = WMService.CreateWorkspace("pruebasts1", "STS#0", System.UInt32.Parse("1033"), tz)

sin embargo este codigo tiene muchas desventajas por que los web service no tiene todas las caracteristicas para automatizar el sharepoint.

lo que tiene que hacer es lo siguiente:
paso 1
buscar el un dll de sharepoint y referenciarlo a su proyecto la cual se encuentra en:

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\ISAPI\Microsoft.SharePoint.dll

paso 2
codigo para crear el sitio

//crea sitio en sharepoint
using (SPSite oSiteCollection = new SPSite("http://test"))
{
SPWebCollection collWebsites = oSiteCollection.AllWebs;
System.UInt32 lcid = new System.UInt32();
lcid = Convert.ToUInt32("1033");
SPWeb oWebsite = collWebsites.Add("site1", usuario, "Description xx", lcid, "STS#0", true, false);
}
//fin crea sitio en sharepoint

//crea el grupo de permisos
using (SPSite oSiteCollection = new SPSite("http://test"))
{
using (SPWeb oWebsite = oSiteCollection.OpenWeb("site-" + usuario))
{
string usuario="prueba";
string groupName1 = usuario + "-Contribuidor";
oWebsite.SiteUsers.Add("test\\" + usuario, "", usuario, "user:" + usuario);
SPUser ownerUser = oWebsite.SiteUsers["test\\" + usuario];
oWebsite.SiteGroups.Add(groupName1, ownerUser, ownerUser, "contrubuidor");
oWebsite.AssociatedGroups.Add(oWebsite.SiteGroups[groupName1]);
SPRoleDefinitionCollection roleDefinitions = oWebsite.RoleDefinitions;
SPRoleAssignmentCollection roleAssignments = oWebsite.RoleAssignments;
SPPrincipal author = oWebsite.SiteGroups[groupName1] as SPPrincipal;
SPRoleAssignment assignment = new SPRoleAssignment(author);
SPRoleDefinitionBindingCollection definitions = assignment.RoleDefinitionBindings;
//Contribute - Full Control
definitions.Add(roleDefinitions["Contribute"]);
roleAssignments.Add(assignment);
}
}
//fin del grupo de permisos

//crea las librerias
using (SPSite oSiteCollection = new SPSite("http://test"))
{
using (SPWeb oWebsite = oSiteCollection.OpenWeb("site-" + usuario))
{
oWebsite.Lists.Add("documentos", "documentos de " + usuario, SPListTemplateType.DocumentLibrary);
SPList newList = oWebsite.Lists["documentos"];
newList.OnQuickLaunch = true;
newList.Update();

oWebsite.Lists.Add("Fotos", "fotos de" + usuario, SPListTemplateType.PictureLibrary);
SPList newfotos = oWebsite.Lists["Fotos"];
newfotos.OnQuickLaunch = true;
newfotos.Update();
}
}
//fin de las librerias


si quiere hacerlo aun mas poderoso miren este articulo:
SharePoint Security and .NET Impersonation
http://www.15seconds.com/issue/040511.htm


Algunas otros templates para crear site.
STS#0 Team site
STS#1 Blank Site
STS#2 Document Workspace
MPS#0 Basic Meeting Workspace
MPS#1 Blank Meeting Workspace
MPS#2 Decision Meeting Workspace
MPS#3 Social Meeting Workspace
MPS#4 Multipage Meeting Workspace
WIKI#0 Wiki
BLOG#0 Blog
BDR#0 Document Center
OFFILE#0 Record Center 0
OFFILE#1 Record Center 1
OSRV#0 Shared Services Administration
SPSPERS#0 SP Portal Personal Space
SPSMSITE#0 Personalization Site
SPSTOC# COntents Area Template
SPSTOPIC#0 Topic Area Template
SPSNEWS#0 News Site
CMSPUBLISHING#0 Publishing Site 0
BLANKINTERNET#0 Publishing Site 1
BLANKINTERNET#2 Publishing Site with Workflow
SPSNHOME#0 News Site 2
SPSSITES#0 Site Directory
SPSCOMMU#0 Community Area Template
SPSREPORTCENTER#0 Report Center
SPSPORTAL#0 Collaboration Portal
SRCHCEN#0 Search Center with Tabs
PROFILES#0 Profiles
BLANKINTERNETCONTAINER#0 Publishing Portal
SPSMSITEHOST#0 My Site Host
SRCHCENTERLITE#0 Search Center 0
SRCHCENTERLITE#1 Search Center 1
Ver

lunes, 10 de agosto de 2009

¿Eres un ejecutivo?

No hay comentarios.:
Super viejo pero es bueno.
Las respuestas no son difíciles. Simplemente Ud. debe pensar como un/averdadero/a
ejecutivo.
PREGUNTA NUMERO 1
¿Cómo pone Ud. una jirafa en una nevera(refri)?
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Respuesta correcta: Abra la nevera(refri), ponga la jirafa y cierre la puerta. Esta pregunta verifica si Ud. está haciendo las cosas simples de una manera complicada.

PREGUNTA NUMERO 2
¿Cómo pone Ud. un elefante en la nevera?

*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Respuesta incorrecta: Abra la nevera, ponga el elefante y cierre la nevera. Respuesta correcta:Abra la nevera, saque la jirafa, ponga el elefante, y cierre la nevera. Esta pregunta comprueba su capacidad de evaluar dificultades futuras.

PREGUNTA NUMERO 3
El Rey León ha convocado una Asamblea General de Animales. Todos fueron, menos uno. ¿Cual?
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Respuesta correcta:El elefante. !Está en la nevera! Esta pregunta evalúa su capacidad de razonamiento comprensivo.
PREGUNTA NUMERO 4
En la selva, hay un río lleno de cocodrilos, y Ud. no cuenta con embarcación alguna. ¿Cómo lo cruza?
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

Respuesta correcta: Nadando. ¡Todos los cocodrilos están en la reunión del Rey León! Esta pregunta evalúa su agilidad mental.

Calificación para puestos...
4 respuestas correctas = Dirección ejecutiva, Presidencia
3 respuestas correctas = Gerencias medias
2 respuestas correctas = Asistentes, Jefaturas
1 respuesta correcta = Obrero, OficinistaNinguna respuesta correcta = Dedicate a la pesca con red, por que conanzuelo no sacas nada...
Ver