వర్డ్ ఆఫీస్

Mia Chevalier

8, డిసెంబర్ 2024, ఆదివారం 1:21:29 AMకి

మీ వర్డ్ యాడ్-ఇన్ కోసం డేటా యాక్సెస్‌ను క్రమబద్ధీకరించడం

మీరు SharePoint డాక్యుమెంట్ లైబ్రరీ నుండి నిర్దిష్ట డేటాను తీయడానికి అవసరమైన Word Office యాడ్-ఇన్ని అభివృద్ధి చేస్తున్నట్లు ఊహించుకోండి. PnPjs మరియు Microsoft గ్రాఫ్ వంటి ఫ్రేమ్‌వర్క్‌లను ఉపయోగించి, ఈ పని సూటిగా ఉండాలి. కానీ ప్రారంభించడం విఫలమైనప్పుడు, విషయాలు త్వరగా నిరాశ చెందుతాయి. 🤔

మా దృష్టాంతంలో, యాడ్-ఇన్‌లో వినియోగదారు ఇంటరాక్టివిటీని మెరుగుపరచడానికి షేర్‌పాయింట్‌లో నిల్వ చేయబడిన JSON ఫైల్‌ను చదవాలని మేము లక్ష్యంగా పెట్టుకున్నాము. PnPjs మైక్రోసాఫ్ట్ గ్రాఫ్‌ని యాక్సెస్ చేయడానికి అనుకూలమైన సారాంశాలను అందిస్తోంది, ఆఫీస్ యాడ్-ఇన్‌లో పని చేసేలా దీన్ని కాన్ఫిగర్ చేయడం ప్రత్యేకమైన సవాళ్లను అందిస్తుంది.

మేము ఎదుర్కొన్న ప్రధాన సమస్య గ్రాఫ్ API అభ్యర్థనల కోసం ప్రామాణీకరణ శీర్షికలను సరిగ్గా సెటప్ చేయడం. మా `authService` ఊహించిన విధంగా పనిచేసినప్పటికీ, టోకెన్‌లను ధృవీకరించడానికి లేదా ప్రాథమిక వినియోగదారు డేటాను పొందేందుకు చేసిన ప్రయత్నాలు ఎర్రర్‌లకు దారితీశాయి.

ఈ కథనంలో, ఈ సమస్యలు ఎందుకు సంభవిస్తాయో మేము అన్వేషిస్తాము మరియు PnPjs మరియు మైక్రోసాఫ్ట్ గ్రాఫ్‌ని ప్రారంభించడానికి ఒక పని ఉదాహరణను అందిస్తాము. మీ అభివృద్ధి ప్రయాణంలో మీరు ఇలాంటి అడ్డంకులను ఎదుర్కొన్నట్లయితే, ఈ గైడ్ మీ కోసం. సమస్యను దశలవారీగా పరిష్కరిద్దాం! 🚀

