Analizando como podemos consumir SharePoint OData con javascript

Pienso que es interesante las pruebas que realice para validar lo que me devuelve el servicio de Odata de SharePoint Online.

Cree una lista personalizada de SharePoint llamada Banners y adicione un par de columnas Url y Link.

Y el contenido es el siguiente: un solo elemento con una image y un enlace.

Si consumimos el servicio enviando la siguiente instrucción con jquery:
 
Lo que me devuelve al consumir json es lo siguiente:
{"odata.metadata":"https://infowareplus.sharepoint.com/sites/prueba/_api/$metadata#SP.ListData.BannersListItems"
,"value":[{"odata.type":"SP.Data.BannersListItem"
,"odata.id":"0589cb7b-2bb2-4ced-a7ea-704cd8e0dcea"
,"odata.etag":"\"4\""
,"odata.editLink":"Web/Lists(guid'2b6b9d83-4eeb-4716-86e4-5f6ee03a577e')/Items(1)"
,"FileSystemObjectType":0
,"Id":1
,"ContentTypeId":"0x01002C49C3B57506B541ABE2A829193FF712"
,"Title":"Noticias"
,"Imagen":{"Description":"Evento"
,"Url":"https://infowareplus.sharepoint.com/sites/prueba/SiteAssets/EventoMicrosoftAzureComunidadTecnica2.jpg"}
,"Link":{"Description":"Dirección de Prueba"
,"Url":"http://www.google.com"}
,"ID":1
,"Modified":"2015-12-14T19:54:56Z"
,"Created":"2015-12-10T20:47:48Z"
,"AuthorId":9
,"EditorId":9
,"OData__UIVersionString":"1.0"
,"Attachments":false
,"GUID":"f6a6e965-8f1a-436e-86c8-682e4f6368d5"}]}
Ahora observemos la siguiente prueba a tavés de javascript:

Create Object from JSON String

Lo que nos devuelve es lo siguiente:

{"odata.metadata":"https://infowareplus.sharepoint.com/sites/PRUEBA/_api/$metadata#SP.ListData.BannersListItems","value":[{"odata.type":"SP.Data.BannersListItem","odata.id":"0589cb7b-2bb2-4ced-a7ea-704cd8e0dcea","odata.etag":"'4'","odata.editLink":"Web/Lists(guid\'2b6b9d83-4eeb-4716-86e4-5f6ee03a577e\')/Items(1)","FileSystemObjectType":0,"Id":1,"ContentTypeId":"0x01002C49C3B57506B541ABE2A829193FF712","Title":"Noticias","Imagen":{"Description":"Evento","Url":"https://infowareplus.sharepoint.com/sites/prueba/SiteAssets/EventoMicrosoftAzureComunidadTecnica2.jpg"},"Link":{"Description":"Dirección de Prueba","Url":"http://www.google.com"},"ID":1,"Modified":"2015-12-14T19:54:56Z","Created":"2015-12-10T20:47:48Z","AuthorId":9,"EditorId":9,"OData__UIVersionString":"1.0","Attachments":false,"GUID":"f6a6e965-8f1a-436e-86c8-682e4f6368d5"}]}

Si accedemos  a la propiedad odata.detadata:
var obj = JSON.parse(text);
document.getElementById("demo2").innerHTML = obj["odata.metadata"];
Me retorna lo siguiente:

https://infowareplus.sharepoint.com/sites/prueba/_api/$metadata#SP.ListData.BannersListItems

Si accedemos la propiedad value obtendremos otro objeto de json que podemos acceder sus propiedades, de la siguiente forma:
var obj2 = obj["value"];
document.getElementById("demo3").innerHTML = obj2[0]["odata.type"];
Lo que nos retorna es lo siguiente:

SP.Data.BannersListItem

Asi podemos obtener otros atributos:
document.getElementById("demo4").innerHTML = obj2[0]["odata.id"];
document.getElementById("demo5").innerHTML = obj2[0]["odata.etag"];
document.getElementById("demo6").innerHTML = obj2[0]["odata.editLink"];
Lo que nos retorna es lo siguiente:

0589cb7b-2bb2-4ced-a7ea-704cd8e0dcea
'4'
Web/Lists(guid'2b6b9d83-4eeb-4716-86e4-5f6ee03a577e')/Items(1)

Y por ultimo vamos acceder la propiedad Imagen y Link de la siguiente forma:

var obj3 = obj2[0]["Imagen"];
document.getElementById("demo7").innerHTML = obj3["Url"];
var obj4 = obj2[0]["Link"];
document.getElementById("demo8").innerHTML = obj4["Url"];

Y los resultados serán las URL siguientes:

https://infowareplus.sharepoint.com/sites/PRUEBA/SiteAssets/EventoMicrosoftAzureComunidadTecnica2.jpg
http://www.google.com

Bueno como vemos podemos acceder con javascript la información que me devuelve el servicio OData de SharePoint, y como esta construído la estructura de datos de una lista Personalizada de SharePoint.  Para que observemos mejor la estructura lo mostraré de la siguiente forma:
'{
"odata.metadata":"https://infowareplus.sharepoint.com/sites/prueba/_api/$metadata#SP.ListData.BannersListItems"
,"value":[
     {"odata.type":"SP.Data.BannersListItem"
     ,"odata.id":"0589cb7b-2bb2-4ced-a7ea-704cd8e0dcea"
     ,"odata.etag":"\'4\'"
     ,"odata.editLink":"Web/Lists(guid\'2b6b9d83-4eeb-4716-86e4-5f6ee03a577e\')/Items(1)"
     ,"FileSystemObjectType":0
     ,"Id":1
     ,"ContentTypeId":"0x01002C49C3B57506B541ABE2A829193FF712"
     ,"Title":"Noticias"
     ,"Imagen":{"Description":"Evento","Url":"https://infowareplus.sharepoint.com/sites/prueba/SiteAssets/EventoMicrosoftAzureComunidadTecnica2.jpg"}
     ,"Link":{"Description":"Dirección de Prueba" ,"Url":"http://www.google.com"}
     ,"ID":1
     ,"Modified":"2015-12-14T19:54:56Z"
     ,"Created":"2015-12-10T20:47:48Z"
     ,"AuthorId":9
     ,"EditorId":9
     ,"OData__UIVersionString":"1.0"
     ,"Attachments":false
     ,"GUID":"f6a6e965-8f1a-436e-86c8-682e4f6368d5"}
     ]
}'
Espero que con eso los haya ayudado a comprender la estructura de las listas en SharePoint en formato JSON.
Hasta la próxma,
Juan Manuel Herrera Ocheita
 

P.D. utilice para las pruebas el siguiente enlace: http://www.w3schools.com/json/tryit.asp?filename=tryjson_parse .

Como descargar una solución de granja instalada en SharePoint 2010 y 2013

