Gyakorlat – Függvények létrehozása az Azure Functions-alkalmazáshoz

9 perc

Ebben a leckében függvényeket hozhat létre és konfigurálhat az Azure Functions alkalmazásban az GETNode.js Express-alkalmazásban lévő , POST, PUTés DELETE végpontokhoz.

Adathozzáférés hozzáadása a GET függvényhez

Az első API-végpontot akkor hozta létre, amikor az Azure Functions-alkalmazást az utolsó leckében hozta létre. Ez a függvény akkor fut, ha HTTP-t GET kér a rendszer./vacations Frissítenie kell a kazánlemez kódját, hogy meghívja az adatszolgáltatást a szabadságok lekéréséhez.

Nyissa meg a functions/src/functions/getVacations.ts fájlt.
Nyissa meg a kiszolgáló/útvonalak/vacation.routes.ts fájlt egy külön ablakban, hogy mindkét fájlt egymás mellett láthassa.
A getVacations.ts adja hozzá a vacationService importálásiutasítást.
```
import { vacationService } from '../services';
```

A getVacations.ts szerkessze a függvényt getVacations a vacationService meghívásához.

 export async function getVacations(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
     context.log(`Http function processed request for url "${request.url}"`);
     return { jsonBody: vacationService.getVacations() }; // Data access logic within the return object
 };

Ott megállhatna. Ez az egyetlen kód, amelyet hozzá kell adnia a függvényhez a szabadságok lekéréséhez. A hibák kezelésére és állapotkód visszaadására szolgáló kódot is meg kell adnia. Frissítse a függvényt a következő kód használatára.

 export async function getVacations(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
   context.log(`Http function processed request for url "${request.url}"`);

   try {
     const vacations = vacationService.getVacations();  // Data access logic

     if (vacations) {
       return {
         status: 200,
         jsonBody: vacations
       };
     } else {
       return {
         status: 404,
         jsonBody: {
           error: 'No vacations found'
         }
       };
     }      
   } catch (error: unknown) {
     const err = error as Error;
     context.error(`Error listing vacations: ${err.message}`);

     return {
       status: 500,
       jsonBody: {
         error: 'Failed to list vacations'
       }
     };
   }
 };

Az Azure Functions-útvonalak rendszerezése

A v4-es programozási modellben többféleképpen rendszerezheti az útvonalakat. Az útvonaldefiníciót egyetlen fájlban hagyhatja az útvonalkezelővel. Ez az egy végponttal rendelkező alkalmazások esetében rendben van. A Tailwind Traders fejlesztőjeként tudja, hogy ez az alkalmazás számos API-ra fog növekedni, amelyeket rendszerezni kell.

A szervezet elindításához hozzon létre egy új ./functions/src/index.ts fájlt az útvonaldefiníciók rögzítéséhez.
Adja hozzá a csomagból biztosított alkalmazás függőségét @azure/functions .
```
import { app } from '@azure/functions';
```
Adja hozzá a getVacations függvény függőségét a ./functions/getVacations fájlból.
```
import { getVacations } from `./functions/getVacations`;
```
Helyezze át az útvonaldefiníciót ./functions/getVacations a index.ts fájlba. Frissítse a metódustulajdonság-tömböt a következőre GET: .
```
app.http('getVacations', {
    methods: ['GET'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: getVacations
});
```

A függvény és a kezelő elnevezése

A név getVacations az app.http első paramétereként és a második paraméter tulajdonságaként is használatos. Ez zavaró lehet, és a név használatától függően különböző elnevezési szabályokat szeretne a szervezetben vagy a csapatban.

Screenshot of the http definition with the first parameter numbered as one, and the second parameter's handler property numbered as two.

Első paraméter – név sztringként: Az első paraméter értéke a függvény neve, ahogy az az Azure Portalon megjelenik. Ezek a nevek alfanumerikusan jelennek meg a portálon, ezért érdemes lehet olyan elnevezési konvenciót használni, amely a hasonló függvényeket szándékosan, például vacationGet metódusok, például getVacationmetódusok szerint csoportosítja. Másik esetet is választhat, például snake_case, kebab-case vagy camelCase.
Második paraméter – kezelőfüggvény: A második paraméter értéke a függvénykezelő neve az importáláskor és a kódban való használat során. Ennek a névnek leírónak kell lennie, és meg kell egyeznie a függvény céljával. Megfelelhet a kódbázisban már meglévő elnevezési konvencióknak, és a kódmegfelelőségi eszközökkel kényszeríthető ki.

A fennmaradó függvények létrehozása

Az expressz Node.js alkalmazásban négy végpont található, és most hozta létre a függvényt a GET végponthoz. Most hozzon létre függvényeket a fennmaradó útvonalvégpontokhoz.

Metódus	HTTP-eseményindító neve	Útvonal
`POST`	`postVacation`	`vacations`
`PUT`	`updateVacation`	`vacations/{id}`
`DELETE`	`deleteVacation`	`vacations/{id}`

Míg a GET és a POST útvonal megegyezik. Az PUT útvonalak egy DELETE paraméterrel azonosítják a használni kívánt szabadságokat.

A HTTP POST függvény létrehozása

Hozza létre a POST szabadság hozzáadását kezelő függvényt.

A Visual Studio Code-ban nyissa meg a parancspalettát a Ctrl Shift +P billentyűkombinációval + , írja be Azure Functions: Create Function és nyomja le az Enter billentyűt.
Típusként válassza a HTTP-eseményindítót , majd a postVacation nevet.
Adja hozzá a vacationService importálási utasítást a fájlhoz.
```
import { vacationService } from '../services';
```

