Método Indirecto de Actualización para Power Apps y SharePoint Online

 

En este post, quiero compartir un enfoque eficiente y seguro para gestionar actualizaciones en listas de SharePoint Online desde Power Apps, al que llamo el método indirecto de actualización. Este método permite realizar actualizaciones y eliminaciones en listas maestras sin otorgar permisos directos de edición a los usuarios, incrementando así la seguridad y el control sobre los datos.

¿En qué consiste el método indirecto de actualización?

El método indirecto de actualización se basa en utilizar listas intermedias para manejar las operaciones de agregar, actualizar y eliminar elementos en una lista maestra. La estructura básica incluye:

1. Lista Maestra: La lista principal en SharePoint donde se almacenan los datos definitivos. Los usuarios tienen permisos de solo lectura.
2. Lista de Actualizaciones: Una lista donde los usuarios pueden agregar elementos que representan solicitudes de actualización. Los usuarios tienen permisos para agregar elementos.
3. Lista de Eliminaciones: Una lista separada donde los usuarios pueden agregar elementos que representan solicitudes de eliminación. Los usuarios tienen permisos para agregar elementos.

Proceso de Funcionamiento

1. Agregar Elementos: Los usuarios pueden agregar nuevos elementos directamente en la Lista de Actualizaciones. Un flujo de Power Automate se dispara al detectar un nuevo elemento, procesando la solicitud y actualizando la Lista Maestra en consecuencia.
2. Actualizar Elementos: Similar al proceso de agregar, los usuarios realizan cambios en los elementos de la Lista de Actualizaciones. El flujo de Power Automate detecta las modificaciones y aplica las actualizaciones en la Lista Maestra.
3. Eliminar Elementos: Los usuarios agregan un elemento en la Lista de Eliminaciones indicando cuál debe ser eliminado. El flujo de Power Automate toma esta solicitud y elimina el elemento correspondiente en la Lista Maestra.

Manejo de Estados en Power Apps

Un aspecto crucial al implementar este método en Power Apps es manejar la latencia en la ejecución de los flujos de Power Automate, ya que los eventos en SharePoint no se disparan de forma inmediata. Para asegurar que los usuarios sean conscientes de que sus solicitudes están en proceso, es necesario manejar colecciones en memoria dentro de Power Apps. Estas colecciones indican que el estado de algún elemento agregado o eliminado está pendiente de actualizarse.

De esta manera, cuando un usuario realiza una acción, Power Apps agrega el elemento a una colección que marca dicho elemento como pendiente. Así, el usuario puede ver que su solicitud se está procesando, aunque el flujo de Power Automate todavía no haya completado la operación en la Lista Maestra.

Beneficios del Método Indirecto

1. Seguridad Mejorada: Al restringir los permisos de la Lista Maestra a solo lectura, evitamos que los usuarios modifiquen o eliminen datos críticos directamente.
2. Control de Acceso: Los usuarios solo pueden agregar elementos a las listas intermedias, evitando la necesidad de permisos de edición directa en la Lista Maestra.
3. Automatización: Los flujos de Power Automate gestionan automáticamente las operaciones en la Lista Maestra basándose en los eventos disparados por las listas intermedias.
4. Simplicidad en Power Apps: La aplicación Power Apps solo necesita conectarse a las listas intermedias, simplificando la configuración y reduciendo el riesgo de errores en la manipulación de la Lista Maestra.

Implementación del Método

1. Crear Listas en SharePoint Online:
• Lista Maestra
• Lista de Actualizaciones
• Lista de Eliminaciones
2. Configurar Permisos:
• Lista Maestra: Permisos de solo lectura para los usuarios.
• Listas de Actualizaciones y Eliminaciones: Permisos para agregar elementos.
3. Desarrollar Flujos en Power Automate:
• Flujo para procesar nuevas adiciones y actualizaciones desde la Lista de Actualizaciones a la Lista Maestra.
• Flujo para manejar eliminaciones desde la Lista de Eliminaciones a la Lista Maestra.
4. Configurar Colecciones en Power Apps:
• Crear y manejar colecciones en memoria para indicar el estado de los elementos pendientes de actualizarse o eliminarse, asegurando que los usuarios sepan que sus solicitudes están en proceso.

Conclusión

El método indirecto de actualización para Power Apps y SharePoint Online es una estrategia poderosa para mejorar la seguridad y el control en la gestión de datos. Al implementar listas intermedias y automatizar las operaciones con flujos de Power Automate, podemos asegurar que solo se realicen cambios autorizados en la Lista Maestra, manteniendo la integridad y la seguridad de nuestros datos. Además, el manejo de colecciones en Power Apps proporciona una experiencia de usuario fluida, informando a los usuarios sobre el estado de sus solicitudes.

 