Cómo descargar una solución de granja instalada es un requerimiento muy usual cuando se esta migrando versiones de SharePoint, por ejemplo de 2010 a 2013.  O bien migrando de un conjunto de servidores a otros por temas de problemas con el existente.

Bueno antes de resolver el tema hablemos un poco de las soluciones de granja.  Estas son empacadas en paquetes con extensión WSP, aunque no son las únicas ya que las soluciones Sandbox, las plantillas de sitio y las famosas apps utilizan este formato de paquete para que puedan ser ejecutados desde SharePoint.  Estos paquetes no son mas que empacados que contiene un conjunto de documentos y archivos binarios que componen la solución de granja o Farm Solution.

Es esto posible si por medio de PowerShell podemos realizar esta tarea que en versiones 2007 era impensable.

$FolderPath = "c:\Solutions"

foreach ($solution in Get-SPSolution) 

{ 

    $id = $Solution.SolutionID 

    $title = $Solution.Name 

    $filename = $Solution.SolutionFile.Name 

    $solution.SolutionFile.SaveAs("$FolderPath\$filename") 

}

 

Si se migra el paquete de 2010 a 2013 y este no tiene depedencias que hayan variado en la versión 2013, puede intentar el siguiente comando luego de extraer el paquete wsp de la granja SharePoint 2010.

Install-SPSolution –Identity Solution.wsp –GACDeployment –CompatibilityLevel All e intenar ejecutar el sitio en modo 2010.

https://technet.microsoft.com/en-us/library/dn673579.aspx

Script para saber el tamaño de una carpeta de una biblioteca en SharePoint 2010-2013

 

Esta solicitud me hicieron hace un momento y como no vi un ejemplo en especifico para esto decidi compartirlo con mis amigos lectores.

Los tres parametros que necesitamos son: url del sitio web en cuestion, el nombre de la biblioteca y el nombre de la carpeta.  Como se muestra abajo:

$urlWebSite = “http://hostname/siteurl/sub-siteurl”

$nombreLibreria = "Nombre-Libreria"

$nombreCarpeta = "Nombre-Carpeta"

Luego debemos de obtener el objeto SPWeb para encontrar la bilioteca de la siguiente forma:

$web = get-SPWeb $urlWebSite

Una vez que lla obtuvimos el objeto SPWeb que representa el sitio web en SharePoint obtenemos la biblioteca con la colección Folders del objeto SPWeb, como se muestra a continuación:

$folder =  $web.Folders[$nombreLibreria]

Ahora que almacenamos en la variable $folder la bilbioteca en cuestion, necesitamos obtener la carpeta que buscamos a través de la colección SubFolerds del objeto SPFolder, de la siguiente forma:

$subfolder = $folder.SubFolders[$nombreCarpeta]

Con eso tenemos ya la ubicación deseada para iniciar el proceso de lectura de los bytes ocupados en la carpeta y sub carpetas, para ello necesitamos crear un funcion que llamemos de forma recursiva hasta que obtengamos el espacio total ocupado.

[long]$total = 0

$total = GetFolderSize($subfolder)

La función es la siguiente:

function GetFolderSize ($Folder)

{

    [long]$folderSize = 0 

    foreach ($file in $Folder.Files)

    {

        write-host "Nombre documento" $file.Name

        $folderSize += $file.Length;

        write-host "Total en bytes que va acumulando:" $folderSize

    }

    foreach ($fd in $Folder.SubFolders)

    {

        $folderSize += GetFolderSize -Folder $fd

    }

    return $folderSize

}

Lo que nos falta entonces es convertir los bytes en megas, y en gigas es es lo que hacemos a continuación:

$totalInMb = ($total/1024)/1024

$totalInMb = "{0:N2}" -f $totalInMb

$totalInGb = (($total/1024)/1024)/1024

$totalInGb = "{0:N2}" -f $totalInGb

write-host "Tamaño total de la carpeta" $StartWeb "es" $total " Bytes,"

write-host "son " $totalInMb "MB o " $totalInGb "GB"

Y ahora necesitamos indicarle a Windows que libere el recurso en memoria que ocupamos a través del objeto SPWeb la invocar el comando  $web = get-SPWeb $urlWebSite , y lo hacemos de la siguiente forma:

$web.Dispose()

Para poner todo en orden debemo de prepar un contenedor de este script en un archivo con extension .ps1, por ejemplo:

C:\>GetFolderSize.ps1

y debera contener el siguiente orden del código descripto arriba:

<!--- Begin of File –->

function GetFolderSize ($Folder)

{

    [long]$folderSize = 0 

    foreach ($file in $Folder.Files)

    {

        write-host "Nombre documento" $file.Name

        $folderSize += $file.Length;

        write-host "Total en bytes que va acumulando:" $folderSize

    }

    foreach ($fd in $Folder.SubFolders)

    {

        $folderSize += GetFolderSize -Folder $fd

    }

    return $folderSize

}

$urlWebSite = “http://hostname/siteurl/sub-siteurl”

$nombreLibreria = "Nombre-Libreria"

$nombreCarpeta = "Nombre-Carpeta"

$web = get-SPWeb $urlWebSite

$folder =  $web.Folders[$nombreLibreria]

$subfolder = $folder.SubFolders[$nombreCarpeta]

$totalInMb = ($total/1024)/1024

$totalInMb = "{0:N2}" -f $totalInMb

$totalInGb = (($total/1024)/1024)/1024

$totalInGb = "{0:N2}" -f $totalInGb

write-host "Tamaño total de la carpeta" $StartWeb "es" $total " Bytes,"

write-host "son " $totalInMb "MB o " $totalInGb "GB"

$web.Dispose()

<!--- End of File –->

Y por ultimo utilizamo el Management Shell for SharePoint para ejecutar el script de la siguiente forma:

c:\>.\GetFolderSize.ps1

Eso es todo amigos.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Autenticación Mixta en SharePoint 2013 no se lleva bien con las SharePonit Apps

El problema

Recientemente habilitamos para un cliente en Azure un SharePoint Foundatio 2013 con autenticación mixta, Windows y Azure AD.   Pero las apps no respondian adecuadamente, mostrandonos el error típico de las apps cuando no son correctamente configuradas. 

Al parecer cuando esta en modo mixto las apps no saben como resolver la autenticación.  Cuando retornabamos al Windows las apps comenzaron a funcionar correctamente.

Pensamos que el problema era la autenticación con los usuarios de AD de Azure, aunque nos parecia incorrecta esta apreciación.   Por lo que se nos ocurrió ahislar el problema y en vez de adicionar otro proveedor de autenticación a la aplicación Web existente lo que se nos occurió fue extender la aplicación Web.

La Estrategía y solución

Extender la aplicación Web es una opción de SharePoint que lo que hace es hacer una copia del Web Site del IIS actual en otro Web Site y diferenciarlo por el nuevo nombre de la aplicación Web.  Si deseamos utilizar el puerto http es necesario utilizar un host header diferente.   Por lo que para este ejemplo utilizaremos el nombre extranet.midominio.com  para diferenciarlo de la zona predeterminada de la Aplicación Web, que diremos se llama portal.midominio.com.   Al momento de extenderla le indicamos que el proveedor de autenticación ya no era windows sino el Azure Provider la etiqueta que le pusimos al configurar al autenticación de Azure Active Directory.

