Compartir a través de

Cómo: operaciones de SharePoint (versión preliminar)

Use el SDK de Power Apps para conectar la aplicación de código a SharePoint y use los modelos y servicios generados para realizar operaciones CRUD (Crear, Leer, Actualizar, Eliminar) en una lista de SharePoint.

Prerrequisitos

Escenarios admitidos

Se admiten los escenarios siguientes al conectarse a SharePoint mediante el SDK de Power Apps:

  • Agregar listas de SharePoint como orígenes de datos mediante la CLI de PAC
  • Realizar operaciones CRUD en una lista de SharePoint
  • Obtención de valores posibles para columnas de elección, búsqueda o persona o grupo

Configura tu aplicación de codificación

Antes de realizar operaciones de creación, lectura, actualización y eliminación (CRUD) en la aplicación de código, complete estos pasos de configuración.

Asegúrese de que el SDK de Power Apps esté inicializado antes de realizar llamadas a datos.

En el App.tsx archivo, implemente lógica que espere a que el SDK de Power Apps se inicialice completamente antes de realizar operaciones de datos. Este enfoque evita errores causados por servicios no inicializados o contexto que falta.

Use una función asincrónica o una administración de estado para confirmar la inicialización antes de realizar llamadas API. Por ejemplo:

useEffect(() => { 
// Define an async function to initialize the Power Apps SDK 
const init = async () => { 
      try { 
            await initialize(); // Wait for SDK initialization 
            setIsInitialized(true); // Mark the app as ready for data operations 
      } catch (err) { 
            setError('Failed to initialize Power Apps SDK'); // Handle initialization errors 
            setLoading(false); // Stop any loading indicators 
      } 
};

init(); // Call the initialization function when the component mounts 
}, []); 
 
useEffect(() => { 
// Prevent data operations until the SDK is fully initialized 
if (!isInitialized) return; 
 
// Place your data reading logic here 
}, []);

Agregar el origen de datos de SharePoint

Agregue el origen de datos de SharePoint siguiendo las instrucciones de Conexión a datos.

Importación de tipos y servicios necesarios

Al agregar un origen de datos, los archivos de modelo y servicio se generan y colocan automáticamente en la /generated/services/ carpeta . Por ejemplo, si agrega la ChoicesTest1 lista, se crean los siguientes archivos:

  • ChoicesTest1Model.ts : define el modelo de datos para la lista ChoicesTest1.
  • ChoicesTest1Service.ts : proporciona métodos de servicio para interactuar con los datos en la lista ChoicesTest1.

Puede importar y usar estos archivos en el código App.tsx de la siguiente manera:

import { ChoicesTest1Service } from './generated/services/ChoicesTest1Service'; 
import type { ChoicesTest1 } from './generated/models/ChoicesTest1Model';

Leer registros

En este ejemplo se capturan todos los elementos y se establece el estado.

const loadRecords = async () => { 
  try { 
    const result = await ChoicesTest1Service.getAll(); 
    if (result.data) { 
      setRecords(result.data); // result.data is T[] 
    } else { 
      // handle empty or error 
    } 
  } catch (err) { 
    // handle error 
  } 
};

En este ejemplo se lee un único registro.

const fetchOne = async (id: string) => { 
  const r = await ChoicesTest1Service.get(id); 
  if (r.data) { 
    // r.data is a single record typed as ChoicesTest1 
  } 
};

Crear registros

Para los ejemplos de los pasos siguientes, los tipos de ejemplo del archivo de modelo son ChoicesTest1, Choices1Value, personValuey lookupValue.

  1. Asignar identificadores seleccionados a objetos expandidos

Nota:

Los modelos generados pueden incluir nombres de propiedad internos con # (por ejemplo: Choices1#Id) que se usan para enlazar en formularios, pero que no deben incluirse en la carga enviada al conector de SharePoint. Al actualizar o crear una fila en la lista, la API de SharePoint espera que proporcione el objeto expandido para las columnas a las que se hace referencia (autor, editor, columnas de persona o grupo, etc.) en lugar de solo los identificadores. Consulte la documentación de la API de SharePoint para obtener más información.

const choices1Obj = selectedChoices1Id 
? choices1Options.find(c => c.Id === selectedChoices1Id) 
: undefined; 
const personObj = selectedPersonClaims 
? personOptions.find(p => p.Claims === selectedPersonClaims) 
: undefined; 
const lookupObj = selectedLookupId 
? lookupOptions.find(l => l.Id === selectedLookupId) 
: undefined;
  1. Compilación de carga y creación

Asegúrese de omitir las propiedades que contienen #, incluya objetos expandidos para elegir, búsquedas y personas y agregue información de tipo de contenido si es necesario. Use los tipos de modelo generados para ayudar a crear la carga útil.

// Content type (example static sample; retrieve dynamically if needed) 
const contentTypeId = "0x0100..."; // replace with your content type id 

const payload = { 
Title: titleValue, 
Choices1: choices1Obj, 
Choices2: choices2Obj, 
Choices3: choices3Obj, 
person: personObj, 
yesno: yesnoBoolean, 
lookup: lookupObj,
"{ContentType}": { 
   "@odata.type": "#Microsoft.Azure.Connectors.SharePoint.SPListExpandedContentType",
   Id: contentTypeId, 
   Name: "Item" 
} 
} as Partial<Omit<ChoicesTest1, "ID">>; 

// create 
const created = await ChoicesTest1Service.create(payload as Omit<ChoicesTest1, "ID">); 
if (created.data) { 
// success 
}

Actualizar registros

Use update(id, payload) desde el archivo de servicio generado. Proporcione los mismos objetos expandidos que al crear un registro.

Por ejemplo:

const updatePayload = { 
  Title: updatedTitle, 
  Choices1: updatedChoices1Obj, 
  // ... 
} as Partial<Omit<ChoicesTest1, "ID">>; 

await ChoicesTest1Service.update(recordId, updatePayload);

Eliminar registros

Asegúrese recordId de que es el identificador de cadena que espera el servicio. Suele ser un identificador de elemento numérico convertido en cadena.

await ChoicesTest1Service.delete(recordId);

Entidades a las que se hace referencia (Opciones/ Búsqueda/Persona)

Para rellenar las listas desplegables, llame a getReferencedEntity(). SharePoint siempre devuelve una matriz de valores que contiene objetos de la entidad a la que se hace referencia. Es posible que desee normalizar la respuesta, ya que algunos conectores devuelven una estructura con el formato { value: [] }, mientras que otros proporcionan la matriz directamente.

// The first parameter is a search term, the second is the referenced entity name 
const res = await ChoicesTest1Service.getReferencedEntity("", "Choices1"); 
// normalize: 
const dataArray = (res.data as { value?: any[] })?.value || res.data; 
const options = Array.isArray(dataArray) ? dataArray : []; 
// map to select options: 
const selectOpts = options.map(o => ({ id: o.Id, label: o.Value }));

Escenarios no soportados

El SDK de Power Apps y la CLI de PAC permiten operaciones CRUD en listas de SharePoint, pero no admiten API de procesamiento de documentos ni acciones como la sincronización de elementos o los cambios de permisos. Puede agregar estas características mediante la creación de un archivo de servicio personalizado para la aplicación de código.

  • Last updated on