ఆదేశం	ఉపయోగం యొక్క ఉదాహరణ
graphfi()	మైక్రోసాఫ్ట్ గ్రాఫ్ APIతో పరస్పర చర్య చేయడానికి PnPjs గ్రాఫ్ ఉదాహరణను ప్రారంభించేందుకు ఉపయోగించబడుతుంది. ప్రామాణీకరణ వంటి మిడిల్‌వేర్‌ను కాన్ఫిగర్ చేయడానికి ఇది ఎంట్రీ పాయింట్‌గా పనిచేస్తుంది.
DefaultInit()	PnPjs కోసం డిఫాల్ట్ కాన్ఫిగరేషన్‌లను అందిస్తుంది, సాధారణ వినియోగ సందర్భాలలో సెటప్‌ను క్రమబద్ధీకరిస్తుంది. ఫంక్షనల్ గ్రాఫ్ API ఇంటిగ్రేషన్‌ను త్వరగా పరంజా చేయడానికి ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.
instance.on.auth.replace()	టోకెన్‌ల వంటి ప్రామాణీకరణ హెడర్‌ల మాన్యువల్ ఇంజెక్షన్‌ని ప్రారంభించడం ద్వారా డిఫాల్ట్ ప్రమాణీకరణ మిడిల్‌వేర్‌ను భర్తీ చేయడానికి అనుకూల లాజిక్‌ను అనుమతిస్తుంది.
context.headers	గ్రాఫ్ API అభ్యర్థనతో పంపబడిన హెడర్‌లను సూచిస్తుంది. ఇక్కడే బేరర్ టోకెన్‌తో `ఆథరైజేషన్` హెడర్ ఇంజెక్ట్ చేయబడింది.
authService.getGraphApiToken()	మీ ప్రమాణీకరణ సేవ నుండి ప్రామాణీకరణ టోకెన్‌లను తిరిగి పొందడం కోసం అనుకూల పద్ధతి. సురక్షితమైన మరియు చెల్లుబాటు అయ్యే API యాక్సెస్‌ని నిర్ధారించడానికి ఇది కీలకం.
acquireTokenSilent()	MSAL.jsలో భాగంగా, ఈ పద్ధతి కాష్ నుండి యాక్సెస్ టోకెన్‌ను అందుబాటులో ఉంటే, అనవసరమైన వినియోగదారు పరస్పర చర్యను నివారిస్తుంది.
acquireTokenPopup()	`acquireTokenSilent()` విఫలమైతే, పాప్‌అప్ ద్వారా ఇంటరాక్టివ్ టోకెన్ అభ్యర్థనకు తిరిగి వస్తుంది, వినియోగదారులు అవసరమైనప్పుడు ప్రామాణీకరించగలరని నిర్ధారిస్తుంది.
graph.me()	మైక్రోసాఫ్ట్ గ్రాఫ్ నుండి ప్రామాణీకరించబడిన వినియోగదారు ప్రొఫైల్ డేటాను పొందేందుకు PnPjs ఆదేశం, టోకెన్ కార్యాచరణ మరియు API కనెక్టివిటీని ధృవీకరిస్తుంది.
...context.headers	JavaScript స్ప్రెడ్ ఆపరేటర్ ఇప్పటికే ఉన్న హెడర్‌లను కొత్త వాటితో విలీనం చేయడానికి ఉపయోగించబడుతుంది, `ఆథరైజేషన్` హెడర్‌ను ఇంజెక్ట్ చేసేటప్పుడు డేటా ఏదీ ఓవర్‌రైట్ చేయబడదని నిర్ధారిస్తుంది.
async/await	టోకెన్ రిట్రీవల్ లేదా API కాల్స్ వంటి అసమకాలిక ఆపరేషన్‌లు క్లీన్‌గా మరియు సీక్వెన్స్‌లో నిర్వహించబడుతున్నాయని నిర్ధారిస్తుంది, రీడబిలిటీ మరియు విశ్వసనీయతను మెరుగుపరుస్తుంది.

ఆఫీస్ యాడ్-ఇన్‌లలో PnPjలు మరియు మైక్రోసాఫ్ట్ గ్రాఫ్ యొక్క స్ట్రీమ్‌లైన్డ్ ఇంటిగ్రేషన్

వర్డ్ యాడ్-ఇన్ కోసం SharePoint నుండి JSON ఫైల్‌ను చదవడంలో సమస్యను పరిష్కరించడానికి, అందించిన స్క్రిప్ట్‌లు PnPjs ఫ్రేమ్‌వర్క్ మరియు Microsoft Graph API యొక్క శక్తిని ప్రభావితం చేస్తాయి. పరిష్కారం `గ్రాఫి` ఉదాహరణను ప్రారంభించడం ద్వారా ప్రారంభమవుతుంది. ఇది అన్ని తదుపరి API కాల్‌లకు పునాదిగా పనిచేస్తుంది, మైక్రోసాఫ్ట్ గ్రాఫ్‌కు అభ్యర్థనలు సరిగ్గా రూట్ చేయబడి మరియు ప్రామాణీకరించబడినట్లు నిర్ధారిస్తుంది. `DefaultInit()` కాన్ఫిగరేషన్‌ని ఉపయోగించడం ద్వారా, డెవలపర్‌లు అనుకూలీకరణల కోసం సౌలభ్యాన్ని కలిగి ఉండగానే వారి సెటప్ ప్రక్రియను సులభతరం చేయవచ్చు.