Con eso nuestra sorpresa fue que las Apps empezaron a funcionar correctamente.  Ya que teniamos una entrada por autenticación Windows a través del url http://portal.midominio.com y para usuarios del Azure AD la dirección http://extranet.midominio.com

Enalces de referencia relacionados al tema:

Usar Active Directory de Microsoft Azure para autenticación de SharePoint 2013

https://technet.microsoft.com/es-es/library/dn635311.aspx

Extender las aplicaciones web basadas en notificaciones en SharePoint 2013

https://technet.microsoft.com/es-es/library/gg276325.aspx

Configuración de un entorno para aplicaciones de SharePoint (SharePoint 2013)

https://technet.microsoft.com/es-es/library/fp161236.aspx

En conclusión hasta hoy podré decir que la recomendación es no utilizar la autenticación mixta en SharePoint adicionando el proveedor de autenticación en la misma Aplicación Web, sino mejor extender la Aplicación Web con el siguiente método de autenticación.

Espero pueda salvarles el dia amigo lector.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Enterese lo nuevo en SharePoint 2016

 

Nacida en la  nueva esta nueva versión nos prometen Cero DownTime, orientado a las necesidades de los usuarios,

Servicio de Búsqueda Hibrida

Permitirá habilitar el contenido mixto o solo para un ambiente Nube o Local.  Esto permitirá que la Aplicación Delve que analiza el trabajo realizado en SharePoint este disponible en una vista cenntralizada desde delve y veas tu trabajo más reciente y frecuente al alcance de una vista en Delve, con contenido mixto en SharePoint On Prem o bien en la nube en Office 365 con SharePoint Online.

MinRoles

Para IT Pros… la instalación nos presenta una variación, la definición del Rol del Servidor el cual instala los bits optimizados para el rol en especifico.

El App Laucher de Office 365 estará disponible para SharePoint 2016 permitiendo acceso rápido a las aplicaciones favoritas del usuario.

Nuevo centro de cumplimiento para administración del cotenido.  Ahora de forma mas clara y centralizada hay un lugar centralizado donde se puede definir politicas de retención de documentos, colecciones de sitios y plantillas.

 

Nueva Interfaz de Usuario para dispositivos Moviles

La idea primaria del equipo de SharePoint es traer SharePoint al usuario final desde los dispositivos móviles, se esta realizando esfuerzos importantes para mejorar esta interfaz y que pueda operase SharePoint de una forma ágil y habitual para el usuario con dispositivos moviles (tabletas, telefonos de cualquier proveedor)

 

SharePoint user voice

Por ultimo el equipo de Microsoft esta escuchando a los usuarios que les gusta y que no, Que quisieran tener, que quisieran que se mejorará, si quieres aportar abajo te dejo el enlace para hacerlo.

https://sharepoint.uservoice.com/

Asi que esperamos el próximo año un producto renovado, mejorado y productivo.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Dando formato a una carta en un elemento Web de SharePoint

Hay veces que necesitamos construir el formato de una carta para ser desplegada en un elemento Web.  Para darle formato necesitamos escribir código HTML de forma dinámica y luego desplegarla al momento que elemento Web es cargado en la página de SharePoint.

Lo primero es definir un control asp.net Literal ya que este escribe exactamente lo que le enviemos sin realizar ninguna conversión, esto nos permitirá enviar código HTML dentro del texto.  Asi como se demuestra a continuación:

   <asp:Literal runat="server" ID="uiCarta"></asp:Literal>

En el código adyacente o Code Behind podemos encontrar la siguiente declaración.

public string Carta
       {
           set
           {
               uiCarta.Text = value;
           }
       }

Definimos una propiedad tipo String y definimos el valor a ingresar es para la propiedad Text del control Literal.

Para facilitar su comprensión asumiremos de la definición al obtendremos de codigo definido a continuacion.

var carta = @”

Señores

<b>[NombreUsuario]</b>

<br>

[Departamento]

<br><div style=”text-align:justify”>

Por este medio deseo indicarle…. blalablalallal

</div><br>

<table style=”width=100%;”>

<tr>

<td style=”width=50%;”>

Vo.Bo.

</td>

<td style=”width=50%;”>

Revisado

</td>

</tr>

</table>

”;

carta= carta.replace(“[Usuairo]”,SPContext.Current.Web.CurrentUser.Name).Replace(“[Departamento]”,userDepartmentVariable);

_vista.Carta = carta;

El Resultado es el siguiente:

Eso es todo.   Una solución sencilla para un requerimiento común.

Code4Fun!,

Juan Manuel Herrera Ocheita

Ojo con las dependencias al desinstalar una solución de granja en SharePoint

Las soluciones de granja de SharePoint siguen siendo requeridas por los clientes con instalaciones On Premises.  Como es una solución de granja afecta a toda la granja de SharePoint y esto incluye las Aplicaciones Web configuradas en la granja a pesar que cuando lo instalé indique que era sobre una aplicación Web en especifico.

El Escenario

AjaxControlToolKit.dll es una libreria que nos ayudará a mejorar los controles disponibles en asp.net y como empresa nosotros la utilizamos en las aplicaciones que entregamos a nuestros clientes sobre SharePoint Server.  Esta libreria no le va bien instalada en el Global Assembly Cache, es mejor instalarla en el directorio bin de la aplicación Web elegida.

Esto lo hacemos especificando en el Package del Proyecto de SharePoint Visual Web Part que incluya el ensamblado a nivel de la WebApplication, como se muestra en la imagen de abajo.

El Problema

En esta granja de SharePoint habian otras aplicaciones Web donde habiamos instalado otras soluciones utilizando la libreria AjaxControlToolKit.dll.   Lo que sucedio fue que al actualizar la solución en la granja la desinstalamos y la volvimos a instalar, a través de los comandos uninstall-SPSolution y Remove-SPSolution, eliminó de las otras aplicaciones Web la libreria AjaxControlToolKit.dll.  Y aunque volvimos a instalar la solución que estabamos probando con add-SPSolution y install-SPSolution, no volvio a instalar la libreria en las demás aplicaciones Web.

Los comandos ejecutados para re-instalar fueron los siguientes:

PS C:\> Uninstall-SPSolution –Identity infoware.doc.publicadosui.wsp 

PS C:\> Remove-SPSolution -Identity infoware.doc.publicadosui.wsp

PS C:\> Add-SPSolution –LiteralPath c:\instaladores\infoware.doc.publicadosui.wsp

PS C:\> Install-SPSolution -Identity infoware.doc.publicadosui.wsp -WebApplicat
on http://sitioprueba -GACDeployment

La Solución

