---
title: "Flatpages-appen"
version: 6.1
locale: sv
source: https://docs.djangoproject.com/sv/6.1/ref/contrib/flatpages/
canonical: https://djangodocs.dev/sv/6.1/ref/contrib/flatpages/
---
# Flatpages-appen

Django levereras med en valfri ”flatpages”-applikation. Den låter dig lagra ”platt” HTML-innehåll i en databas och hanterar hanteringen åt dig via Djangos admin-gränssnitt och ett Python API.

En flatpage är ett objekt med en URL, en titel och ett innehåll. Använd den för enstaka sidor i specialfall, t.ex. sidor med ”Om” eller ”Sekretesspolicy”, som du vill lagra i en databas men som du inte vill utveckla en anpassad Django-applikation för.

En flatpage kan använda en anpassad mall eller en standardmall för flatpage som gäller för hela systemet. Den kan vara kopplad till en eller flera webbplatser.

Innehållsfältet kan eventuellt lämnas tomt om du föredrar att lägga ditt innehåll i en anpassad mall.

## Installation

Följ dessa steg för att installera Flatpages-appen:

1. Installera [`sites-ramverket`](/sv/6.1/ref/contrib/sites/#module-django.contrib.sites) genom att lägga till `'django.contrib.sites'` i din [`INSTALLED_APPS`](/sv/6.1/ref/settings/#std-setting-INSTALLED_APPS)-inställning, om det inte redan finns där.

   Kontrollera också att du har ställt in [`SITE_ID`](/sv/6.1/ref/settings/#std-setting-SITE_ID) till ID:t för den webbplats som inställningsfilen representerar. Detta är vanligtvis `1` (dvs. `SITE_ID = 1`), men om du använder sites-ramverket för att hantera flera webbplatser kan det vara ID:t för en annan webbplats.
2. Lägg till `'django.contrib.flatpages'` till din [`INSTALLED_APPS`](/sv/6.1/ref/settings/#std-setting-INSTALLED_APPS) inställning.

Då antingen..:

3. Lägg till en post i din URLconf. Till exempel:

   ```
   urlpatterns = [
       path("pages/", include("django.contrib.flatpages.urls")),
   ]
   ```

eller:

3. Lägg till `'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'` till din [`MIDDLEWARE`](/sv/6.1/ref/settings/#std-setting-MIDDLEWARE) inställning.
4. Kör kommandot [`manage.py migrate`](/sv/6.1/ref/django-admin/#django-admin-migrate).

## Hur det fungerar

`manage.py migrate` skapar två tabeller i din databas: `django_flatpage` och `django_flatpage_sites`. `django_flatpage` är en uppslagstabell som mappar en URL till en titel och en massa textinnehåll. `django_flatpage_sites` associerar en flatpage med en webbplats.

### Använda URLconf

There are several ways to include the flatpages in your URLconf. You can
dedicate a particular path to flatpages:

```
urlpatterns = [
    path("pages/", include("django.contrib.flatpages.urls")),
]
```

Du kan också använda det som ett ”catchall”-mönster. I det här fallet är det viktigt att placera mönstret i slutet av de andra urlmönstren:

```
from django.contrib.flatpages import views

# Your other patterns here
urlpatterns += [
    re_path(r"^(?P<url>.*/)$", views.flatpage),
]
```

> **Warning**
>
> Om du ställer in [`APPEND_SLASH`](/sv/6.1/ref/settings/#std-setting-APPEND_SLASH) till `False` måste du ta bort snedstrecket i catchall-mönstret, annars matchas inte sidor utan ett efterföljande snedstreck.

Another common setup is to use flatpages for a limited set of known pages and
to hardcode their URLs in the [URLconf](/sv/6.1/topics/http/urls/):

```
from django.contrib.flatpages import views

urlpatterns += [
    path("about-us/", views.flatpage, kwargs={"url": "/about-us/"}, name="about"),
    path("license/", views.flatpage, kwargs={"url": "/license/"}, name="license"),
]
```

Argumentet `kwargs` anger det `url`-värde som används för modelluppslagningen `FlatPage` i flatpage-vyn.

Argumentet `name` gör att URL:en kan vändas i mallar, t.ex. med hjälp av malltaggen [`url`](/sv/6.1/ref/templates/builtins/#std-templatetag-url).

### Använda mellanprogram

Klassen:~django.contrib.flatpages.middleware.FlatpageFallbackMiddleware kan göra allt arbete.

#### `class FlatpageFallbackMiddleware`

Varje gång en Django-applikation ger upphov till ett 404-fel kontrollerar detta middleware flatpages-databasen för den begärda webbadressen som en sista utväg. Specifikt kontrolleras om det finns en flatpage med den angivna URL:en med ett webbplats-ID som motsvarar inställningen [`SITE_ID`](/sv/6.1/ref/settings/#std-setting-SITE_ID).

Om den hittar en matchning följer den den här algoritmen:

- Om sidan har en egen mall laddas den mallen. Annars laddas mallen `flatpages/default.html`.
- Den skickar den mallen en enda kontextvariabel, `flatpage`, som är flatpage-objektet. Den använder [`RequestContext`](/sv/6.1/ref/templates/api/#django.template.RequestContext) vid rendering av mallen.

Mellanvaran lägger bara till ett efterföljande snedstreck och omdirigerar (genom att titta på inställningen [`APPEND_SLASH`](/sv/6.1/ref/settings/#std-setting-APPEND_SLASH)) om den resulterande URL:en hänvisar till en giltig flatpage. Omdirigeringar är permanenta (301 statuskod).

Om den inte hittar någon matchning fortsätter begäran att behandlas som vanligt.

Middleware aktiveras endast för 404:or - inte för 500:or eller svar med någon annan statuskod.

> **Flatpages kommer inte att tillämpa view middleware**
>
> Eftersom `FlatpageFallbackMiddleware` tillämpas först efter att URL-upplösningen har misslyckats och resulterat i en 404, kommer det svar som returneras inte att tillämpa några [view middleware](/sv/6.1/topics/http/middleware/#view-middleware)-metoder. Endast förfrågningar som framgångsrikt dirigeras till en vy via normal URL-upplösning tillämpar view middleware.

Observera att ordningen på [`MIDDLEWARE`](/sv/6.1/ref/settings/#std-setting-MIDDLEWARE) spelar roll. I allmänhet kan du sätta [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware) i slutet av listan. Detta innebär att det kommer att köras först när svaret bearbetas och säkerställer att alla andra svarsbearbetande mellanprogram ser det riktiga flatpage-svaret snarare än 404.

Mer information om middleware finns i [middleware docs](/sv/6.1/topics/http/middleware/).

> **Se till att din 404-mall fungerar**
>
> Note that the
> [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware)
> only steps in once another view has successfully produced a 404 response.
> If another view or middleware class attempts to produce a 404 but ends up
> raising an exception instead, the response will become an HTTP 500
> (”Internal Server Error”) and the
> [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware)
> will not attempt to serve a flatpage.

## Så här lägger du till, ändrar och tar bort flatpages

> **Warning**
>
> Behörighet att lägga till eller redigera flatpages bör begränsas till betrodda användare. Flatpages definieras av rå HTML och är **inte sanerade** av Django. Som en följd av detta kan en skadlig flatpage leda till olika säkerhetsproblem, inklusive behörighetseskalering.

### Via administratörsgränssnittet

Om du har aktiverat det automatiska Django-administratörsgränssnittet bör du se ett ”Flatpages”-avsnitt på adminindexsidan. Redigera flatpages som du redigerar alla andra objekt i systemet.

Modellen `FlatPage` har ett fält `enable_comments` som inte används av `contrib.flatpages`, men som kan vara användbart för ditt projekt eller tredjepartsappar. Det visas inte i admin-gränssnittet, men du kan lägga till det genom att registrera en anpassad `ModelAdmin` för `FlatPage`:

```
from django.contrib import admin
from django.contrib.flatpages.admin import FlatPageAdmin
from django.contrib.flatpages.models import FlatPage
from django.utils.translation import gettext_lazy as _

# Define a new FlatPageAdmin
class FlatPageAdmin(FlatPageAdmin):
    fieldsets = [
        (None, {"fields": ["url", "title", "content", "sites"]}),
        (
            _("Advanced options"),
            {
                "classes": ["collapse"],
                "fields": [
                    "enable_comments",
                    "registration_required",
                    "template_name",
                ],
            },
        ),
    ]

# Re-register FlatPageAdmin
admin.site.unregister(FlatPage)
admin.site.register(FlatPage, FlatPageAdmin)
```

### Via Python API

Flatpages representeras av en standard [Django model](/sv/6.1/topics/db/models/), [`FlatPage`](#django.contrib.flatpages.models.FlatPage). Du kan komma åt flatpage-objekt via [Django database API](/sv/6.1/topics/db/queries/).

> **Kontrollera om det finns dubbletter av URL:er för flatpage.**
>
> Om du lägger till eller ändrar flatpages via din egen kod kommer du sannolikt att vilja kontrollera om det finns dubbla URL:er för flatpages på samma webbplats. Flatpage-formuläret som används i admin utför denna valideringskontroll och kan importeras från `django.contrib.flatpages.forms.FlatpageForm` och användas i dina egna vyer.

## `FlatPage` modell

#### `class models.FlatPage`

### Fält

[`FlatPage`](#django.contrib.flatpages.models.FlatPage)-objekt har följande fält:

#### `class models.FlatPage`

#### `url`

Krävs. 100 tecken eller färre. Indexerad för snabbare sökningar.

#### `title`

Krävs. 200 tecken eller färre.

#### `content`

Valfritt ([`blank=True`](/sv/6.1/ref/models/fields/#django.db.models.Field.blank)). [`TextField`](/sv/6.1/ref/models/fields/#django.db.models.TextField) som vanligtvis innehåller HTML-innehållet på sidan.

#### `enable_comments`

Boolesk. Detta fält används inte av [`flatpages`](#module-django.contrib.flatpages) som standard och visas inte i admin-gränssnittet. Se [flatpages admin interface section](#flatpages-admin) för en detaljerad förklaring.

#### `template_name`

Valfritt ([`blank=True`](/sv/6.1/ref/models/fields/#django.db.models.Field.blank)). 70 tecken eller färre. Anger den mall som används för att rendera sidan. Standardvärdet är `flatpages/default.html` om den inte anges.

#### `sites`

Många-till-många-relation till [`Site`](/sv/6.1/ref/contrib/sites/#django.contrib.sites.models.Site), som bestämmer [sites](/sv/6.1/ref/contrib/sites/) som den platta sidan är tillgänglig på.

### Metoder

#### `class models.FlatPage`

#### `get_absolute_url()`

Returnerar den relativa URL-sökvägen för sidan baserat på attributet [`url`](#django.contrib.flatpages.models.FlatPage.url).

## Mallar för platta sidor

By default, flatpages are rendered via the template
`flatpages/default.html`, but you can override that for a particular
flatpage: in the admin, a collapsed fieldset titled ”Advanced options”
(clicking will expand it) contains a field for specifying a template name. If
you’re creating a flatpage via the Python API you can set the template name as
the field `template_name` on the `FlatPage` object.

Det är ditt ansvar att skapa mallen `flatpages/default.html`; i din mallkatalog skapar du en katalog `flatpages` som innehåller filen `default.html`.

Flatpage-mallar får en enda kontextvariabel, `flatpage`, som är flatpage-objektet.

Här är ett exempel på en `flatpages/default.html` mall:

```html+django
<!DOCTYPE html>
<html lang="en">
<head>
<title>{{ flatpage.title }}</title>
</head>
<body>
{{ flatpage.content }}
</body>
</html>
```

Eftersom du redan skriver in rå HTML på adminsidan för en flatpage, markeras både `flatpage.title` och `flatpage.content` som **inte** krävande [automatisk HTML-escaping](/sv/6.1/ref/templates/language/#automatic-html-escaping) i mallen.

## Få en lista över [`FlatPage`](#django.contrib.flatpages.models.FlatPage)-objekt i dina mallar

Appen Flatpages tillhandahåller en malltagg som gör att du kan iterera över alla tillgängliga flatpages på [aktuell webbplats](/sv/6.1/ref/contrib/sites/#hooking-into-current-site-from-views).

Som alla anpassade malltaggar måste du [ladda dess anpassade taggbibliotek](/sv/6.1/ref/templates/language/#loading-custom-template-libraries) innan du kan använda den. När du har laddat biblioteket kan du hämta alla aktuella flatpages via taggen [`get_flatpages`](#std-templatetag-get_flatpages):

```html+django
{% load flatpages %}
{% get_flatpages as flatpages %}
<ul>
    {% for page in flatpages %}
        <li><a href="{{ page.url }}">{{ page.title }}</a></li>
    {% endfor %}
</ul>
```

### Visning av `registration_required` flatpages

Som standard visar malltaggen [`get_flatpages`](#std-templatetag-get_flatpages) endast flatpages som är markerade med `registration_required = False`. Om du vill visa registreringsskyddade flatpages måste du ange en autentiserad användare med hjälp av en `for`-klausul.

Till exempel:

```html+django
{% get_flatpages for someuser as about_pages %}
```

Om du anger en anonym användare kommer [`get_flatpages`](#std-templatetag-get_flatpages) att bete sig på samma sätt som om du inte hade angett någon användare - dvs. den kommer bara att visa dig offentliga flatpages.

### Begränsa flatpages genom bas-URL

Ett valfritt argument, `starts_with`, kan användas för att begränsa de returnerade sidorna till dem som börjar med en viss bas-URL. Detta argument kan skickas som en sträng eller som en variabel som ska lösas upp från kontexten.

Till exempel:

```html+django
{% get_flatpages '/about/' as about_pages %}
{% get_flatpages about_prefix as about_pages %}
{% get_flatpages '/about/' for someuser as about_pages %}
```

## Integrering med [`django.contrib.sitemaps`](/sv/6.1/ref/contrib/sitemaps/#module-django.contrib.sitemaps)

#### `class FlatPageSitemap`

Klassen [`sitemaps.FlatPageSitemap`](#django.contrib.flatpages.sitemaps.FlatPageSitemap) tittar på alla offentligt synliga [`flatpages`](#module-django.contrib.flatpages) som definieras för den aktuella [`SITE_ID`](/sv/6.1/ref/settings/#std-setting-SITE_ID) (se [`sites-dokumentationen`](/sv/6.1/ref/contrib/sites/#module-django.contrib.sites)) och skapar en post i webbplatskartan. Dessa poster inkluderar endast attributet [`location`](/sv/6.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.location) – inte [`lastmod`](/sv/6.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.lastmod), [`changefreq`](/sv/6.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.changefreq) eller [`priority`](/sv/6.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.priority).

### Exempel

Här är ett exempel på en URLconf som använder [`FlatPageSitemap`](#django.contrib.flatpages.sitemaps.FlatPageSitemap):

```
from django.contrib.flatpages.sitemaps import FlatPageSitemap
from django.contrib.sitemaps.views import sitemap
from django.urls import path

urlpatterns = [
    # ...
    # the sitemap
    path(
        "sitemap.xml",
        sitemap,
        {"sitemaps": {"flatpages": FlatPageSitemap}},
        name="django.contrib.sitemaps.views.sitemap",
    ),
]
```