ఈ అమలు యొక్క క్లిష్టమైన అంశాలలో ఒకటి `on.auth.replace` పద్ధతిని ఉపయోగించడం. ఇది డిఫాల్ట్ ప్రమాణీకరణ మెకానిజంను భర్తీ చేస్తుంది, అభ్యర్థన హెడర్‌లలో యాక్సెస్ టోకెన్‌ల డైనమిక్ ఇంజెక్షన్‌ను అనుమతిస్తుంది. ఈ విధానం అనుకూల `authService` ద్వారా టోకెన్‌లను పొందడం ద్వారా గ్రాఫ్ APIకి సురక్షితమైన మరియు చెల్లుబాటు అయ్యే యాక్సెస్‌ని నిర్ధారిస్తుంది. ప్రామాణీకరణ వర్క్‌ఫ్లోలకు నిర్దిష్ట భద్రతా ప్రోటోకాల్‌లను పాటించాల్సిన అవసరం ఉన్న ఎంటర్‌ప్రైజ్ దృశ్యాలలో ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది. 🔐

`acquireTokenSilent()` మరియు `acquireTokenPopup()` వంటి టోకెన్ హ్యాండ్లింగ్ పద్ధతులను చేర్చడం ద్వారా ప్రామాణీకరణ వినియోగదారు-స్నేహపూర్వకంగా మరియు పటిష్టంగా ఉంటుందని నిర్ధారిస్తుంది. ఈ పద్ధతులు యాడ్-ఇన్ సజావుగా పనిచేయడానికి అనుమతిస్తాయి, కాష్ నుండి టోకెన్‌లను తిరిగి పొందడం లేదా అవసరమైనప్పుడు మాత్రమే వినియోగదారులను ప్రాంప్ట్ చేయడం. ఉదాహరణకు, వర్డ్‌లో ఉద్యోగి నివేదికలను రూపొందించాల్సిన HR మేనేజర్‌ని ఊహించుకోండి. యాడ్-ఇన్ బ్యాక్‌గ్రౌండ్‌లో నిశ్శబ్దంగా ప్రామాణీకరించబడుతుంది, మేనేజర్ అనుభవానికి అంతరాయం లేకుండా ఉంటుంది. ఇది ద్రావణాన్ని స్కేలబుల్ మరియు అత్యంత సమర్థవంతమైనదిగా చేస్తుంది. 🚀

చివరగా, టోకెన్ కార్యాచరణను డీబగ్గింగ్ చేయడానికి మరియు ధృవీకరించడానికి `graph.me()` వంటి API టెస్టింగ్ కమాండ్‌ల ఏకీకరణ అమూల్యమైనది. షేర్‌పాయింట్ డాక్యుమెంట్‌లను చదవడం వంటి సంక్లిష్టమైన ఆపరేషన్‌లలోకి ప్రవేశించే ముందు ప్రామాణీకరణ ప్రవాహం సరిగ్గా పని చేస్తుందని ఈ దశ నిర్ధారిస్తుంది. మాడ్యులారిటీ మరియు ఉత్తమ అభ్యాసాలను కలపడం ద్వారా, ఈ స్క్రిప్ట్‌లు ఇలాంటి సవాళ్లను పరిష్కరించడానికి స్పష్టమైన మరియు పునర్వినియోగ ఫ్రేమ్‌వర్క్‌ను అందిస్తాయి. మీరు వ్యక్తిగత ఉపయోగం కోసం యాడ్-ఇన్‌ని నిర్మిస్తున్నా లేదా ఎంటర్‌ప్రైజ్-వైడ్ సొల్యూషన్‌లను అమలు చేస్తున్నా, ఈ సెటప్ వశ్యత మరియు విశ్వసనీయత రెండింటికి హామీ ఇస్తుంది.

వర్డ్ ఆఫీస్ యాడ్-ఇన్‌లో PnPjలను ప్రారంభించడం మరియు మైక్రోసాఫ్ట్ గ్రాఫ్‌ను ఎలా యాక్సెస్ చేయాలి

మైక్రోసాఫ్ట్ గ్రాఫ్‌తో బ్యాకెండ్ స్క్రిప్ట్ మాడ్యులారిటీ మరియు ఇంటిగ్రేషన్‌పై దృష్టి సారించి, ఆఫీస్ యాడ్-ఇన్‌లో ఉపయోగించడం కోసం PnPjలను ఎలా కాన్ఫిగర్ చేయాలో ఈ పరిష్కారం చూపుతుంది.