Al repotarnos el error el usuario final, lo que hicimos fue copiar la libreria AjaxControlToolKit.dll en las aplicaciones Web que nos reportaron el error.  La solución fue sencilla, pero nos sorprendió la forma de comportarse al desintalar la solución de granja sobre el resto de aplicaciones Web.

Lexión Aprendida

A pesar que dirigimos la instalación a una aplicación Web por cuanto es una solución de Granja necesitamos realizar un respaldo del directorio bin y validar las librerias dependientes que coicidan con la solución que estamos instalando nosotros, y validar que continuen funcionando como lo solian hacer.

Code4Fun & Share2KeepBusy, 

Juan Manuel Herrera Ocheita

Cannot unregister UpdatePanel since it was not registered with ScriptManager en un elemento Web de SharePoint

 

El error es el siguiente:

El error es algo confuso, ya que posiblemente ya hayamos definido el update panel en otro elemento web y no nos da el error.

El problema es en la definición declarativa de los elementos en SharePoint.   En mi particular caso el elemento Web estaba siendo implementado dentro de la solución WSP adicionandolo a una pagina que despliega el elemento web, como se muestra a continuación el código de la página.

Si puedes observar el WebPartZone se llama wpSeguros2 pero en la definición de Elements.xml del Modulo que se utiliza para crear una pagina que incluya el elemento web cuando se instala la solución.  (Si quieres saber mas de como agregar una pagina de elementos web que se incluya dentro de tu solución pueder ver el siguiente enlace https://amalhashim.wordpress.com/2013/02/14/sharepoint-deploy-webpart-page-using-module/)

El problema se debio a que no coincide el WebPartZone ya que se llama wpSeguros y allí esta todo el problema, ya que SharePoitn si incluye el elemento Web a la página pero en una nueva zona que no esta definida en la plantilla y esto le afecto el updatepanel.

 

Esto es todo espero a verles ayudado.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Desarrollando soluciones WSP separando las responsabilidades en SharePoint

Separar las responsabilidades implica escribir el código de tal forma que el código solo tenga una responsabilidad y delege a otro segmento de codigo la responsabilidad que no le compete al codigo escrito.  Este principio en el desarrollo de software se aplicado a Desarrollo en N-Capas, Diseño basado en Dominio.  Pero en SharePoint es un reto desarrollar de esta forma ya que deforma predeterminada todo se instala en el GAC y los cambios del codigo se ven reflajados hasta que el GAC se actualice.  Y en ambientes de producción en la implementación es un stress inecesario y riesgo.

Que podemos hacer?  Podemos definir a nivel quel Paquete de SharePoint que los ensamblados se instalen en la Web Application en vez del Global Assembly Cache.  Para ello también es necesario firmar cada ensambaldo.

Primero separamos en Proyectos de librerias de clases exceptuando el Project de Visual WebPart de SharePoint.

En el proyecto común tenemos la definición de las entidades de negocio y las interfases de los repositorios y servicios.

El proyecto de Repositorio tenemos las implementaciones de el código de acceso a base de datos de las operaciones básicas hacia la base de datos o CRUD (Create Read Update & Delete).  Ninguna lógica de negocio, como validaciones u operaciones entre diferentes Repositorios.

El proyecto de Servicios es donde se encuentra la lógica del negocio e invoca a los repositorios necesarios para cumplir con la regla de negocio.

Este proyecto es otro Repositorio Especializado para invocar las librerias de SharePoint y acceder los objetos de SharePoint, separado de la base de datos ya que no comparten las mismas librerias.

Para finalizar el proyecto de SharePoint que representa la Capa de Presentación o Visualización.  Aquí podemos aplicar el patrón MVP o Model View Presenter.

Detalles a Conocer.

1) Para cada Ensamblado firmamos el emsamblado esto lo relizamos en las propiedades del proyecto en la opción Signing.

2) Referenciar los proyectos según su dependencia que debe de ser jerarquica y no cruzada, evitar la referencia ciclica.

En el paquete agregamos los ensamblados que deben de incluirse en la solución WSP.

Y debemos indicar que es a nivel de Web Application y no a nivel de GAC.

Y eso es todo.  Una ultima nota si en caso le reporta que no encuentra algunas referencias solo seleccione la opción Clean Solution en Build. 

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Cinta o ribbon se oculta al adicionar elemento Web personalizado en SharePoint

A veces se desea integrar personalizaciones con funcionalidades de SharePoint.  Este es el caso de adicionar en la página de una biblioteca en SharePoint un elemento Web Personalizado.

El problema radica que cuando adicionamos este elemento Web Personalizado la barra superior o Ribbon de administración de la biblioteca desaparece.

 

Para hacerla aparecer es necesario agregar el siguiente código JavaScript dentro de la declaración html del elemento Web Visual:

<script type=”text/javascript”>

setTimeout(function() { var elem = document.getElementById("MSOZoneCell_WebPartWPQ2"); if(elem != null) { var dummyevent = new Array(); dummyevent["target"] = elem; dummyevent["srcElement"] = elem; WpClick(dummyevent); _ribbonStartInit("Ribbon.Browse", true) } }, 2000);

</script>

El resultado será ver la barra de configuración esperada.

 

Referencia de la solución aplicada:

http://stackoverflow.com/questions/4848892/list-tools-tab-is-no-longer-available-after-adding-webpart-to-the-page

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Clases Fuertemente Tipados en una ListView para un WebPart en SharePoint

El control ListView nos permite desplegar colecciones de Clases definidas en codigo (Ej.:List<MiEntidad> ).  

Normalmente utlizamos el metodo Eval(“Atributo de la Clase”) para desplegar la información que enlazamos en el control con el evento miListView.DataBind().

Una mejor forma es utilizando el Atributo ItemType del control ListView.  De la siguiente forma:

<asp:ListView ID="uiListado" runat="server" ItemPlaceholderID="DetalleListado"
          OnPagePropertiesChanged="uiListado_PagePropertiesChanged"
          ItemType="Infoware.Comun.Dominio.Entidad.MiClase">

En el detalle lo definimos de la siguiente forma:

