Lagra data i OneLake

Varje fabric-objekt har åtkomst till OneLake-lagring, vilket ger ett säkert och skalbart sätt att lagra filer som är associerade med ditt objekt. Den här guiden beskriver hur du laddar upp filer till ditt Infrastrukturobjekt med hjälp av FabricPlatformAPIClient och den underliggande OneLakeClient.

Förstå objektlagring i Fabric

Varje objekt i Fabric har ett eget dedikerat lagringsområde i OneLake. Det här lagringsutrymmet är organiserat i mappar, där huvudmapparna är:

• Filer – För att lagra allmänna filer och dokument
• Tabeller – för lagring av tabelldata

Förutsättningar

Innan du laddar upp filer till ditt objekt behöver du:

• En giltig Fabric-arbetsyta
• Ett befintligt objekt där du vill ladda upp filen
• Lämpliga behörigheter för att skriva till objektet

Skapa FabricPlatformAPIClient

Skapa först en FabricPlatformAPIClient instans:

import { getWorkloadClient } from "../controller/WorkloadClient";
import { FabricPlatformAPIClient } from "../clients/FabricPlatformAPIClient";

// Create client using the current user's context
const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());

Exempel: Ladda upp en textfil till ett objekt

Så här laddar du upp en textfil till ett objekt med onelake-klienten:

async function uploadTextFileToItem(
  workspaceId: string, 
  itemId: string, 
  fileName: string, 
  content: string
) {
  try {
    // Get the FabricPlatformAPIClient
    const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
    
    // Access the OneLake client
    const oneLakeClient = fabricClient.oneLake;
    
    // Generate the file path in OneLake for this item
    // This follows the pattern: workspaceId/itemId/Files/fileName
    const filePath = oneLakeClient.constructor.getFilePath(workspaceId, itemId, fileName);
    
    // Write the text content to the file
    await oneLakeClient.writeFileAsText(filePath, content);
    
    console.log(`Successfully uploaded ${fileName} to item ${itemId}`);
    return true;
  } catch (error) {
    console.error("Error uploading file to item:", error);
    throw error;
  }
}

Exempel: Ladda upp en binär fil till ett objekt

För binära filer som bilder eller PDF-filer måste du konvertera filen till base64 först:

async function uploadBinaryFileToItem(
  workspaceId: string,
  itemId: string,
  fileName: string,
  fileData: ArrayBuffer // Binary file data
) {
  try {
    const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
    const oneLakeClient = fabricClient.oneLake;
    
    // Convert binary data to base64
    const base64Content = arrayBufferToBase64(fileData);
    
    // Generate the file path
    const filePath = oneLakeClient.constructor.getFilePath(workspaceId, itemId, fileName);
    
    // Write the binary content to the file
    await oneLakeClient.writeFileAsBase64(filePath, base64Content);
    
    console.log(`Successfully uploaded binary file ${fileName} to item ${itemId}`);
    return true;
  } catch (error) {
    console.error("Error uploading binary file to item:", error);
    throw error;
  }
}

// Helper function to convert ArrayBuffer to base64
function arrayBufferToBase64(buffer: ArrayBuffer): string {
  let binary = '';
  const bytes = new Uint8Array(buffer);
  const len = bytes.byteLength;
  
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  
  return btoa(binary);
}

Exempel: Ladda upp en fil från webbläsaren

Om du skapar ett webbgränssnitt kan du använda den här funktionen för att hantera filuppladdningar från en filinmatning:

async function handleFileUpload(
  workspaceId: string,
  itemId: string,
  fileInputElement: HTMLInputElement
) {
  if (!fileInputElement.files || fileInputElement.files.length === 0) {
    console.warn("No file selected");
    return false;
  }
  
  const file = fileInputElement.files[0];
  const fileName = file.name;
  
  try {
    // Read the file as ArrayBuffer
    const fileBuffer = await readFileAsArrayBuffer(file);
    
    // Upload based on file type
    if (file.type.startsWith('text/')) {
      // For text files, convert to string and upload as text
      const textDecoder = new TextDecoder();
      const textContent = textDecoder.decode(fileBuffer);
      
      return await uploadTextFileToItem(workspaceId, itemId, fileName, textContent);
    } else {
      // For binary files, upload as base64
      return await uploadBinaryFileToItem(workspaceId, itemId, fileName, fileBuffer);
    }
  } catch (error) {
    console.error("Error processing file upload:", error);
    throw error;
  }
}

// Helper function to read file as ArrayBuffer
function readFileAsArrayBuffer(file: File): Promise<ArrayBuffer> {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result as ArrayBuffer);
    reader.onerror = reject;
    reader.readAsArrayBuffer(file);
  });
}

Hantera filer i objektet

När filerna har laddats upp kan du också:

Kontrollera om det finns en fil

async function checkFileExists(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  return await fabricClient.oneLake.checkIfFileExists(filePath);
}

Läsa filinnehåll

async function readTextFile(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  return await fabricClient.oneLake.readFileAsText(filePath);
}

Ta bort en fil

async function deleteFile(workspaceId: string, itemId: string, fileName: string) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  const filePath = fabricClient.oneLake.constructor.getFilePath(workspaceId, itemId, fileName);
  
  await fabricClient.oneLake.deleteFile(filePath);
  console.log(`File ${fileName} deleted successfully`);
}

Metodtips för filuppladdningar

1. Använd lämpliga filformat: Överväg syftet med filen och använd format som stöds i stor utsträckning.
2. Hantera fel på ett korrekt sätt: Inkludera alltid felhantering för nätverksproblem eller behörighetsproblem.
3. Verifiera filstorlekar: Stora filer kan ta längre tid att ladda upp och bearbeta.
4. Kontrollera behörigheter: Kontrollera att användaren har rätt behörigheter innan du försöker ladda upp.
5. Använd filprefix eller mappar: För komplexa objekt med många filer bör du överväga att ordna dem i undermappar.

Använda OneLakeClientItemWrapper

För förenklad åtkomst till objektfiler kan du använda OneLakeClientItemWrapper:

async function uploadFileWithItemWrapper(item, fileName, content) {
  const fabricClient = FabricPlatformAPIClient.create(getWorkloadClient());
  
  // Create a wrapper for simpler access to this specific item
  const itemWrapper = fabricClient.oneLake.createItemWrapper({
    workspaceId: item.workspaceId,
    itemId: item.id
  });
  
  // Upload directly to the item (no need to specify paths)
  await itemWrapper.writeFileAsText(fileName, content);
  
  // Read the file back
  const fileContent = await itemWrapper.readFileAsText(fileName);
  
  console.log(`File uploaded and read back: ${fileContent.substring(0, 50)}...`);
}

Den här wrappern förenklar filåtgärderna genom att automatiskt hantera den fullständiga sökvägskonstruktionen.