// Import necessary modules from PnPjs
import { graphfi } from "@pnp/graph";
import "@pnp/graph/users"; // For accessing user data
import { DefaultInit } from "@pnp/graph/presets/all";
// Authentication Service Integration
class AuthService {
    async getGraphApiToken(authority) {
        // Replace this with your actual token fetch logic
        return { accessToken: "your-access-token" };
    }
}
// Main configuration class
class GraphConfig {
    constructor(authService) {
        this.authService = authService;
        this.graph = null;
    }
    async initialize() {
        this.graph = graphfi().using(DefaultInit(), (instance) => {
            instance.on.auth.replace(async (url, context) => {
                const tokenResponse = await this.authService.getGraphApiToken("your-authority");
                if (!tokenResponse) {
                    console.error("Token retrieval failed");
                    return;
                }
                context.headers = {
                    ...context.headers,
                    Authorization: `Bearer ${tokenResponse.accessToken}`
                };
            });
        });
    }
    async testTokenValidity() {
        try {
            const userInfo = await this.graph.me();
            console.log("User info:", userInfo);
        } catch (error) {
            console.error("Token is not valid:", error);
        }
    }
}
// Usage example
const authService = new AuthService();
const graphConfig = new GraphConfig(authService);
await graphConfig.initialize();
await graphConfig.testTokenValidity();

ప్రత్యామ్నాయ విధానం: టోకెన్ నిర్వహణ మరియు PnPjs ప్రారంభించడం కోసం MSAL ఉపయోగించండి

ఈ పద్ధతి ప్రామాణీకరణ టోకెన్‌లను నిర్వహించడానికి MSAL.js లైబ్రరీని ఉపయోగిస్తుంది మరియు గ్రాఫ్ API యాక్సెస్ కోసం వాటిని PnPjsలో ఇంటిగ్రేట్ చేస్తుంది.

// Import necessary modules
import * as msal from "@azure/msal-browser";
import { graphfi } from "@pnp/graph";
import "@pnp/graph/users";
// MSAL Configuration
const msalConfig = {
    auth: {
        clientId: "your-client-id",
        authority: "https://login.microsoftonline.com/your-tenant-id",
        redirectUri: "your-redirect-uri"
    }
};
// Initialize MSAL client
const msalClient = new msal.PublicClientApplication(msalConfig);
// Acquire token silently or interactively
async function getToken() {
    try {
        const response = await msalClient.acquireTokenSilent({
            scopes: ["https://graph.microsoft.com/.default"]
        });
        return response.accessToken;
    } catch (error) {
        if (error instanceof msal.InteractionRequiredAuthError) {
            const response = await msalClient.acquireTokenPopup({
                scopes: ["https://graph.microsoft.com/.default"]
            });
            return response.accessToken;
        }
        throw error;
    }
}
// Initialize PnPjs with MSAL token
const graph = graphfi().using((instance) => {
    instance.on.auth.replace(async (url, context) => {
        const token = await getToken();
        context.headers = {
            ...context.headers,
            Authorization: `Bearer ${token}`
        };
    });
});
// Test API
async function testApi() {
    try {
        const user = await graph.me();
        console.log("User info:", user);
    } catch (error) {
        console.error("API call failed:", error);
    }
}
// Execute test
testApi();

ఆఫీస్ యాడ్-ఇన్‌లలో ప్రామాణీకరణ మరియు డేటా రిట్రీవల్‌ని ఆప్టిమైజ్ చేయడం

ప్రాథమిక సవాలు PnPjsని ప్రారంభించడం మరియు మైక్రోసాఫ్ట్ గ్రాఫ్‌తో అనుసంధానించడం చుట్టూ తిరుగుతున్నప్పటికీ, ప్రామాణీకరణను సురక్షితంగా మరియు సమర్ధవంతంగా నిర్వహించడం కూడా అంతే క్లిష్టమైన అంశం. ఆఫీస్ యాడ్-ఇన్‌ల కోసం, MSAL.js లైబ్రరీని ఉపయోగించడం టోకెన్ సముపార్జనను సులభతరం చేస్తుంది, ప్రత్యేకించి బహుళ-అద్దెదారు లేదా ఎంటర్‌ప్రైజ్ దృశ్యాలను నిర్వహించేటప్పుడు. MSAL వినియోగదారు ప్రమాణీకరణను క్రమబద్ధీకరించడానికి పద్ధతులను అందిస్తుంది, సంక్లిష్టమైన బ్యాకెండ్ సేవల అవసరాన్ని తగ్గిస్తుంది, ఇది తేలికపాటి వర్డ్ యాడ్-ఇన్‌లను అమలు చేసేటప్పుడు చాలా ముఖ్యమైనది. 🔑