<ItemTemplate>
      <tr class="">
          <td id="Td2" runat="server"><%#: Item.Perfil %></td>
          <td id="Td3" runat="server"><%#: Item.Plazas %></td>
          <td id="Td4" runat="server"><%#: Item.Seccion %></td>
          <td id="Td10" runat="server"><%#: Item.Departamento %></td>
          <td id="Td7" runat="server"><%#: Item.PlazasTotal %></td>
          <td id="Td9" runat="server"> Del: <%#: Item.InscripcionesFechaInicial.HasValue? Item.InscripcionesFechaInicial.Value.ToString("dd/MM/yyyy"):"" %> 
              Al: <%#: Item.InscripscionesFechaFin.HasValue?Item.InscripscionesFechaFin.Value.ToString("dd/MM/yyyy"):"" %></td>
          <td id="Td8" runat="server"><%#: Item.InscripscionesFechaFin.HasValue? Item.InscripscionesFechaFin.Value.ToString("dd/MM/yyyy"):"" %></td>
           <td id="Td1" runat="server"><%#: Item.ExamenLugar %></td>
          <td id="Td5" runat="server"><%#: Item.TipoConvocatoria %></td>
        
          <td class="clasebotones">
              <asp:LinkButton ID="uiVer" runat="server"  ToolTip="Ver"
                  OnClick="evento_ver" CommandArgument='<%#: Item.Id %>' ValidationGroup='<%#: Item.CircularNo %>'
                  OnClientClick="javascript:setFormSubmitToFalse()">Circular PDF</asp:LinkButton>
           
              <asp:LinkButton ID="LinkButton3" runat="server"  ToolTip="Ver"
                  OnClick="evento_Recrear" CommandArgument='<%#: Item.Id %>' ValidationGroup='<%#: Item.CircularNo %>'
                  OnClientClick="javascript:setFormSubmitToFalse()">Recrear Circular PDF</asp:LinkButton>
          </td>
      </tr>
  </ItemTemplate>

Como podemos observar utilizamos la clase Item.NombreAtributoClaseDefiniaEnItemType.

Uselo es práctico y evita errores de escritura.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Interminable error Could not load file or assembly en una solución de granja de SharePoint 2013

Este error nunca terminaba y se alternaba de dlls referenciados indicando diferentes versiones que no eran las referenciadas, por más que lo reinstale, borre el cache de asp.net, reinicie el IIS no terminaba, hasta que encontré el único consejo que en mi caso si me sirvió, el cual es el siguiente:

Copia el DLL del problema o bien todos los que hace referencia tu solución, en mi caso eran dos al directorio bin de la carpeta debug del proyecto de SharePoint y con ello el problema si desaparece.

En mi caso los DLL´s que tenia referenciados eran:

Aspose.words.dll y AjaxControlToolKit.dll.

Y esto es porque el directorio bin tiene precedencia del GAC en la aplicación Web siempre y cuando no se especifique la versión. 

Una de las ventajas de copiar el DLL en el directorio bin de la aplicación Web que se va utilizar es que no tiene que reiniciar el servidor y el riesgo se reduce porque solo afecta la aplicación Web que le interesa.  Esto también puede ser una desventaja si existen varias Aplicaciones Web que utilizan el mismo DLL.

Más información en: http://www.hanselman.com/blog/BINDeployingASPNETMVC3WithRazorToAWindowsServerWithoutMVCInstalled.aspx

Así que amigos mi recomendación es copien los DLL en el directorio Bin de la Aplicación Web que necesitan y afecten el servidor lo menos posible, tomen en cuenta que si el dll es utilizado en otras aplicaciones Web deberán actualizarlas también allí, pero esto es mejor a mi parecer que utilizar el GAC ya que este debe de actualizarse el cache reiniciando el IIS y algunas veces hasta el servidor mismo.

Code4Fun!,

Juan Manuel Herrera Ocheita

Creando un sitio de recuperación para SharePoint Foundation en Azure

El siguiente escenario es ficticio pero posible, donde oficinas de representación cuentan con un único servidor físico para: validar usuarios, administrar impresoras, compartir archivos, portal colaborativo e inclusive respaldar su información.

La necesidad:

Resguardar su información y asegurar que el plan de recuperación funcione en caso de desastre.

La solución:

Azure nos permite crear escenarios confiables para garantizar la continuidad del negocio.  No solo se trata de mover o copiar lo que tenemos localmente sino aplicar buenas prácticas que garanticen la continuidad del negocio.

En el siguiente diagrama mostramos el siguiente escenario que iré explicando por etapas.

Etapa 1: Crear ambiente híbrido

Primero lo primero y es crear un ambiente hibrido entre la red local y Azure.  Para ello hacemos lo siguiente:

1. Creamos una suscripción en Azure
2. Definimos una red virtual en Azure
3. Creación un enlace VPN Sitio a Sitio entre el dispositivo VPN del cliente y Azure

 

Resultado:   Desde Azure podemos ver la red local y desde la red local podemos ver la red virtual de Azure

Etapa 2: Garantizar la autenticación Usuarios ambos ambientes

Esto es lo primordial luego de crear el ambiente hibrido especialmente que en esta caso tienen un único servidor que si les sucede algo la red es inaccesible.  Para este caso no utilizaremos Azure Active Directory ya que este solo cubre la autenticación de los usuarios de las aplicaciones en la nube y no la redundancia que deseamos lograr en caso de falla del servidor local.  

Los pasos son los siguientes:

1. Crear un Sitio en el Active Directory local para Azure
2. Crear una subnet para Azure
3. Crear un grupo de Afinidad en el portal de Azure
4. Crear un Maquina Virtual en Azure con Windows Server 2012 TIPO A1 con disco 10 GB.  Tenga el cuidado cuando crear la maquina virtual en azure seleccionar Create an avialability set en la casilla AVAILABILITY SET para asegurar la alta disponibilidad en
5. Instalar Servicios de dominio de Active Directory y promover este servidor a un controlador de dominio de réplica en un dominio de Active Directory existente e incluya el servicio del DNS.
6. Repetir pasos 4 y 5 para el Controlador de Dominio no. 2.

https://azure.microsoft.com/en-us/documentation/articles/virtual-networks-install-replica-active-directory-domain-controller/

Resultado: Con este etapa 2 garantizamos la alta disponibilidad para la autenticación de usuarios locales en ambos amientes y la resolución de nombres para mantener la red corriendo.

Etapa 3: Crear las copias de Respaldo en la nube

Ahora  lo que sigue es almacenar las copias de respaldo en Azure para garantizar su restauración, esto es mucho más seguro ya que geográficamente esta a miles de millas de distancia, tiene 3 copias de forma predeterminada en Azure y si seleccionamos la Georeplicación estarán 3 copias más replicadas a 4 mil millas de distancia del centro de datos primario.

Los pasos a realizar son:

1. Crear un backup Vault en el portal de Azure  (Seleccione GeoRepliación)
2. Descargar la credencia de Vault
3. Descargar e instalar el agente Backup
4. Calendarice el Backup
5. Pruebe el Backup

https://azure.microsoft.com/en-us/documentation/articles/backup-configure-vault/

Resultado:   Tiene la copia de respaldo encriptado  a miles de millas de distancia con 3 copias encriptado y 3 copias mas a 4 mil millas de distancia del centro de datos primario.  Con eso se garantiza que tendrá disponible el respaldo cuando lo necesite.

Etapa 4:  Crear las maquinas virtuales que desea recuperar en caso de desastre

Ahora vamos a crear las máquinas virtuales para los servicios Impresión y colaboración con SharePoint Foundation.  A diferencia del ambiente local donde en un solo servidor tienen todos los servicios creados aquí separaremos los servicios en 3 servidores, esto reducirá el riesgo y nos permitirá fácilmente habilitar alta disponibilidad cuando así lo deseemos.