La version destino del sitio de SharePoint es menor a la soportada por la aplicación SharePoint 2013 local o en nuestras instalaciones (On Premises)

Escenario:

Un App para SharePoint o Add-in como lo renombro Microsoft ahora que deseamos probar en un servidor de desarrollo. El App de hecho esta subida en el Seller Dashboard de Microsoft para Office pero al realizar desde Visual Studio 2015 el deployment ahora nos muestra el siguiente mensaje:

The target version of the SharePoint site is 15.0.4569.1000, which is lower than the minimum supported SharePoint version of the app

Esto es porque en el manifiesto del app es decir el archivo AppManifest.xml esta indicada la versión mínima requerida de SharePoint para ejectuar el App.

 

 Y si abrimos el archivo xml en VS nos muestra el requerimiento mínimo.

 

Lo que debemos de hacer es cambiar el número de 16 a 15 para probarlo en nuestro servidor de desarrollo.

 Y listo el app se implementa exitosamente.

Eso es todo amigos!.

SharePoint4Fun!,

Juan Manuel Herrera Ocheita

Como migrar el contenido de un sitio de WordPress a las bibliotecas de SharePoint Online

La estrategia es muy sencilla y va ser la siguiente:
1) Descargar el contenido a un almacenamiento local a través de una herramienta FTP.
2) Definir una estrategia para almacenar el contenido en SharePoint Online
2) Crear un Script que lea el contenido migrado y suba los archivos a bibliotecas de SharePoint.
La herramienta
Describamos un poco la herramienta llamada FileZila.   Esta herramienta de FTP es gratuita y esta disponible para los sistemas operativos más populares.   Lo mas importante si estamos en un entrono Windows es que vamos a poder acceder el contenido de WordPress que esta en Linux.
El enlace para descargar la herramienta es el siguiente: https://filezilla-project.org/ 
Veamos ahora la conexión hacia el servicio ftp

La información que debes de solicitar para hacer la conexión es la siguiente:
Dirección IP del servidor Linux
Puerto (Opcional solo si el cliente utiliza un puerto en especifico diferente el predeterminado [21] colocarlo allí).
Luego Las credenciales un usuario con acceso y una contraseña.
Seleccionamos lo que deseamos descargar y con el clic derecho del ratón seleccionamos la opción Download.

La estrategia
Para la estrategia vamos a crear bibliotecas por cada carpeta principal ya que en SPO hay un límite de despliegue de documentos de 5,000 por razones de rendimiento.  Por lo que debemos de tomar eso en cuenta.








Para reducir el trabajo en el script vamos a crear manualmente las bibliotecas porque tampoco son muchas en mi este caso de lo contrario deberíamos tomar eso en cuenta en el script y crear con comandos de Powershell las bibliotecas.

El Script
A través de este script invocamos los comandos de CSOM Client SharePoint Object Model y no el Modelo de objetos de SharePoint.   Porque razón?, bueno porque SharePoint Online no esta local sino en la nube y la forma de acceder remotamente las librerias de SharePoint es através de CSOM que no es mas que llamadas de servicios Web por medio de un módelo de objetos definido para ese propósito.