మరొక ముఖ్య విషయం ఏమిటంటే ఎర్రర్ స్టేట్స్ మరియు టోకెన్ గడువుని నిర్వహించడం. ఆఫీస్ యాడ్-ఇన్‌లు కఠినమైన సమయ పరిమితులు మరియు భద్రతా విధానాలతో వాతావరణంలో పనిచేస్తాయి. వినియోగదారు విశ్వాసం మరియు డేటా భద్రతను నిర్వహించడానికి, విఫలమైన టోకెన్ అభ్యర్థనలు లేదా గ్రాఫ్ API కాల్‌ల కోసం మళ్లీ ప్రయత్నించే విధానాలను అమలు చేయడం చాలా అవసరం. ఇది నెట్‌వర్క్ అంతరాయాలు లేదా గడువు ముగిసిన టోకెన్‌లను ఎదుర్కొన్నప్పుడు కూడా యాడ్-ఇన్ ఫంక్షనల్‌గా ఉండేలా చేస్తుంది, పరిష్కారం యొక్క మొత్తం విశ్వసనీయతను పెంచుతుంది. ఉదాహరణకు, సర్వర్ అంతరాయం సమయంలో పత్రాన్ని యాక్సెస్ చేస్తున్న ఉద్యోగి ఇప్పటికీ కాష్ చేసిన డేటాను చూడవచ్చు లేదా సజావుగా పొందేందుకు మళ్లీ ప్రయత్నించవచ్చు. 🚀

చివరగా, షేర్‌పాయింట్ డేటా రిట్రీవల్ పనితీరు మరొక ముఖ్యమైన అంశం. యాడ్-ఇన్‌లు బాహ్య APIలపై ఆధారపడతాయి కాబట్టి, జాప్యాన్ని తగ్గించడానికి కాల్‌లను ఆప్టిమైజ్ చేయడం చాలా కీలకం. బ్యాచింగ్ రిక్వెస్ట్‌లు లేదా గ్రాఫ్ API యొక్క సెలెక్టివ్ ప్రాపర్టీలను ఉపయోగించడం వంటి సాంకేతికతలు అవసరమైన డేటాను మాత్రమే పొందడంలో సహాయపడతాయి, లోడ్ సమయాలు మరియు బ్యాండ్‌విడ్త్ వినియోగాన్ని తగ్గిస్తాయి. JSON ఫైల్‌ని చదివినా లేదా వినియోగదారు డేటాను పొందుతున్నప్పటికీ, ఈ ఆప్టిమైజేషన్‌లు అధిక డిమాండ్ ఉన్న వాతావరణంలో కూడా యాడ్-ఇన్‌ను వేగంగా మరియు మరింత ప్రతిస్పందించేలా చేస్తాయి.

PnPjలు మరియు మైక్రోసాఫ్ట్ గ్రాఫ్‌ను సమగ్రపరచడం గురించి సాధారణ ప్రశ్నలు

ఏమిటి graphfi() కోసం ఉపయోగిస్తారు?
graphfi() మైక్రోసాఫ్ట్ గ్రాఫ్ APIలతో పరస్పర చర్యను ప్రారంభించడం ద్వారా PnPjs గ్రాఫ్ ఉదాహరణను ప్రారంభిస్తుంది.
నేను ఉపయోగించి టోకెన్‌లను ఎలా ఇంజెక్ట్ చేయాలి on.auth.replace?
ది on.auth.replace అభ్యర్థన హెడర్‌లలో టోకెన్‌ను ఇన్‌సర్ట్ చేయడానికి కస్టమ్ లాజిక్‌తో డిఫాల్ట్ ప్రమాణీకరణ ప్రవాహాన్ని భర్తీ చేయడానికి పద్ధతి మిమ్మల్ని అనుమతిస్తుంది.
ఏమి చేస్తుంది DefaultInit() అందిస్తారా?
DefaultInit() PnPjs కోసం కాన్ఫిగరేషన్‌ను సులభతరం చేస్తుంది, సాధారణ వినియోగ సందర్భాలలో ప్రీబిల్ట్ డిఫాల్ట్‌లను అందిస్తుంది.
నిశ్శబ్ద టోకెన్ అభ్యర్థనలను MSAL ఎలా నిర్వహిస్తుంది?
acquireTokenSilent() వినియోగదారు పరస్పర చర్య లేకుండా కాష్ నుండి టోకెన్‌లను తిరిగి పొందుతుంది, అతుకులు లేని ఆపరేషన్‌ను నిర్ధారిస్తుంది.
API అభ్యర్థనలను బ్యాచింగ్ చేయడం వల్ల కలిగే ప్రయోజనాలు ఏమిటి?
PnPjsతో బ్యాచింగ్ API కాల్‌ల సంఖ్యను తగ్గిస్తుంది, పనితీరును మెరుగుపరుస్తుంది మరియు డేటా రిట్రీవల్ కార్యకలాపాల కోసం జాప్యాన్ని తగ్గిస్తుంది.

