Oefening: functies maken voor de Azure Functions-app

9 minuten

In deze les maakt en configureert u functies in de Azure Functions-app voor de GET, POSTen PUTDELETE eindpunten in de Node.js Express-app.

Gegevenstoegang toevoegen aan de functie GET

U hebt het eerste API-eindpunt gemaakt toen u de Azure Functions-app in de laatste les maakte. Deze functie wordt uitgevoerd wanneer een HTTP GET wordt aangevraagd op /vacations. U moet de standaardcode bijwerken om de gegevensservice aan te roepen om de vakanties op te halen.

Open het bestand functions/src/functions/getVacations.ts .
Open het bestand server/routes/vacation.routes.ts in een afzonderlijk venster, zodat u beide bestanden naast elkaar kunt zien.
Voeg in getVacations.ts de importinstructie vacationService toe.
```
import { vacationService } from '../services';
```

Bewerk in getVacations.ts de functie om de getVacations vacationService aan te roepen.

 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
 };

Je kunt daar stoppen. Dat is de enige code die u aan de functie moet toevoegen om de vakanties op te halen. U moet echter ook code opgeven voor het afhandelen van fouten en het retourneren van een statuscode. Werk de functie bij om de volgende code te gebruiken.

 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'
       }
     };
   }
 };

De Azure Functions-routes organiseren

In het v4-programmeermodel kunt u uw routes op verschillende manieren organiseren. U kunt de routedefinitie met de route-handler in één bestand laten staan. Dit is prima voor een toepassing met één eindpunt. Als ontwikkelaar bij Tailwind Traders weet u dat deze toepassing zal groeien tot veel API's die moeten worden georganiseerd.

Als u die organisatie wilt starten, maakt u een nieuw ./functions/src/index.ts bestand om de routedefinities vast te leggen.
Voeg de afhankelijkheid toe voor de app die is opgegeven vanuit het @azure/functions pakket.
```
import { app } from '@azure/functions';
```
Voeg de afhankelijkheid voor de functie getVacations toe uit het ./functions/getVacations bestand.
```
import { getVacations } from `./functions/getVacations`;
```

Verplaats de routedefinitie van ./functions/getVacations naar het index.ts-bestand . Werk de eigenschapmatrix van de methode bij naar GET.

app.http('getVacations', {
    methods: ['GET'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: getVacations
});

De functie en handler een naam geven

De naam getVacations wordt gebruikt als zowel de eerste parameter voor app.http als als een eigenschap in de tweede parameter. Dit kan verwarrend zijn en mogelijk wilt u verschillende naamgevingsregels in uw organisatie of team, afhankelijk van hoe de naam wordt gebruikt.

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

Eerste parameter - naam als tekenreeks: de waarde voor de eerste parameter is de naam van de functie, zoals deze wordt weergegeven in Azure Portal. Deze namen worden alfanumerisch weergegeven in de portal, dus u kunt een naamconventie gebruiken die vergelijkbare functies groepeert op doel, zoals vacationGet of op methode, zoals getVacation. U kunt ook een ander geval kiezen, zoals snake_case, jpeg-case of camelCase.
Tweede parameter - handler-functie: de waarde voor de tweede parameter is de naam van de functie-handler zoals deze wordt geïmporteerd en gebruikt in de code. Deze naam moet beschrijvend zijn en overeenkomen met het doel van de functie. Het kan voldoen aan naamconventies die u al hebt voor functies in uw codebasis en kan worden afgedwongen met typische hulpprogramma's voor codeconformiteit.

De resterende functies maken

Er zijn vier eindpunten in de Node.js Express-toepassing en u hebt zojuist de functie voor het GET eindpunt gemaakt. Maak nu functies voor de resterende route-eindpunten.

Wijze	HTTP-triggernaam	Route
`POST`	`postVacation`	`vacations`
`PUT`	`updateVacation`	`vacations/{id}`
`DELETE`	`deleteVacation`	`vacations/{id}`

Hoewel de GET- en POST-routes hetzelfde zijn. De PUT en DELETE routes gebruiken een parameter om te bepalen welke vakantie moet worden gebruikt.

De HTTP POST-functie maken

Maak de POST functie die het toevoegen van een vakantie afhandelt.

Open in Visual Studio Code het opdrachtpalet met Ctrl + Shift +P en typ Azure Functions: Create Function en druk op Enter.
Selecteer HTTP-trigger als het type en postVacation als de naam.
Voeg de importinstructie vacationService toe aan het bestand.
```
import { vacationService } from '../services';
```

Vervang de standaardfunctie postVacation door de volgende code voor gegevenstoegang en foutafhandeling.

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'
            }
        };
    }
}

Als u de binnenkomende vakantiegegevens wilt lezen, gebruikt u de request.json() methode. Deze methode retourneert een belofte die wordt omgezet in de JSON-gegevens in de aanvraagbody. Vervolgens gebruikt u het await trefwoord om te wachten tot de belofte is opgelost. De as Vacation syntaxis is een typeverklaring waarmee TypeScript het resultaat als een Vacation object moet behandelen.

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

Verplaats de routedefinitie van het postVacation-bestand naar het index.ts-bestand . Werk de eigenschapmatrix van de methode bij naar POST.

app.http('post-vacation', {
    methods: ['POST'],
    route: 'vacations',
    authLevel: 'anonymous',
    handler: postVacation
});

De HTTP PUT-functie maken

Maak de PUT functie die het toevoegen van een vakantie afhandelt.

Open in Visual Studio Code het opdrachtpalet met Ctrl + Shift + P en typ Azure Functions: Create Function en druk op Enter.
Selecteer HTTP-trigger als het type en updateVacation als de naam.
Voeg de importinstructie vacationService toe aan het bestand.
```
import { vacationService } from '../services';
```

Vervang de standaardfunctie updateVacation door de volgende code voor gegevenstoegang en foutafhandeling.

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'
      }
    };
  }
};

De request.params.id eigenschap wordt gebruikt om de vakantie-id op te halen uit de URL. De request.json() methode wordt gebruikt om de vakantiegegevens op te halen uit de aanvraagbody. De as Vacation syntaxis is een typeverklaring waarmee TypeScript het resultaat als een Vacation object moet behandelen.

Verplaats de routedefinitie van het putVacation-bestand naar het index.ts-bestand . Werk de eigenschapmatrix van de methode bij naar PUT.

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

De functie HTTP DELETE maken

Maak de DELETE functie die het toevoegen van een vakantie afhandelt.

Open in Visual Studio Code het opdrachtpalet met Ctrl + Shift + P en typ Azure Functions: Create Function en druk op Enter.
Selecteer HTTP-trigger als het type en verwijderVacation als de naam.
Voeg de vacationService-import toe aan het bestand.
```
import { vacationService } from '../services';
```

Vervang de standaardfunctie deleteVacation door de volgende code voor gegevenstoegang en foutafhandeling.

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'
      }
    };
  }
};

De request.params.id eigenschap wordt gebruikt om de vakantie-id op te halen uit de URL.

Verplaats de routedefinitie van het deleteVacation-bestand naar het index.ts-bestand . Werk de eigenschapmatrix van de methode bij naar DELETE.

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

Ga naar de volgende les om de Azure Functions-toepassing te controleren die u hebt gemaakt.