Ahora vemos el script que hace la magia:
/* Cargamos las librerias de CSOM */
Add-Type -Path "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.dll"
Add-Type -Path "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.Runtime.dll"
/* El método Ensure_Folder nos asegurará que la carpeta este creada antes de copiar el contenido */
Function Ensure-Folder()
{
Param(
  [Parameter(Mandatory=$True)]
  [Microsoft.SharePoint.Client.Web]$Web,
  [Parameter(Mandatory=$True)]
  [Microsoft.SharePoint.Client.Folder]$ParentFolder,
  [Parameter(Mandatory=$True)]
  [String]$FolderUrl
)
    $folderNames = $FolderUrl.Trim().Split("/",[System.StringSplitOptions]::RemoveEmptyEntries)
    $folderName = $folderNames[0]
    Write-Host "Creating folder [$folderName] ..."
    $curFolder = $ParentFolder.Folders.Add($folderName)
    $Web.Context.Load($curFolder)
    $web.Context.ExecuteQuery()
    Write-Host "Folder [$folderName] has been created succesfully. Url: $($curFolder.ServerRelativeUrl)"
    if ($folderNames.Length -gt 1)
    {
        $curFolderUrl = [System.String]::Join("/", $folderNames, 1, $folderNames.Length - 1)
        Ensure-Folder -Web $Web -ParentFolder $curFolder -FolderUrl $curFolderUrl
    }
}
/* El método Upload-File  recibe como parametros el url relativo de la carpeta destino y la ubicación local del archivo */
Function Upload-File()
{
Param(
  [Parameter(Mandatory=$True)]
  [Microsoft.SharePoint.Client.Web]$Web,
  [Parameter(Mandatory=$True)]
  [String]$FolderRelativeUrl,
  [Parameter(Mandatory=$True)]
  [System.IO.FileInfo]$LocalFile
)
    try {
     $folderUrl = $LocalFile.Name.ToLower().Replace($SourceFolderPath.ToLower(),"")
    
     $fileUrl = $FolderRelativeUrl + "/" + $folderUrl
       write-host "FileUrl:" $fileUrl
       Write-Host "Uploading file [$($LocalFile.FullName)] ..."
       [Microsoft.SharePoint.Client.File]::SaveBinaryDirect($Web.Context, $fileUrl, $LocalFile.OpenRead(), $true)
       Write-Host "File [$($LocalFile.FullName)] has been uploaded succesfully. Url: $fileUrl"
    }
    catch {
       write-host "An error occured while uploading file [$($LocalFile.FullName)]"
    }
}
/* El método Upload-Files es la principal ya que localiza cata archivo local y define la url destino para subir el archivo  a SPO.  Este método recibe como parameto la url destino, el usuario de O365, la contraeña, el nombre de la biblioteca de SharePoint destino, y la rutal local donde esta ubicado el contenido.  Como es recursivo solo debemos de dar el punto de partida de donde deseamos iniciar la carga de información. */

function Upload-Files()
{
Param(
  [Parameter(Mandatory=$True)]
  [String]$Url,
  [Parameter(Mandatory=$True)]
  [String]$UserName,
  [Parameter(Mandatory=$False)]
  [String]$Password,
  [Parameter(Mandatory=$True)]
  [String]$TargetListTitle,
  [Parameter(Mandatory=$True)]
  [String]$SourceFolderPath
)
    if($Password) {
       $SecurePassword = $Password | ConvertTo-SecureString -AsPlainText -Force
    }
    else {
      $SecurePassword = Read-Host -Prompt "Enter the password" -AsSecureString
    }

# Abajo la autenticación a O365 para acceder los objetos de SharePoint Online
    $Context = New-Object Microsoft.SharePoint.Client.ClientContext($Url)
    $Credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($UserName,$SecurePassword)
    $Context.Credentials = $Credentials

    #Instanciamos el Web Site que vamos acceder
    $web = $Context.Web
    $Context.Load($web)
    # Instanciamos la biblioteca destino
    $list = $web.Lists.GetByTitle($TargetListTitle);
    $Context.Load($list.RootFolder)

#Ejecutamos el conjunto de lineas anteriores

    $Context.ExecuteQuery()

#Recorremos cada directorio local del parametró de ruta origen que indicamos al ejecutar el método

    Get-ChildItem $SourceFolderPath -Recurse | % {
       if ($_.PSIsContainer -eq $True) {
          $folderUrl = $_.FullName.ToLower().Replace($SourceFolderPath.ToLower(),"")
          $folderUrl = $folderUrl.Replace("\","/").Replace(".","")  
          if($folderUrl) {
             Ensure-Folder -Web $web -ParentFolder $list.RootFolder -FolderUrl $folderUrl
          } 
       }
       else{
          # Basado en la ubicación local creamos un Url Relativo reciproco en la biblioteca de SPO
          $folderRelativeUrl = $list.RootFolder.ServerRelativeUrl + $_.DirectoryName.ToLower().Replace($SourceFolderPath.ToLower(),"").Replace("\","/").Replace(".","") 
          #Ejecutamos el métod que subira el archivo a la ruta destino
          Upload-File -Web $web -FolderRelativeUrl $folderRelativeUrl -LocalFile $_
       }
    }
}

#End of file
La ejecución
Para ejecutar el archivo uploadfiles-csom.ps1 deberemos declarar los siguientes parámetros:

$Url = https://miempresa.sharepoint.com/sites/miSitio
$UserName = misuario@midominio.onmicrosoft.com
$Password = "******"
$TargetListTitle = "BibliotecaDestino"   #Target Library
$SourceFolderPath = "X:\www\data\uploads\CarpetaOrigen"  #Source Physical Path

#Comando
Upload-Files -Url $Url -UserName $UserName -Password $Password -TargetListTitle $TargetListTitle -SourceFolderPath $SourceFolderPath

Y eso es todo amigos.
Hasta la próxima, 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