PnPjs మరియు Microsoft గ్రాఫ్ యొక్క అతుకులు లేని ఏకీకరణ

ఆఫీస్ యాడ్-ఇన్‌లో PnPjsని సమర్థవంతంగా సెటప్ చేయడం వలన మీ అప్లికేషన్ సురక్షితంగా డేటాను పొందేందుకు మరియు Microsoft గ్రాఫ్‌తో పరస్పర చర్య చేయడానికి సిద్ధంగా ఉందని నిర్ధారిస్తుంది. భద్రత మరియు పనితీరుకు ప్రాధాన్యతనిస్తూ షేర్‌పాయింట్ కంటెంట్ మరియు వినియోగదారు డేటాను నిర్వహించడాన్ని ఈ ఫ్రేమ్‌వర్క్ సులభతరం చేస్తుంది. విశ్వసనీయతకు సరైన అమలు కీలకం.

అందించిన దశలు మరియు ఉదాహరణలను అనుసరించడం ద్వారా, డెవలపర్‌లు ప్రామాణీకరణ వైఫల్యాల వంటి సాధారణ సమస్యలను పరిష్కరించగలరు మరియు మెరుగైన వినియోగదారు అనుభవం కోసం వారి యాడ్-ఇన్‌లను ఆప్టిమైజ్ చేయవచ్చు. ఈ సాధనాలు మరియు ఉత్తమ అభ్యాసాలతో, మీ వర్డ్ యాడ్-ఇన్ ఎంటర్‌ప్రైజ్ ఉత్పాదకత కోసం శక్తివంతమైన సాధనంగా మారుతుంది. 🛠️

ఆఫీస్ యాడ్-ఇన్‌లలో PnPjలను అమలు చేయడానికి మూలాలు మరియు సూచనలు

అధికారిక PnPjs డాక్యుమెంటేషన్ - అప్లికేషన్‌లలో PnPjలను ఏకీకృతం చేయడానికి సమగ్ర గైడ్. PnPjs డాక్యుమెంటేషన్‌ని సందర్శించండి
మైక్రోసాఫ్ట్ గ్రాఫ్ API అవలోకనం - గ్రాఫ్ API ముగింపు పాయింట్‌లు మరియు వాటి వినియోగం కోసం వివరణాత్మక సూచన. Microsoft Graph API గురించి తెలుసుకోండి
MSAL.js లైబ్రరీ డాక్యుమెంటేషన్ - జావాస్క్రిప్ట్ అప్లికేషన్‌లలో ప్రామాణీకరణను నిర్వహించడానికి సూచనలు. MSAL.js డాక్యుమెంటేషన్‌ను అన్వేషించండి
SharePoint JSON ఫైల్ యాక్సెస్ ఉదాహరణలు - షేర్‌పాయింట్ లైబ్రరీల నుండి డేటాను చదవడంలో అంతర్దృష్టులు. SharePoint డెవలపర్ వనరులను చదవండి
ఆఫీస్ యాడ్-ఇన్‌ల డెవలపర్ గైడ్ - వర్డ్ ఆఫీస్ యాడ్-ఇన్‌లను నిర్మించడానికి మరియు సమగ్రపరచడానికి గైడ్. ఆఫీస్ యాడ్-ఇన్‌ల డాక్యుమెంటేషన్‌ని సందర్శించండి

వర్డ్ ఆఫీస్ యాడ్-ఆన్‌లో మైక్రోసాఫ్ట్ గ్రాఫ్ మరియు PnPjలను సరిగ్గా ఎలా సెటప్ చేయాలి