Servidor de Impresora

Aunque es cuestionable tener el servidor de impresora en la nube por el tiempo de atraso que esta sufre, mejor es tenerla lejos que no tenerla.

Procedemos a realizar los siguientes pasos:

1. Cree un Servidor Virtual con Windows Server 2012 en el portal de Azure
2. Adicione el Rol de Servicios de Impresión en el Servidor de Windows Server 2012
3. Exporte del servidor local Windows Server 2008 r2 las impresoras a través de Print Management
4. Importe en el Servidor en Azure las Impresoras
5. Pruebe el nuevo servidor con una estación de trabajo de la red y vea que funcione

Servidor de base de datos

Este servidor es para almacenar las bases de datos de SharePoint Foundation.  Con la versión SQL Server 2012 Standard es suficiente para esta versión ya que no tiene servicios sofisticados que requieran de inteligencia de negocios.  Aquí podemos decidir de utilizar una licencia disponible para SQL Server o bien que nos incluya el licenciamiento.  Si poseemos MSDN podemos utilizar una de estas licencias ya que es un centro de datos para desastres y no para producción. SharePoint no soporta SQL Azure o Azure Database por lo que necesitamos una virtual con Windows Server y SQL Server.

Por ser un servidor de base de datos para SharePoint por la naturaleza de SharePoint que es un workload, sugerimos un servidor A6.

Los requisitos de SQL Server para SharePoint Foundation puede consultarlos en los siguientes enlaces:

https://technet.microsoft.com/es-gt/library/cc262485.aspx

http://blogs.msmvps.com/shane/2012/09/17/a-simple-install-of-sql-server-2012-for-sharepoint-server-2013-or-2010/

Luego de instalado SQL Server será adecuado restaurar los respaldos de las bases de datos almacenadas en Azure y así validar que los respaldos funcionan.

Servidor Web (Front-End SharePoint)

Para este servidor sugerimos un A5, una configuración aceptable para un servidor Web con SharePoint instalado.

A continuación el enlace oficial para descargar SharePoint Foundation 2013:http://www.microsoft.com/es-es/download/details.aspx?id=35488

Los pasos son lo siguientes:

1. Cree la virtual en el portal de Azure con Windows server 2012 con una máquina A5 y dos discos uno de 250 GB y el otro con el espacio necesario para almacenar el índice, logs y otros archivos (100 GB).
2. Descargue la media de SharePoint Foundation 2013.
3. Reutilice las cuentas que uso para instalar el SharePoint local o bien cree nuevas.
4. Ejecute la media, instale los prerrequisitos de SharePoint 2013.
5. Instale los bits de SharePoint 2013 y conéctese al nuevo servidor de base de datos en Azure.
6. Configure todos los servicios, cree la aplicación Web para hospedar las bases de datos recuperadas.
7. Desmonte la base de datos nueva que se creo al crear la aplicación Web.
8. Monte la base de datos restaurada a la nueva aplicación Web creada en el servidor de SharePoint en Azure.

Servidor de Archivos

Este servidor no es necesario crearlo ya que podemos utilizar el servicio de File Storage en Azure o bien utilizar SharePoint como repositorio de Archivos.  En este caso vamos a crear el servicio de File Storage de Azure para disponer el servicio cuando se necesite.  

Los pasos son los siguientes:

1. Crear una cuenta de Almacenamiento en Azure.
2. Crear un File Share en Azure para ello es necesario powershell.
3. Mapee un drive al File Share.

https://azure.microsoft.com/en-us/documentation/articles/storage-dotnet-how-to-use-files/

Bueno el ultima etapa será automatizar el proceso de recuperación con Site Recovery Services pero esto lo dejaremos para otro artículo, suficiente información para digerir y evaluar cada una de las opciones disponibles para migrar nuestro centro de datos incluyendo SharePoint 2013 a la nube de Microsoft: Azure.

Espero sea de su utilidad Azure4Fun & SharePoint4Fun!,

Juan Manuel Herrera Ocheita

API´s disponibles para el Desarrollo de Aplicaciones en SharePoint

Las Interfaces de Programación de Aplicaciones o API en SharePoint tienen su historia y por ello hay una variedad de opciones disponibles hoy en día ningún API se aplica a todos los casos y en necesario conocer su historia para conocer su aplicación.

.NET Server Type o Modelo de Objetos de Servidor para SharePoint

Empecemos con .NET Server Type o el Modelo de Objetos de Servidor para SharePoint.  Esta API nació con la versión SharePoint 2007, la cual emergía de a poco, en Visual Studio 2005 no se tenía ningún plug-in al principio para soportar el desarrollo de soluciones para Extender SharePoint y había que definir manualmente archivos XML que definían las FEATURES que activarían las funcionalidades en los sitios de SharePoint.  Los Elementos web recuerdo eran y son en realidad controles de Usuario de ASP.NET que se enmascaraban a través de un archivo de XML para convertirlo en un elemento Web que reconociera SharePoint.

 

Recomiendo el siguiente enlace:Mejores Prácticas: Problemas comunes cuando utiliza el modelo de objetos de servidor

A continuación segmento de código del Modelo de Objeto de Servidor para SharePoint 2007-2010 y 2013 soluciones de granja (WSP)

sing (SPSite siteCollection = new SPSite("http://intranet.adicodes.com"))
{
  using (SPWeb site = siteCollection.OpenWeb())
  {
    try
    {
      SPList taskList = site.GetList("/Lists/MyTasks");
      Console.WriteLine("Success!");
    //Create a new item
SPListItem newItem = list.Items.Add;
newItem["Title"] = "Created Item " + DateTime.Now.ToLongDateString;
newItem.Update; //NOTE: Update must be called
 
//Read items by binding to grid
SPListItemCollection items = list.Items; //NOTE: This loads all items, folders, and fields!
itemGrid.DataSource = items; // Binding to grid to display items, just for scenario
itemGrid.DataBind;
 
//Delete the first item
list.Items[0].Delete;
 
//Update the first item
//Note the use of a temporary SPListItem
SPListItem updateItem = list.Items[0];
updateItem["Title"] = "Updated Item " + DateTime.Now.ToLongDateString;
updateItem.Update;

    }
    catch(FileNotFoundException)
    {
      Console.WriteLine("List does not exist");
    }
  }
}

CSOM o Client SharePoint Object Model

Este modelo de objetos para SharePoint que se ejecuta de lado del cliente surgió en la versión SharePoint 2010 que introdujo las SandBox Solution que pretendía apoyar la adopción de Silverlight, el cual era un “motor” tipo Java que ejecutaría el código en cualquier dispositivo y sistema operativo, bueno esa era la intención Microsoft desistió al ver nuevas tendencias en el mercado como la nube y saco a Silverlight y como consecuencia el modelo sandbox también marcándolo como obsoleto en las próximas versiones.  El nombre Sandbox solution se le debe a que se ejecuta en una caja cerrada es decir ya no se tiene acceso al servidor sino solamente a la colección de sitios donde se cargue la solución. 

