---
title: "Aplikasi flatpage"
version: 5.1
locale: id
source: https://docs.djangoproject.com/id/5.1/ref/contrib/flatpages/
canonical: https://djangodocs.dev/id/5.1/ref/contrib/flatpages/
---
# Aplikasi flatpage

Django comes with an optional "flatpages" application. It lets you store "flat"
HTML content in a database and handles the management for you via Django's
admin interface and a Python API.

A flatpage is an object with a URL, title and content. Use it for one-off,
special-case pages, such as "About" or "Privacy Policy" pages, that you want to
store in a database but for which you don't want to develop a custom Django
application.

Sebuah flatpage dapat menggunakan cetakan penyesuaian atau awalan, cetakan flatpage sistem luas. Itu dapat dikaitkan dengan satu, atau banyak, situs.

Bidang isi mungkin pilihan ditinggalkan kosong jika anda memilih menaruh isi anda di penyesuaian cetakan.

## Pemasangan

Untuk memasang aplikasi flatpages, ikuti langkah ini:

1. Pasang [`sites framework`](/id/5.1/ref/contrib/sites/#module-django.contrib.sites) dengan menambahkan `'django.contrib.sites'` pada pengaturan [`INSTALLED_APPS`](/id/5.1/ref/settings/#std-setting-INSTALLED_APPS) anda, jika itu sudah tidak disana.

   Juga pastikan anda telah benar menyetel [`SITE_ID`](/id/5.1/ref/settings/#std-setting-SITE_ID) menjadi ID dari situs berkas pengaturan diwakili. Ini biasanya berupa `1` (yaitu `SITE_ID = 1`, tetapi jika anda sedang menggunakan kerangka kerja situs untuk mengelola banyak situs, itu dapat berupa ID dari situs berbeda.
2. Tambah `'django.contrib.flatpages'` ke pengaturan [`INSTALLED_APPS`](/id/5.1/ref/settings/#std-setting-INSTALLED_APPS) anda.

Maka salah satu:

3. Tambah sebuah masukan dalam URLconf anda.  Sebagai contoh:

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

atau:

3. Tambah `'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'` ke pengaturan [`MIDDLEWARE`](/id/5.1/ref/settings/#std-setting-MIDDLEWARE) anda.
4. Jalankan perintah [`manage.py migrate`](/id/5.1/ref/django-admin/#django-admin-migrate).

## Bagaimana itu bekerja

`manage.py migrate` creates two tables in your database: `django_flatpage`
and `django_flatpage_sites`. `django_flatpage` is a lookup table that maps
a URL to a title and bunch of text content. `django_flatpage_sites`
associates a flatpage with a site.

### Menggunakan URLconf

Ada beberapa cara untuk menyertakan halaman-halaman datar dalam URLconf anda. Anda dapat mengamanatkan jalur tertentu pada halaman-halaman datar:

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

Anda dapat juga menyetel itu sebagai sebuah pola "catchall". Dalam kasus ini, itu adalah penting menempatkan pola pada akhir dari urlpattern lain:

```
from django.contrib.flatpages import views

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

> **Warning**
>
> Jika anda menyetel [`APPEND_SLASH`](/id/5.1/ref/settings/#std-setting-APPEND_SLASH) menjadi `False`, anda harus memindahkan garis miring dalam pola catchall atau halaman-halaman datar tanpa diikuti garis miring tidak akan cocok.

Pengaturan lain umum adalah menggunakan halaman-halaman datar untuk kumpulan terbatas dari halaman-halaman yang dikenal dan kode keras url, jadi anda dapat mengacu mereka dengan etiket cetakan [`url`](/id/5.1/ref/templates/builtins/#std-templatetag-url):

```
from django.contrib.flatpages import views

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

### Menggunakan middleware

[`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware) dapat melakukan semua dari pekerjaan.

#### `class FlatpageFallbackMiddleware`

Setiap kali aplikasi Django apapun memunculkan kesalahan 404, middleware ini memeriksa bahwa basisdata flatpage untuk URL diminta sebagai usaha terakhir. Khususnya, itu memeriksa untuk flatpage dengan URL diberikan dengan ID situs yang berhubungan pada pengaturan [`SITE_ID`](/id/5.1/ref/settings/#std-setting-SITE_ID).

Jika dia menemukan yang cocok, dia mengikuti algoritma ini:

- Jika halaman datar mempunyai cetakan penyesuaian, itu memuat cetakan tersebut. Sebaliknya, itu memuat cetakan `flatpages/default.html`.
- Itu melewatkan cetakan tersebut sebuah variabel konteks tunggal, `flatpage`, yaitu obyek halaman datar. Itu menggunakan [`RequestContext`](/id/5.1/ref/templates/api/#django.template.RequestContext) dalam membangun cetakan.

Middleware hanya akan menambah garis miring dan mengalihkan (dengan mencari pada pengaturan [`APPEND_SLASH`](/id/5.1/ref/settings/#std-setting-APPEND_SLASH)) jika URL yang dihasilkan mengacu ke halaman datar yang sah. Pengalihan adalah tetap (kode keadaan 301).

Jika itu tidak menemukan kecocokan, permintaan berlanjut untuk diolah seperti biasa.

Middleware hanya dapat diaktifasikan untuk 404 -- bukan untuk 500 atau tanggapan kode keadaan apapun lainnya.

> **Flatpage tidak akan memberlakukan tampilan middleware**
>
> Karena `FlatpageFallbackMiddleware` diberlakukan hanya setelah keputusan URL gagal dan menghasilkan 404, tanggapan itu mengembalikan tidak akan memberlakukan metode view middleware 1 apapun. Hanya permintaan yang berhasil dirutekan untuk ditampilkan melalui keputusan URL biasa memberlakukan tampilan middleware.

Catat bahwa urutan dari [`MIDDLEWARE`](/id/5.1/ref/settings/#std-setting-MIDDLEWARE) penting. Umumnya, anda dapat menaruh [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware) pada akhir dari daftar. Ini berarti itu akan berjalan pertama ketika mengolah tanggapan, dan memastikan bahwa middleware pengolahan-tanggapan lain apapn melihat tanggapan flatpage daripada 404.

Untuk lebih pada middleware, baca [dokumentasi middleware](/id/5.1/topics/http/middleware/).

> **Pastikan bahwa cetakan 404 anda bekerja**
>
> Catat bahwa [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware) hanya melangkah dalam sekali tampilan lain telah berhasil menghasilkan tanggapan 404. Jika tampilan lain atau kelas middleware berusaha untuk menghasilkan 404 tetapi berakhir memunculkan sebuah pengecualian, tanggapan akan menjadi HTTP 500 ("Internal Server Error") dan [`FlatpageFallbackMiddleware`](#django.contrib.flatpages.middleware.FlatpageFallbackMiddleware) tidak akan berusaha melayani halaman datar.

## Bagaimana menambah, merubah dan menghapus flatpages

> **Warning**
>
> Permissions to add or edit flatpages should be restricted to trusted users.
> Flatpages are defined by raw HTML and are **not sanitized** by Django. As a
> consequence, a malicious flatpage can lead to various security
> vulnerabilities, including permission escalation.

### Melalui antarmuka admin

Jika anda telah diaktivasi antarmuka admin Django, anda harus melihat bagisn "Flatpages" pada halaman indeks admin. Sunting flatpage ketika anda menyunting obyek apapun lainnya dalam sistem.

Model `FlatPage` mempunyai bidang `enable_comments` yang tidak digunakan oleh `contrib.flatpages`, tetapi itu mungkin berguna untuk peoyek anda atau aplikasi pihak-ketiga. Itu tidak muncul dalam antarmuka admin, tetapi anda dapat menambahkan itu dengan mendaftarkan penyesuaian `ModelAdmin` untuk `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)
```

### Melalui API Python

#### `class FlatPage`

Flatpage diwakilkan oleh sebuah standar [Django model](/id/5.1/topics/db/models/), yang berada dalam [django/contrib/flatpages/models.py](https://github.com/django/django/blob/stable/5.1.x/django/contrib/flatpages/models.py). Anda dapat mengakses obyek flatpage melalui [Django database API](/id/5.1/topics/db/queries/).

> **Periksa untuk URL flatpage ganda.**
>
> Jika anda menambah atau merubah melalui kode anda sendiri, anda akan ingin memeriksa untuk URL faltpage ganda dalam situs yang sama. Formulir flatpage digunakan dalam admin melakukan pemeriksaan pengesahan ini, dan dapat diimpor dari `django.contrib.flatpages.forms.FlatpageForm` dan digunakan dalam tampilan anda sendiri.

## Cetakan flatpages

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 flat page via the
Python API you can set the template name as the field `template_name` on the
`FlatPage` object.

Creating the `flatpages/default.html` template is your responsibility;
in your template directory, create a `flatpages` directory containing a
file `default.html`.

Cetakan flatpage melewatkan variabel konteks tunggal, `flatpage`, yaitu obyek flatpage.

Ini adalah sebuah contoh cetakan `flatpages/default.html`:

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

Sejak anda sudah memasukkan HTML mentah kedalam halaman admin untuk sebuah flatpage, kedua `flatpage.title` dan `flatpage.content` ditandai sebagai **bukan** membutuhkan automatic HTML escaping 1 dalam cetakan.

## Mendapatkan daftar dari obyek [`FlatPage`](#django.contrib.flatpages.models.FlatPage) dalam cetakan anda

Aplikasi flatpage menyediakan sebuah etiket cetakan yang mengizinkan anda mengulangi semua flatpage yang tersedia pada current site 1.

Seperti semua etiket cetakan penyesuaian, anda akan butuh untuk load its custom tag library 1 sebelum anda dapat menggunakan itu. Setelah memuat pustaka, anda dapat mengambil semua flatpage melalui etiket [`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>
```

### Menampilkan flatpage `registration_required`

Secara awalan, etiket cetakan [`get_flatpages`](#std-templatetag-get_flatpages) akan hanya menunjukkan halaman datar yang ditandai `registration_required = False`. Jika anda ingin menampilkan halaman datar terlindungi-pendaftaran, anda butuh menentukan seorang pengguna terautentifikasi menggunakan klausa `for`.

Sebagai contoh:

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

Jika anda menyediakan pengguna anonim, [`get_flatpages`](#std-templatetag-get_flatpages) akan berperilaku sama seperti jika anda belum menyediakan pengguna -- yaitu, itu akan hanya menampilkan flatpage umum anda.

### Membatasi flatpage dengan URL dasar

Sebuah argumen pilihan, `starts_with`, dapat diberlakukan pada batasan halaman dikembalikan ke yang dimulai dengan URL dasar tertentu. Argumen ini mungkin dilewatkan sebagai sebuah string, atau sebagai sebuah variabel untuk dipecahkan dari konteks.

Sebagai contoh:

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

## Memadukan dengan [`django.contrib.sitemaps`](/id/5.1/ref/contrib/sitemaps/#module-django.contrib.sitemaps)

#### `class FlatPageSitemap`

Kelas [`sitemaps.FlatPageSitemap`](#django.contrib.flatpages.sitemaps.FlatPageSitemap) mencari semua [`flatpages`](#module-django.contrib.flatpages) yang nampak di depan umum ditentukan untuk [`SITE_ID`](/id/5.1/ref/settings/#std-setting-SITE_ID) saat ini (lihat [`sites documentation`](/id/5.1/ref/contrib/sites/#module-django.contrib.sites)) dan buat sebuah masukan dalam peta situs. Masukan ini termasuk hanya atribut [`location`](/id/5.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.location) -- bukan [`lastmod`](/id/5.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.lastmod), [`changefreq`](/id/5.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.changefreq) atau [`priority`](/id/5.1/ref/contrib/sitemaps/#django.contrib.sitemaps.Sitemap.priority).

### Contoh

Ini adalah sebuah contoh dari URLconf menggunakan [`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",
    ),
]
```