Övning – Skapa funktioner för Azure Functions-appen

9 minuter

I den här lektionen skapar och konfigurerar du funktioner i Azure Functions-appen för slutpunkterna GET, POST, PUToch DELETE i Node.js Express-appen.

Lägga till dataåtkomst till GET-funktionen

Du skapade den första API-slutpunkten när du skapade Azure Functions-appen i den senaste lektionen. Den här funktionen körs när en HTTP GET begärs på /vacations. Du måste uppdatera exempelkoden för att anropa datatjänsten för att få semester.

Öppna filen functions/src/functions/getVacations.ts.
Öppna filen server/vägar/vacation.routes.ts i ett separat fönster så att du kan se båda filerna sida vid sida.
Lägg till vacationService-import-instruktionen i getVacations.ts.
```
import { vacationService } from '../services';
```

I getVacations.ts redigerar du getVacations funktionen för att anropa vacationService.

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

Du kan stanna där. Det är den enda kod som du behöver lägga till i funktionen för att få semester. Du bör dock även ange kod för att hantera fel och returnera en statuskod. Uppdatera funktionen så att den använder följande kod.

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

Organisera Azure Functions-vägarna

I programmeringsmodellen v4 kan du organisera dina vägar på flera olika sätt. Du kan lämna routningsdefinitionen med routningshanteraren i en enda fil. Detta är bra för ett program med en slutpunkt. Som utvecklare på Tailwind Traders vet du att det här programmet kommer att växa till många API:er som måste organiseras.

Om du vill starta organisationen skapar du en ny ./functions/src/index.ts fil för att avbilda routningsdefinitionerna.
Lägg till beroendet för appen som tillhandahålls @azure/functions från paketet.
```
import { app } from '@azure/functions';
```
Lägg till beroendet för funktionen getVacations från ./functions/getVacations filen.
```
import { getVacations } from `./functions/getVacations`;
```

Flytta routningsdefinitionen från ./functions/getVacations till filen index.ts . Uppdatera metodegenskapsmatrisen till GET.

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

Namnge funktionen och hanteraren

Namnet getVacations används både som den första parametern till app.http och som en egenskap i den andra parametern. Detta kan vara förvirrande och du kanske vill ha olika namngivningsregler i din organisation eller ditt team, beroende på hur namnet används.

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

Första parametern – namn som sträng: Värdet för den första parametern är namnet på funktionen så som den visas i Azure-portalen. Dessa namn visas alfanumeriskt i portalen, så du kanske vill använda en namngivningskonvention som grupperar liknande funktioner efter syfte, till exempel vacationGet eller efter metod, till exempel getVacation. Du kan också välja ett annat fall, till exempel snake_case, kebab-case eller camelCase.
Den andra parametern – hanteringsfunktionen: Värdet för den andra parametern är namnet på funktionshanteraren eftersom den importeras och används i koden. Det här namnet ska vara beskrivande och matcha syftet med funktionen. Den kan följa namngivningskonventioner som du redan har för funktioner i kodbasen och kan tillämpas med vanliga verktyg för kodöverensstämmelse.

Skapa de återstående funktionerna

Det finns fyra slutpunkter i Node.js Express-programmet och du har precis skapat funktionen för GET slutpunkten. Skapa nu funktioner för de återstående routningsslutpunkterna.

Metod	HTTP-utlösarnamn	Flöde
`POST`	`postVacation`	`vacations`
`PUT`	`updateVacation`	`vacations/{id}`
`DELETE`	`deleteVacation`	`vacations/{id}`

Även om GET- och POST-vägarna är desamma. Vägarna PUT och DELETE använder en parameter för att identifiera vilken semester som ska användas.

Skapa funktionen HTTP POST

Skapa den POST funktion som hanterar att lägga till en semester.

I Visual Studio Code öppnar du kommandopaletten med Ctrl + Skift +P och skriver Azure Functions: Create Function och trycker på Retur.
Välj HTTP-utlösare som typ och postVacation som namn.
Lägg till vacationService-importinstruktionen i filen.
```
import { vacationService } from '../services';
```

Ersätt funktionen boilerplate postVacation med följande kod för dataåtkomst och felhantering.

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

Om du vill läsa inkommande semesterdata använder request.json() du metoden . Den här metoden returnerar ett löfte som matchar JSON-data i begärandetexten. Sedan använder du nyckelordet await för att vänta på att löftet ska lösas. Syntaxen as Vacation är en typkontroll som instruerar TypeScript att behandla resultatet som ett Vacation objekt.

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

Flytta routningsdefinitionen från postVacation-filen till filen index.ts . Uppdatera metodegenskapsmatrisen till POST.

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

Skapa funktionen HTTP PUT

Skapa den PUT funktion som hanterar att lägga till en semester.

I Visual Studio Code öppnar du kommandopaletten med Ctrl + Skift + P och skriver Azure Functions: Create Function och trycker på Retur.
Välj HTTP-utlösare som typ och uppdateraVacation som namn.
Lägg till vacationService-importinstruktionen i filen.
```
import { vacationService } from '../services';
```

Ersätt funktionen boilerplate updateVacation med följande kod för dataåtkomst och felhantering.

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

Egenskapen request.params.id används för att hämta semester-ID:t från URL:en. Metoden request.json() används för att hämta semesterdata från begärandetexten. Syntaxen as Vacation är en typkontroll som instruerar TypeScript att behandla resultatet som ett Vacation objekt.

Flytta routningsdefinitionen från putVacation-filen till index.ts-filen. Uppdatera metodegenskapsmatrisen till PUT.

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

Skapa funktionen HTTP DELETE

Skapa den DELETE funktion som hanterar att lägga till en semester.

I Visual Studio Code öppnar du kommandopaletten med Ctrl + Skift + P och skriver Azure Functions: Create Function och trycker på Retur.
Välj HTTP-utlösare som typ och ta bortVacation som namn.

Lägg till vacationService-importen i filen.

import { vacationService } from '../services';

Ersätt funktionen boilerplate deleteVacation med följande kod för dataåtkomst och felhantering.

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

Egenskapen request.params.id används för att hämta semester-ID:t från URL:en.

Flytta routningsdefinitionen från filen deleteVacation till filen index.ts . Uppdatera metodegenskapsmatrisen till DELETE.

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

Gå till nästa enhet för att granska Azure Functions-programmet som du skapade.

Fortsätt