Una de las interioridades de este tipo de solución es que el empacado era el mismo que las soluciones de granja de solución wsp, pero con el alcance limitado a colección de sitios y que no podía ejecutar código que instanciara el Modelo de Objetos de Servidor de las soluciones de granja del modelo anterior.  En SharePoint 2010, entonces hay dos posibilidades desarrollar soluciones de granja y soluciones Sandbox una consume el modelo de objetos de Servidor y la otra el modelo de objetos cliente.  No todo el modelo de objetos de Servidor se dispone en la versión CSOM ya que el alcance es mucho mas limitado en las soluciones Sandbox y fundamentalmente se tiene acceso al contenido dentro de los sitios de SharePoint, bibliotecas, listas, grupos y usuarios.

// Create ClientContext object

ClientContext ctxObj = new ClientContext("http://mysitecllection/mysite/");

// Get Site Collection object

Site siteObj = ctxObj.Site;

ctxObj.Load(siteObj);

// Get web object

Web webObj = siteObj.RootWeb;

ctxObj.Load(webObj);

// Build query to the list "EmployeeList"

List empListObj = webObj.Lists.GetByTitle("EmployeeList");

ctxObj.Load(empListObj);

// Execute the query against ClientContext

ctxObj.ExecuteQuery();

// Get the Title

Console.WriteLine(empListObj.Title);

// Build a query for all items in the list

CamlQuery query = new CamlQuery();

query.ViewXml = "<View/>";

ListItemCollection allEmploys  = empListObj.GetItems(query);

ctxObj.Load(allEmploys);

// Execute the query against ClientContext

ctxObj.ExecuteQuery();

// Get all the results

foreach (ListItem listItem in allEmploys) {

Console.WriteLine("Id: {0} - Firstname: {1} - LastName: {2} - Department: {3}",

listItem["ID"],

listItem["FirstName"],

listItem["LastName"],

listItem["Department"]

);

}

REST endpoint

También en la versión SharePoint 2010 vino una implementación de Rest para el contenido de SharePoint, también limitado al contenido de SharePoint como su contraparte CSOM.   Pero no fue sino hasta la versión 2013 que ya vino incluido desde su edición original.  La intención de Microsoft es proveer un protocolo de comunicación standard para que el contenido de SharePoint fuese consumido por cualquier tipo de aplicación.

PartsDataContext context = new PartsDataContext(
  new Uri("http://localhost/sites/sharepointlist/_vti_bin/listdata.svc"));

var partsQuery = (DataServiceQuery<PartsItem>)
      context.Parts.Where(p => p.SKU.StartsWith(SearchSku))
        .Select(p => new PartsItem { Title = p.Title, 
                                     SKU = p.SKU, 
                                     Id = p.Id, 
                                     Description = p.Description 
                                   });

// Execute query.
query.BeginExecute(DisplayParts, query);

JSOM object

Con el advenimiento de la versión SharePoint 2013 trabajo consigo un nuevo modelo de desarrollo llamado App Model o Modelo de Aplicación, esto para apoyar la estrategia de Microsoft en la nube y proveer un modelo de extensibilidad de SharePoint en la nube a través de Office 365.  Para la versión SharePoint 2013 en premisas persiste el modelo de solución de granja que tiene acceso total a los recursos del servidor y el modelo Apps.  Pero para la versión en la nube solo esta disponible el modelo de Aplicación.  

Fundamentalmente solo se pueden desarrollas dos tipos de aplicaciones bajo este nuevo modelo  SharePoint Hosted y Provider Hosted.   La primera básicamente consume el contenido de SharePoint por medio de javascript y este modelo provee un conjunto de librerías de Json para consumir el contenido de SharePoint el cual devuelve los resultados en formato Json.  Si elegimos el Modelo Provider Hosted podemos utilizar cualquiera de las API Cliente (Csom, Jsom o Rest) pero el código debe de hospedarse fuera de SharePoint.

Ejemplo:

function createListItem(siteUrl,listName, itemProperties, success, failure) {

    var itemType = getItemTypeForListName(listName);
    itemProperties["__metadata"] = { "type": itemType };

    $.ajax({
        url: siteUrl + "/_api/web/lists/getbytitle('" + listName + "')/items",
        type: "POST",
        contentType: "application/json;odata=verbose",
        data: JSON.stringify(itemProperties),
        headers: {
            "Accept": "application/json;odata=verbose",
            "X-RequestDigest": $("#__REQUESTDIGEST").val()
        },
        success: function (data) {
            success(data.d);
        },
        error: function (data) {
            failure(data);
        }
    });
}


// Get List Item Type metadata
function getItemTypeForListName(name) {
    return "SP.Data." + name.charAt(0).toUpperCase() + name.split(" ").join("").slice(1) + "ListItem";
}

//specify item properties
var itemProperties = {'Title':'Order task','Description': 'New task'};
//create item
createListItem(_spPageContextInfo.webAbsoluteUrl,'Tasks',itemProperties,
   function(entity){
      console.log('New task ' + entity.Title + ' has been created');
   },
   function(error){
      console.log(JSON.stringify(error));
   }
);

API disponibles en SharePoint para el desarrollo de Aplicaciones.

.NET Server type	CSOM type	JSOM object	REST endpoint
SPAttachmentCollection	AttachmentCollection	SP.AttachmentCollection object (sp.js)	…/_api/web/lists('<list id>')/items(<item id>)/attachmentfiles
SPBasePermissions	BasePermissions	SP.BasePermissions object (sp.js)
SPCalendarType	CalendarType	SP.CalendarType enumeration (sp.js)
SPChangeCollection	ChangeCollection	SP.ChangeCollection object (sp.js)	…/_api/web/getchanges(changequery)
SPChangeSite	ChangeSite	SP.ChangeSite enumeration (sp.js)
	ClientContext	SP.ClientContext object (sp.js)	…/_api/contextinfo