Cserélje le a boilerplate függvényt postVacation az alábbi kódra az adathozzáféréshez és a hibakezeléshez.

export async function postVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`HTTP function processed request for URL: "${request.url}"`);

    try {
        const vacation = await request.json() as Vacation;

        // Validate the vacation object
        if (!vacation || typeof vacation !== 'object' || !vacation.name || !vacation.description) {
            return {
                status: 400,
                jsonBody: { 
                    error: 'Invalid or missing vacation data.' 
                }
            };
        }

        // Data access logic
        const newVacation = vacationService.addVacation(vacation); 

        // Successfully added the vacation
        return {
            status: 201,
            jsonBody: newVacation
        };
    } catch (error: unknown) {
        const err = error as Error;
        context.error(`Error create vacation: ${err.message}`);

        return {
            status: 500,
            jsonBody: {
                error: 'Failed to create vacation'
            }
        };
    }
}

A bejövő szabadságadatok olvasásához használja a metódust request.json() . Ez a metódus egy ígéretet ad vissza, amely feloldja a JSON-adatokat a kérelem törzsében. Ezután a await kulcsszóval megvárhatja az ígéret feloldását. A as Vacation szintaxis egy típus-állítás, amely arra utasítja a TypeScriptet, hogy az eredményt objektumként Vacation kezelje.

const vacation = await request.json() as Vacation;

Helyezze át az útvonaldefiníciót a postVacation fájlból a index.ts fájlba. Frissítse a metódustulajdonság-tömböt a következőre POST: .
```
app.http('post-vacation', {
    methods: ['POST'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: postVacation
});
```

A HTTP PUT függvény létrehozása

Hozza létre a PUT szabadság hozzáadását kezelő függvényt.

A Visual Studio Code-ban nyissa meg a parancspalettát a Ctrl Shift + P billentyűkombinációval + , írja be Azure Functions: Create Function és nyomja le az Enter billentyűt.
Típusként válassza a HTTP-eseményindítót , névként pedig az updateVacation elemet.
Adja hozzá a vacationService importálási utasítást a fájlhoz.
```
import { vacationService } from '../services';
```

Cserélje le a boilerplate függvényt updateVacation az alábbi kódra az adathozzáféréshez és a hibakezeléshez.

export async function updateVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  try {
    const id = request.params.id;
    const { name, description } = await request.json() as Vacation;

    // Data access logic
    const updatedVacation = vacationService.updateVacation({ id, name, description });

    if (updatedVacation !== undefined) {
      return {
        status: 200,
        jsonBody: {
          updatedVacation
        }
      };
    } else {
      return {
        status: 404,
        jsonBody: {
          error: `Vacation with ID ${id} not found`
        }
      };
    }
  } catch (error: unknown) {
    const err = error as Error;
    context.error(`Error updating vacation: ${err.message}`);

    return {
      status: 500,
      jsonBody: {
        error: 'Failed to update vacation'
      }
    };
  }
};

A request.params.id tulajdonság használatával lekérheti a szabadságazonosítót az URL-címről. A request.json() metódus segítségével lekérheti a szabadságadatokat a kérelem törzséből. A as Vacation szintaxis egy típus-állítás, amely arra utasítja a TypeScriptet, hogy az eredményt objektumként Vacation kezelje.

Helyezze át az útvonaldefiníciót a putVacation fájlból a index.ts fájlba. Frissítse a metódustulajdonság-tömböt a következőre PUT: .

app.http('updateVacation', {
    methods: ['PUT'],
    route: 'vacations/{id}',
    authLevel: 'anonymous',
    handler: updateVacation
});

A HTTP DELETE függvény létrehozása

Hozza létre a DELETE szabadság hozzáadását kezelő függvényt.

A Visual Studio Code-ban nyissa meg a parancspalettát a Ctrl Shift + P billentyűkombinációval + , írja be Azure Functions: Create Function és nyomja le az Enter billentyűt.
Típusként válassza a HTTP-eseményindítót , névként pedig a deleteVacation elemet.
Adja hozzá a vacationService importálást a fájlhoz.
```
import { vacationService } from '../services';
```

Cserélje le a boilerplate függvényt deleteVacation az alábbi kódra az adathozzáféréshez és a hibakezeléshez.

export async function deleteVacation(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
  context.log(`Http function processed request for url "${request.url}"`);

  try {

    const id = request.params.id;

    if (!id) {
      return {
        status: 400,
        jsonBody: {
          error: 'ID parameter is required'
        }
      };
    }

    const deletedVacation = vacationService.deleteVacation(id);

    if (deletedVacation) {
      return {
        status: 204,
        jsonBody: {
          deleteVacation
        }
      };
    } else {
      return {
        status: 404,
        jsonBody: {
          error: `Vacation with ID ${id} not found`
        }
      };
    }
  } catch (error: unknown) {
    const err = error as Error;
    context.error(`Error deleting vacation: ${err.message}`);

    return {
      status: 500,
      jsonBody: {
        error: 'Failed to delete vacation'
      }
    };
  }
};

A request.params.id tulajdonság használatával lekérheti a szabadságazonosítót az URL-címről.

Helyezze át az útvonaldefiníciót a deleteVacation fájlból a index.ts fájlba. Frissítse a metódustulajdonság-tömböt a következőre DELETE: .
```
app.http('deleteVacation', {
    methods: ['DELETE'],
    route: 'vacations/{id}',
    authLevel: 'anonymous',
    handler: deleteVacation
});
```

Nyissa meg a következő leckét a létrehozott Azure Functions-alkalmazás áttekintéséhez.

Folytatás