SPContentType	ContentType	SP.ContentType object (sp.js)	…/_api/web/contenttypes('<content type id>')
SPContentTypeCollection	ContentTypeCollection	SP.ContentTypeCollection object (sp.js)	…/_api/web/contenttypes
SPContext		SP.RequestContext object (sp.js)
SPEventReceiverDefinition	EventReceiverDefinition	SP.EventReceiverDefinition object (sp.js)	…/_api/web/eventreceivers
SPEventReceiverDefinitionCollection	EventReceiverDefinitionCollection	SP.EventReceiverDefinitionCollection object (sp.js)	…/_api/web/eventreceivers(eventreceiverid)
SPEventReceiverDefinitionCreationInformation	EventReceiverDefinitionCreationInformation	SP.EventReceiverDefinitionCreationInformation object (sp.js)
SPEventReceiverType	EventReceiverType	SP.EventReceiverType enumeration (sp.js)
SPFeature	Feature	SP.Feature object (sp.js)	…/_api/web/features(featureid)
SPFeatureCollection	FeatureCollection	SP.FeatureCollection object (sp.js)	…/_api/web/features
SPFeatureDefinitionScope	FeatureDefinitionScope	SP.FeatureDefinitionScope enumeration (sp.js)
SPField	Field	SP.Field object (sp.js)	…/_api/web/fields('<field id>')
SPFieldCalculated	FieldCalculated	SP.FieldCalculated object (sp.js)	…/_api/web/fields('<field id>')
SPFieldChoice	FieldChoice	SP.FieldChoice object (sp.js)	…/_api/web/fields('<field id>')
SPFieldCollection	FieldCollection	SP.FieldCollection object (sp.js)	…/_api/web/fields
SPFieldComputed	FieldComputed	SP.FieldComputed object (sp.js)	…/_api/web/fields('<field id>')
SPFieldCurrency	FieldCurrency	SP.FieldCurrency object (sp.js)	…/_api/web/fields('<field id>')
SPFieldLink	FieldLink	SP.FieldLink object (sp.js)	…/_api/web/contenttypes('<content type id>')/fieldlinks('<field link id>')
SPFieldLookupValue	FieldLookupValue	SP.FieldLookup object (sp.js)
SPFieldMultiChoice	FieldMultiChoice	SP.FieldMultiChoice object (sp.js)	…/_api/web/fields('<field id>')
SPFieldMultiLineText	FieldMultiLineText	SP.FieldMultiLineText object (sp.js)	…/_api/web/fields('<field id>')
SPFieldNumber	FieldNumber	SP.FieldNumber object (sp.js)	…/_api/web/fields('<field id>')
SPFieldText	FieldText	SP.FieldText object (sp.js)	…/_api/web/fields('<field id>')
SPFieldUrl	FieldUrl	SP.FieldUrl object (sp.js)	…/_api/web/fields('<field id>')
SPFieldUrlValue	FieldUrlValue	SP.FieldUrlValue object (sp.js)
SPFieldUser	FieldUser	SP.FieldUser object (sp.js)	…/_api/web/fields('<field id>')
SPFile	File	SP.File object (sp.js)	…/_api/web/getfilebyserverrelativeurl('/<folder name>/<file name>')
SPFileCollection	FileCollection	SP.FieldCollection object (sp.js)	…/_api/web/getfolderbyserverrelativeurl('/<folder name>')/files
SPFolder	Folder	SP.Folder object (sp.js)	…/_api/web/getfolderbyserverrelativeurl('/<folder name>')
SPForm	Form	SP.Form object (sp.js)	…/_api/web/lists(guid'<list id>')/forms('<form id>')
SPGroup	Group	SP.Group object (sp.js)	…/_api/web/sitegroups(<group id>)
SPGroupCollection	GroupCollection	SP.GroupCollection object (sp.js)	…/_api/web/sitegroups
SPLanguage	Language	SP.Language object (sp.js)
SPList	List	SP.List object (sp.js)	…/_api/web/lists(guid'<list id>')
SPListCollection	ListCollection	SP.ListCollection object (sp.js)	…/_api/web/lists
SPListDataSource	ListDataSource	SP.ListDataSource object (sp.js)
SPListItem	ListItem	SP.ListItem object (sp.js)	…/_api/web/lists(guid'<list id>')/items(<item id>)
SPListItemCollection	ListItemCollection	SP.ListItemCollection object (sp.js)	…/_api/web/lists(guid'<list id>')/items
SPListTemplateType	ListTemplateType	SP.ListTemplateType enumeration (sp.js)
SPNavigation	Navigation	SP.Navigation object (sp.js)	…/_api/web/navigation
SPNavigationNode	NavigationNode	SP.NavigationNode object (sp.js)
SPPrincipal	Principal	SP.Principal object (sp.js)
SPQuery
SPRecycleBinItem	RecycleBinItem	SP.RecycleBinItem object (sp.js)	…/_api/web/RecycleBin(recyclebinitemid)
SPRecycleBinItemCollection	RecycleBinItemCollection	SP.RecycleBinItemCollection object (sp.js)	…/_api/web/RecycleBin
SPRegionalSettings	RegionalSettings	SP.RegionalSettings object (sp.js)	…/_api/web/RegionalSettings
SPRoleAssignment	RoleAssignment	SP.RoleAssignment object (sp.js)	…/_api/web/roleassignments(<principal id>)
SPRoleAssignmentCollection	RoleAssignmentCollection	SP.RoleAssignmentCollection object (sp.js)	…/_api/web/roleassignments
SPRoleDefinition	RoleDefinition	SP.RoleDefinition object (sp.js)	…/_api/web/roledefinitions(<role definition id>)
SPRoleType	RoleType	SP.RoleType enumeration (sp.js)
SPSecurableObject	SecurableObject	SP.SecurableObject object (sp.js)
SPSite	Site	SP.Site object (sp.js)	…/_api/site
SPTimeZone	TimeZone	SP.TimeZone object (sp.js)	…/_api/web/RegionalSettings/TimeZones(timzoneid)
SPTimeZoneCollection	TimeZoneCollection	SP.TimeZoneCollection object (sp.js)	…/_api/web/RegionalSettings/TimeZones
SPUser	User	SP.User object (sp.js)	…/_api/web/siteusers(@v)?@v='<login name>'
SPUserCollection	UserCollection	SP.UserCollection object (sp.js)	…/_api/web/sitegroups(<group id>)/users
SPUtility	Utility	SP.Utilities.Utility object (sp.js)
SPView	View	SP.View object (sp.js)	…/_api/web/lists(guid'<list id>')/views('<view id>')
SPViewCollection	ViewCollection	SP.ViewCollection object (sp.js)	…/_api/web/lists(guid'<list id>')/views
SPViewFieldCollection	ViewFieldCollection	SP.ViewFieldCollection object (sp.js)	…/_api/web/lists(guid'<list id>')/views('<view id>')/fields
SPWeb	Web	SP.Web object (sp.js)	…/_api/web
SPWebCollection	WebCollection	SP.WebCollection object (sp.js)	…/_api/web/webs
SPWebInfo	WebInformation	SP.WebInformation object (sp.js)	…/_api/web/webinfos('<web information id>')
SPWebTemplate	WebTemplate	SP.WebTemplate object (sp.js)	…/_api/web/GetAvailableWebTemplates(languageid,includecrosslanguage)/getbyname(templatename)
SPWebTemplateCollection	WebTemplateCollection	SP.WebTemplateCollection object (sp.js)	…/_api/web/GetAvailableWebTemplates(languageid,includecrosslanguage

https://msdn.microsoft.com/EN-US/library/office/dn268594.aspx

Espero les sea de utilidad para elegir las diferentes API según lo escenarios con que estan desarrollando soluciones para las diferentes versiones de SharePoint.

Hasta la Proxima!,

Juan Manuel Herrera Ocheita