{{ object.title }}
9 | 10 | 19 | {% endblock %} 20 | -------------------------------------------------------------------------------- /froide_govplan/apps.py: -------------------------------------------------------------------------------- 1 | from django.apps import AppConfig 2 | from django.utils.translation import gettext_lazy as _ 3 | 4 | 5 | class FroideGovPlanConfig(AppConfig): 6 | name = "froide_govplan" 7 | verbose_name = _("GovPlan App") 8 | 9 | def ready(self): 10 | from froide.api import api_router 11 | from froide.follow.configuration import follow_registry 12 | 13 | from .api_views import GovernmentPlanViewSet 14 | from .configuration import GovernmentPlanFollowConfiguration 15 | 16 | follow_registry.register(GovernmentPlanFollowConfiguration()) 17 | 18 | api_router.register( 19 | r"governmentplan", GovernmentPlanViewSet, basename="governmentplan" 20 | ) 21 | -------------------------------------------------------------------------------- /manage.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | """Django's command-line utility for administrative tasks.""" 3 | import os 4 | import sys 5 | 6 | 7 | def main(): 8 | """Run administrative tasks.""" 9 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project.settings") 10 | try: 11 | from django.core.management import execute_from_command_line 12 | except ImportError as exc: 13 | raise ImportError( 14 | "Couldn't import Django. Are you sure it's installed and " 15 | "available on your PYTHONPATH environment variable? Did you " 16 | "forget to activate a virtual environment?" 17 | ) from exc 18 | execute_from_command_line(sys.argv) 19 | 20 | 21 | if __name__ == "__main__": 22 | main() 23 | -------------------------------------------------------------------------------- /froide_govplan/urls.py: -------------------------------------------------------------------------------- 1 | from django.urls import path 2 | from django.utils.translation import pgettext_lazy 3 | 4 | from .views import ( 5 | GovPlanDetailView, 6 | GovPlanProposeUpdateView, 7 | GovPlanSectionDetailView, 8 | search, 9 | ) 10 | 11 | app_name = "govplan" 12 | 13 | urlpatterns = [ 14 | path("search/", search, name="search"), 15 | path( 16 | pgettext_lazy("url part", "
6 | {% with gov=instance.government %}
7 |
20 |
--------------------------------------------------------------------------------
/froide_govplan/auth.py:
--------------------------------------------------------------------------------
1 | from django.db.models import Q
2 |
3 | from .models import GovernmentPlan
4 |
5 |
6 | def has_limited_access(user):
7 | if not user.is_authenticated:
8 | return True
9 | return not user.has_perm("froide_govplan.add_governmentplan")
10 |
11 |
12 | def get_allowed_plans(request):
13 | if not has_limited_access(request.user):
14 | return GovernmentPlan.objects.all()
15 | groups = request.user.groups.all()
16 | return GovernmentPlan.objects.filter(group__in=groups).distinct()
17 |
18 |
19 | def get_visible_plans(request):
20 | if not has_limited_access(request.user):
21 | return GovernmentPlan.objects.all()
22 | if request.user.is_authenticated:
23 | groups = request.user.groups.all()
24 | return GovernmentPlan.objects.filter(
25 | Q(public=True) | Q(group__in=groups)
26 | ).distinct()
27 | return GovernmentPlan.objects.filter(public=True)
28 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/plugins/progress.html:
--------------------------------------------------------------------------------
1 | {% load govplan %}
2 |
3 | {% get_plan_progress object_list as progress %}
4 |
5 |
8 |
9 | {% blocktranslate count days=gov.days_left %}One day left{% plural %}{{ days }} days left{% endblocktranslate %}
10 |
11 |
12 |
13 |
18 | {% endwith %}
19 |
14 |
16 |
17 |
6 | {{ progress.count }} Vorhaben
7 |
16 |
17 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [project]
2 | name = "froide_govplan"
3 | readme = "README.md"
4 | description = ""
5 | license = { file = "LICENSE" }
6 | requires-python = ">=3.10"
7 | classifiers = [
8 | "Development Status :: 5 - Production/Stable",
9 | "Framework :: Django",
10 | "Intended Audience :: Developers",
11 | "License :: OSI Approved :: MIT License",
12 | "Operating System :: OS Independent",
13 | "Programming Language :: Python",
14 | "Programming Language :: Python :: 3.10",
15 | "Programming Language :: Python :: 3.12",
16 | "Topic :: Utilities",
17 | ]
18 | version = "0.0.1"
19 | dependencies = [
20 | "django-cms",
21 | "djangocms-alias",
22 | "django-filer",
23 | "psycopg[binary]",
24 | "django-admin-sortable2",
25 | "nh3",
26 | "django-tinymce",
27 | "django-oauth-toolkit",
28 | "django-mfa3",
29 | ]
30 |
31 | [build-system]
32 | requires = ["setuptools"]
33 | build-backend = "setuptools.build_meta"
34 |
35 | [tool.setuptools.packages.find]
36 | include = ["froide_govplan*"]
37 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/plugins/progress_row.html:
--------------------------------------------------------------------------------
1 | {% load govplan %}
2 |
3 | {% get_plan_progress object_list as progress %}
4 |
5 |
8 |
15 |
9 | {% for section in progress.sections %}
10 |
12 | {% endfor %}
13 |
14 |
6 |
18 |
19 |
--------------------------------------------------------------------------------
/froide_govplan/management/commands/import_govplan.py:
--------------------------------------------------------------------------------
1 | import csv
2 | import json
3 |
4 | from django.core.management.base import BaseCommand
5 |
6 | from ...models import Government
7 | from ...plan_importer import PlanImporter
8 |
9 |
10 | class Command(BaseCommand):
11 | help = "Loads public bodies"
12 |
13 | def add_arguments(self, parser):
14 | parser.add_argument("government", type=str)
15 | parser.add_argument("json_mapping", type=str)
16 | parser.add_argument("filename", type=str)
17 |
18 | def handle(self, *args, **options):
19 | government = Government.objects.get(slug=options["government"])
20 |
21 | with open(options["json_mapping"]) as f:
22 | col_mapping = json.load(f)
23 |
24 | importer = PlanImporter(government, col_mapping=col_mapping)
25 |
26 | filename = options["filename"]
27 | with open(filename) as csv_file:
28 | reader = csv.DictReader(csv_file)
29 | importer.import_rows(reader)
30 |
31 | self.stdout.write("Import done.\n")
32 |
--------------------------------------------------------------------------------
/froide_govplan/utils.py:
--------------------------------------------------------------------------------
1 | from urllib.parse import quote, urlencode
2 |
3 | from django.conf import settings
4 | from django.urls import reverse
5 |
6 | from . import conf
7 |
8 |
9 | def make_request_url(plan, publicbody):
10 | pb_slug = publicbody.slug
11 | url = reverse("foirequest-make_request", kwargs={"publicbody_slug": pb_slug})
12 | subject = "Stand des Regierungsvorhabens „{}“".format(plan.title)
13 | if len(subject) > 250:
14 | subject = subject[:250] + "..."
15 | body = "Dokumente, die den Stand des Regierungsvorhabens zum Thema {} (siehe Koalitionsvertrag), dokumentieren.".format(
16 | plan.title
17 | )
18 | query = {
19 | "subject": subject.encode("utf-8"),
20 | "body": body,
21 | "ref": plan.get_foirequest_reference(),
22 | "tags": conf.GOVPLAN_NAME,
23 | }
24 |
25 | hide_features = ["hide_public", "hide_similar", "hide_draft"]
26 |
27 | query.update({f: b"1" for f in hide_features})
28 | query = urlencode(query, quote_via=quote)
29 | return "%s%s?%s" % (settings.SITE_URL, url, query)
30 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License
2 |
3 | Copyright (c) 2022 FragDenStaat.de / Stefan Wehrmeyer
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/project/urls.py:
--------------------------------------------------------------------------------
1 | """project URL Configuration
2 |
3 | The `urlpatterns` list routes URLs to views. For more information please see:
4 | https://docs.djangoproject.com/en/4.1/topics/http/urls/
5 | Examples:
6 | Function views
7 | 1. Add an import: from my_app import views
8 | 2. Add a URL to urlpatterns: path('', views.home, name='home')
9 | Class-based views
10 | 1. Add an import: from other_app.views import Home
11 | 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
12 | Including another URLconf
13 | 1. Import the include() function: from django.urls import include, path
14 | 2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
15 | """
16 | from django.conf import settings
17 | from django.conf.urls.static import static
18 | from django.contrib import admin
19 | from django.urls import include, path
20 |
21 | urlpatterns = [
22 | path(
23 | "follow/",
24 | include("froide.follow.urls", namespace="follow"),
25 | ),
26 | path("admin/", admin.site.urls),
27 | path("", include("cms.urls")),
28 | ]
29 |
30 | if settings.DEBUG:
31 | urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
32 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0007_auto_20220314_1422.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-03-14 13:22
2 |
3 | from django.db import migrations, models
4 |
5 |
6 | class Migration(migrations.Migration):
7 |
8 | dependencies = [
9 | ("froide_govplan", "0006_sections_cms_plugin"),
10 | ]
11 |
12 | operations = [
13 | migrations.AlterField(
14 | model_name="governmentplanscmsplugin",
15 | name="template",
16 | field=models.CharField(
17 | blank=True,
18 | choices=[
19 | ("froide_govplan/plugins/default.html", "Normal"),
20 | ("froide_govplan/plugins/progress.html", "Progress"),
21 | ("froide_govplan/plugins/card_cols.html", "Card columns"),
22 | ("froide_govplan/plugins/search.html", "Search"),
23 | ],
24 | help_text="template used to display the plugin",
25 | max_length=250,
26 | verbose_name="template",
27 | ),
28 | ),
29 | migrations.AlterField(
30 | model_name="governmentplanupdate",
31 | name="url",
32 | field=models.URLField(blank=True, max_length=1024, verbose_name="URL"),
33 | ),
34 | ]
35 |
--------------------------------------------------------------------------------
/froide_govplan/cms_toolbars.py:
--------------------------------------------------------------------------------
1 | from django.urls import reverse
2 | from django.utils.translation import gettext_lazy as _
3 |
4 | from cms.toolbar_base import CMSToolbar
5 | from cms.toolbar_pool import toolbar_pool
6 |
7 | from . import conf
8 |
9 |
10 | class GovPlanToolbar(CMSToolbar):
11 | def populate(self):
12 | if not self.is_current_app:
13 | return
14 | menu = self.toolbar.get_or_create_menu("govplan-menu", conf.GOVPLAN_NAME)
15 |
16 | url = reverse(
17 | "admin:app_list",
18 | kwargs={"app_label": "froide_govplan"},
19 | current_app="govplanadmin",
20 | )
21 | menu.add_link_item(_("Edit plans and updates"), url=url)
22 |
23 | if hasattr(self.request, "govplan"):
24 | govplan = self.request.govplan
25 | url = reverse(
26 | "admin:froide_govplan_governmentplan_change",
27 | args=(govplan.pk,),
28 | current_app="govplanadmin",
29 | )
30 | menu.add_link_item(_("Edit government plan"), url=url)
31 | url = reverse(
32 | "admin:froide_govplan_governmentplanupdate_add",
33 | current_app="govplanadmin",
34 | )
35 | url = "{}?plan={}".format(url, govplan.id)
36 | menu.add_link_item(_("Add update"), url=url)
37 |
38 |
39 | toolbar_pool.register(GovPlanToolbar)
40 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Froide GovPlan
2 |
3 | A Django app that allows tracking government plans. Deployed at: https://fragdenstaat.de/koalitionstracker/
4 |
5 |
6 | ## Install stand-alone
7 |
8 | Requires [GDAL/Geos for GeoDjango](https://docs.djangoproject.com/en/4.1/ref/contrib/gis/install/geolibs/).
9 |
10 | ```bash
11 | # Start a Postgres server with Postgis
12 | docker compose up -d
13 | # Setup virtualenv
14 | python3 -m venv .venv
15 | source .venv/bin/activate
16 | # Install dependencies
17 | pip install -e git+https://github.com/okfde/froide.git@main#egg=froide
18 | pip install -e .
19 | # Setup initial database
20 | ./manage.py migrate
21 | # Create admin user
22 | ./manage.py createsuperuser
23 | # Start development server
24 | ./manage.py runserver
25 | ```
26 |
27 |
28 | 1. Go to http://localhost:8000/admin/
29 | 2. Setup a homepage in the CMS: http://localhost:8000/admin/cms/page/
30 | 3. Setup a page (could be the homepage) and then choose under advanced setting the Govplan app as application.
31 | 4. Publish that page
32 | 5. Setup a government and plans via the admin.
33 |
34 | ## Possible next steps
35 |
36 | - Use the `project` directory as a blueprint for an app that uses this repo as a depdency.
37 | - Setup [djangocms-text-ckeditor](https://github.com/django-cms/djangocms-text-ckeditor), [djangocms-frontend](https://github.com/django-cms/djangocms-frontend) and other CMS components/
38 | - Use Django apps for social authentication.
39 | - Override templates in your custom project.
40 |
--------------------------------------------------------------------------------
/froide_govplan/templatetags/govplan.py:
--------------------------------------------------------------------------------
1 | from django import template
2 |
3 | from froide_govplan.models import STATUS_CSS, PlanStatus
4 |
5 | register = template.Library()
6 |
7 |
8 | PROGRESS_ORDER = [
9 | PlanStatus.IMPLEMENTED,
10 | PlanStatus.PARTIALLY_IMPLEMENTED,
11 | PlanStatus.STARTED,
12 | PlanStatus.NOT_STARTED,
13 | PlanStatus.DEFERRED,
14 | ]
15 |
16 |
17 | @register.simple_tag
18 | def get_plan_progress(object_list):
19 | sections = []
20 | for value in PROGRESS_ORDER:
21 | label = value.label
22 | value = str(value)
23 | status_count = len([x for x in object_list if x.status == value])
24 | percentage = (
25 | 0 if len(object_list) == 0 else status_count / len(object_list) * 100
26 | )
27 | sections.append(
28 | {
29 | "count": status_count,
30 | "name": str(value),
31 | "label": label,
32 | "css_class": STATUS_CSS[value],
33 | "percentage": round(percentage),
34 | "css_percentage": str(percentage),
35 | }
36 | )
37 |
38 | value, label
39 | return {"count": len(object_list), "sections": sections}
40 |
41 |
42 | @register.inclusion_tag("froide_govplan/plugins/progress.html")
43 | def get_section_progress(section):
44 | return {"object_list": section.get_plans()}
45 |
46 |
47 | @register.filter
48 | def addquotes(text):
49 | return f"„{str.strip(text)}“"
50 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/plugins/search.html:
--------------------------------------------------------------------------------
1 | {% load i18n %}
2 |
19 |
20 |
7 | {{ progress.count }} Vorhaben
8 |
9 |
10 |
17 |
11 | {% for section in progress.sections %}
12 |
14 | {% endfor %}
15 |
16 |
21 |
34 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0006_sections_cms_plugin.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-03-14 12:10
2 |
3 | import django.db.models.deletion
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ("cms", "0022_auto_20180620_1551"),
11 | ("froide_govplan", "0005_governmentplansection"),
12 | ]
13 |
14 | operations = [
15 | migrations.CreateModel(
16 | name="GovernmentPlanSectionsCMSPlugin",
17 | fields=[
18 | (
19 | "cmsplugin_ptr",
20 | models.OneToOneField(
21 | auto_created=True,
22 | on_delete=django.db.models.deletion.CASCADE,
23 | parent_link=True,
24 | primary_key=True,
25 | related_name="froide_govplan_governmentplansectionscmsplugin",
26 | serialize=False,
27 | to="cms.cmsplugin",
28 | ),
29 | ),
30 | (
31 | "government",
32 | models.ForeignKey(
33 | blank=True,
34 | null=True,
35 | on_delete=django.db.models.deletion.SET_NULL,
36 | to="froide_govplan.government",
37 | ),
38 | ),
39 | ],
40 | options={
41 | "abstract": False,
42 | },
43 | bases=("cms.cmsplugin",),
44 | ),
45 | ]
46 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/plugins/sections.html:
--------------------------------------------------------------------------------
1 | {% load thumbnail %}
2 | {% load govplan %}
3 |
12 |
22 |
32 |
33 |
13 | {% for section in sections %}
14 |
35 | {% endfor %}
36 |
37 |
--------------------------------------------------------------------------------
/project/templates/base.html:
--------------------------------------------------------------------------------
1 | {% load i18n %}{% load static %}{% load cms_tags %}{% load sekizai_tags %}
2 |
3 |
4 |
5 |
6 |
7 |
8 | {% trans "Could not find any results. Try different keywords or browse the categories." %}
6 | {% else %} 7 |
8 | {% for object in object_list %}
9 |
33 | {% endfor %}
34 |
35 | {% endif %}
36 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/admin/_proposal.html:
--------------------------------------------------------------------------------
1 | {% load i18n %}
2 | {% load form_helper %}
3 | {% load permission_helper %}
4 |
5 |
6 |
7 |
8 |
77 |
78 |
--------------------------------------------------------------------------------
/froide_govplan/cms_plugins.py:
--------------------------------------------------------------------------------
1 | from django.utils.translation import gettext_lazy as _
2 |
3 | from cms.plugin_base import CMSPluginBase
4 | from cms.plugin_pool import plugin_pool
5 |
6 | from .models import (
7 | PLUGIN_TEMPLATES,
8 | GovernmentPlansCMSPlugin,
9 | GovernmentPlanSection,
10 | GovernmentPlanSectionsCMSPlugin,
11 | GovernmentPlanUpdatesCMSPlugin,
12 | PlanStatus,
13 | )
14 |
15 |
16 | @plugin_pool.register_plugin
17 | class GovernmentPlansPlugin(CMSPluginBase):
18 | name = _("Government plans")
19 | model = GovernmentPlansCMSPlugin
20 | filter_horizontal = ("categories",)
21 | cache = True
22 |
23 | def get_render_template(self, context, instance, placeholder):
24 | return instance.template or PLUGIN_TEMPLATES[0][0]
25 |
26 | def render(self, context, instance, placeholder):
27 | context = super().render(context, instance, placeholder)
28 | context["plugin"] = instance
29 | context["status_list"] = PlanStatus.choices
30 | context["object_list"] = instance.get_plans(
31 | context["request"], published_only=False
32 | )
33 | return context
34 |
35 |
36 | @plugin_pool.register_plugin
37 | class GovernmentPlanSectionsPlugin(CMSPluginBase):
38 | name = _("Government plan sections")
39 | model = GovernmentPlanSectionsCMSPlugin
40 | render_template = "froide_govplan/plugins/sections.html"
41 |
42 | def render(self, context, instance, placeholder):
43 | context = super().render(context, instance, placeholder)
44 |
45 | if instance.government_id:
46 | sections = GovernmentPlanSection.objects.filter(
47 | government_id=instance.government_id
48 | )
49 | else:
50 | sections = GovernmentPlanSection.objects.all()
51 |
52 | sections = sections.select_related("government")
53 |
54 | context["sections"] = sections
55 |
56 | return context
57 |
58 |
59 | @plugin_pool.register_plugin
60 | class GovernmentPlanUpdatesPlugin(CMSPluginBase):
61 | name = _("Government plan updates")
62 | model = GovernmentPlanUpdatesCMSPlugin
63 | render_template = "froide_govplan/plugins/updates.html"
64 |
65 | def render(self, context, instance, placeholder):
66 | context = super().render(context, instance, placeholder)
67 | context["updates"] = instance.get_updates(
68 | context["request"], published_only=False
69 | )
70 | context["show_context"] = True
71 | return context
72 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0009_governmentplanupdatescmsplugin.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-03-17 14:54
2 |
3 | import django.db.models.deletion
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ("cms", "0022_auto_20180620_1551"),
11 | ("publicbody", "0039_publicbody_alternative_emails"),
12 | ("froide_govplan", "0008_governmentplan_proposals"),
13 | ]
14 |
15 | operations = [
16 | migrations.CreateModel(
17 | name="GovernmentPlanUpdatesCMSPlugin",
18 | fields=[
19 | (
20 | "cmsplugin_ptr",
21 | models.OneToOneField(
22 | auto_created=True,
23 | on_delete=django.db.models.deletion.CASCADE,
24 | parent_link=True,
25 | primary_key=True,
26 | related_name="froide_govplan_governmentplanupdatescmsplugin",
27 | serialize=False,
28 | to="cms.cmsplugin",
29 | ),
30 | ),
31 | (
32 | "count",
33 | models.PositiveIntegerField(
34 | default=1,
35 | help_text="0 means all the updates",
36 | verbose_name="number of updates",
37 | ),
38 | ),
39 | (
40 | "offset",
41 | models.PositiveIntegerField(
42 | default=0,
43 | help_text="number of updates to skip from top of list",
44 | verbose_name="offset",
45 | ),
46 | ),
47 | (
48 | "categories",
49 | models.ManyToManyField(
50 | blank=True, to="publicbody.Category", verbose_name="categories"
51 | ),
52 | ),
53 | (
54 | "government",
55 | models.ForeignKey(
56 | blank=True,
57 | null=True,
58 | on_delete=django.db.models.deletion.SET_NULL,
59 | to="froide_govplan.government",
60 | ),
61 | ),
62 | ],
63 | options={
64 | "abstract": False,
65 | },
66 | bases=("cms.cmsplugin",),
67 | ),
68 | ]
69 |
--------------------------------------------------------------------------------
/froide_govplan/api_views.py:
--------------------------------------------------------------------------------
1 | from django_filters import rest_framework as filters
2 | from rest_framework import serializers, viewsets
3 |
4 | from .models import Government, GovernmentPlan, GovernmentPlanUpdate
5 |
6 |
7 | class GovernmentSerializer(serializers.ModelSerializer):
8 | class Meta:
9 | model = Government
10 | fields = ("id", "name", "slug", "start_date", "end_date", "planning_document")
11 |
12 |
13 | class GovernmentPlanSerializer(serializers.ModelSerializer):
14 | site_url = serializers.CharField(source="get_absolute_domain_url")
15 | updates = serializers.SerializerMethodField()
16 |
17 | class Meta:
18 | model = GovernmentPlan
19 | fields = (
20 | "id",
21 | "site_url",
22 | "government",
23 | "title",
24 | "slug",
25 | "description",
26 | "quote",
27 | "due_date",
28 | "measure",
29 | "status",
30 | "rating",
31 | "properties",
32 | "updates",
33 | )
34 |
35 | def get_updates(self, obj):
36 | return GovernmentPlanUpdateSerializer(
37 | obj.updates.all(), read_only=True, many=True, context=self.context
38 | ).data
39 |
40 |
41 | class GovernmentPlanUpdateSerializer(serializers.ModelSerializer):
42 | site_url = serializers.CharField(source="get_absolute_domain_url")
43 |
44 | class Meta:
45 | model = GovernmentPlanUpdate
46 | fields = (
47 | "timestamp",
48 | "title",
49 | "content",
50 | "site_url",
51 | "url",
52 | "status",
53 | "rating",
54 | )
55 |
56 |
57 | class GovernmentPlanFilter(filters.FilterSet):
58 | government = filters.ModelChoiceFilter(
59 | queryset=Government.objects.filter(public=True)
60 | )
61 | properties = filters.CharFilter(method="properties_filter")
62 |
63 | class Meta:
64 | model = GovernmentPlan
65 | fields = (
66 | "government",
67 | "status",
68 | "rating",
69 | "properties",
70 | )
71 |
72 | def properties_filter(self, queryset, name, value):
73 | try:
74 | key, value = value.split(":", 1)
75 | except ValueError:
76 | return queryset.filter(properties__has_key=value)
77 |
78 | return queryset.filter(**{"properties__%s__contains" % key: value})
79 |
80 |
81 | class GovernmentPlanViewSet(viewsets.ReadOnlyModelViewSet):
82 | serializer_class = GovernmentPlanSerializer
83 | filterset_class = GovernmentPlanFilter
84 |
85 | def get_queryset(self):
86 | return (
87 | GovernmentPlan.objects.filter(public=True)
88 | .select_related("government")
89 | .prefetch_related("updates")
90 | )
91 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/section.html:
--------------------------------------------------------------------------------
1 | {% extends "froide_govplan/base.html" %}
2 | {% load i18n %}
3 | {% load markup %}
4 | {% load cms_tags %}
5 | {% load follow_tags %}
6 | {% load thumbnail %}
7 | {% block title %}
8 | {{ object.title }}
9 | {% endblock title %}
10 | {% block meta %}
11 | {% include "snippets/meta.html" %}
12 | {% endblock meta %}
13 | {% block app_body %}
14 | | {% trans "Field" %} | 10 | {% for key, proposal in proposals.items %} 11 |12 | 13 | {% if request.user.is_staff and request.user|has_perm:"account.view_user" %} 14 | {{ proposal.user.get_full_name }} ({{ proposal.user.email }}) 15 | {% else %} 16 | {{ proposal.timestamp | date:"SHORT_DATETIME" }} 17 | {% endif %} 18 | 19 | | 20 | {% endfor %} 21 |
|---|---|
| 27 | {% trans "Proposal" %} 28 | | 29 | {% for key, proposal in proposals.items %} 30 |31 | 35 | | 36 | {% endfor %} 37 |
| {{ field.label }} | 42 | {% for key, proposal in proposals.items %} 43 | {% with val=proposal.data|get_item_by_key:field.name %} 44 |45 | {% with label_name=field.name|add:"_label" %} 46 | {% if proposal.data|get_item_by_key:label_name %} 47 | {{ proposal.data|get_item_by_key:label_name }} 48 | {% else %} 49 | {{ val|urlize|linebreaksbr }} 50 | {% endif %} 51 | {% endwith %} 52 | | 53 | {% endwith %} 54 | {% endfor %} 55 |
| 62 | {% trans "Delete proposal" %} 63 | | 64 | {% for key, proposal in proposals.items %} 65 |66 | 70 | | 71 | {% endfor %} 72 |
15 |
49 | {% endblock app_body %}
50 |
--------------------------------------------------------------------------------
/froide_govplan/configuration.py:
--------------------------------------------------------------------------------
1 | from datetime import datetime
2 | from typing import Iterator
3 |
4 | from django.utils.translation import gettext_lazy as _
5 | from froide.follow.configuration import FollowConfiguration
6 | from froide.helper.notifications import Notification, TemplatedEvent
7 |
8 | from .admin import has_limited_access
9 | from .models import GovernmentPlan, GovernmentPlanFollower, GovernmentPlanUpdate
10 |
11 |
12 | class GovernmentPlanFollowConfiguration(FollowConfiguration):
13 | model = GovernmentPlanFollower
14 | title: str = _("Government plans")
15 | slug: str = "govplan"
16 | follow_message: str = _("You are now following this plan.")
17 | unfollow_message: str = _("You are not following this plan anymore.")
18 | confirm_email_message: str = _(
19 | "Check your emails and click the confirmation link in order to follow this government plan."
20 | )
21 | action_labels = {
22 | "follow": _("Follow plan"),
23 | "follow_q": _("Follow plan?"),
24 | "unfollow": _("Unfollow plan"),
25 | "following": _("Following plan"),
26 | "follow_description": _(
27 | "You will get notifications via email when something new happens with this plan. You can unsubscribe anytime."
28 | ),
29 | }
30 |
31 | def get_content_object_queryset(self, request):
32 | if has_limited_access(request.user):
33 | return GovernmentPlan.objects.filter(public=True)
34 | return GovernmentPlan.objects.all()
35 |
36 | def can_follow(self, content_object, user, request=None):
37 | return (
38 | content_object.government.active
39 | and content_object.public
40 | or not has_limited_access(user)
41 | )
42 |
43 | def get_batch_updates(
44 | self, start: datetime, end: datetime
45 | ) -> Iterator[Notification]:
46 | yield from get_plan_updates(start, end)
47 |
48 | def get_confirm_follow_message(self, content_object):
49 | return _(
50 | "please confirm that you want to follow the plan “{title}” by clicking this link:"
51 | ).format(title=content_object.title)
52 |
53 | def email_changed(self, user):
54 | # Move all confirmed email subscriptions of new email
55 | # to user except own requests
56 | self.model.objects.filter(email=user.email, confirmed=True).update(
57 | email="", user=user
58 | )
59 |
60 |
61 | def get_plan_updates(start: datetime, end: datetime):
62 | plan_updates = GovernmentPlanUpdate.objects.filter(
63 | public=True, timestamp__gte=start, timestamp__lt=end
64 | ).select_related("plan")
65 |
66 | for plan_update in plan_updates:
67 | yield Notification(
68 | section=_("Government Plans"),
69 | event_type="planupdate",
70 | object=plan_update.plan,
71 | object_label=plan_update.plan.title,
72 | timestamp=plan_update.timestamp,
73 | event=make_plan_event(plan_update.plan),
74 | user_id=None,
75 | )
76 |
77 |
78 | def make_plan_event(plan):
79 | return TemplatedEvent(
80 | _("An update was posted for the government plan “{title}”."),
81 | title=plan.title,
82 | )
83 |
--------------------------------------------------------------------------------
/froide_govplan/templates/froide_govplan/plugins/updates.html:
--------------------------------------------------------------------------------
1 | {% load markup %}
2 | {% for update in updates %}
3 | {% if wrapper_classes %}
16 |
47 | {% include "froide_govplan/plugins/card_cols.html" with object_list=plans %}
48 |
17 |
46 |
18 |
45 |
19 |
33 |
20 | {% if not government.active %}
21 |
32 |
22 | Dieser Themenbereich gehörte zur {{ government.name }} und wird nicht mehr aktualisiert.
23 |
24 | {% endif %}
25 | {{ object.title }}
26 |27 | {% blocktranslate with section=object.title %} 28 | Here you can find all plans of the section “{{ section }}”, which the coalition constituted in their agreement. On the curresponding detail pages, you'll get more information, stay up to date with news or submit changes. 29 | {% endblocktranslate %} 30 |
31 |
34 | {% include "froide_govplan/plugins/progress_row.html" with object_list=plans %}
35 |
44 | 36 | nicht begonnen 37 | begonnen 38 | teilweise umgesetzt 39 | umgesetzt 40 | verschoben 41 |
42 | {% include "froide_govplan/plugins/time_used.html" with instance=object %} 43 |{% endif %}
4 |
{% endif %}
62 | {% endfor %}
63 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0002_auto_20220215_2113.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.8 on 2022-02-15 20:13
2 |
3 | import django.db.models.deletion
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ("publicbody", "0039_publicbody_alternative_emails"),
11 | ("organization", "0001_initial"),
12 | ("cms", "0022_auto_20180620_1551"),
13 | ("froide_govplan", "0001_initial"),
14 | ]
15 |
16 | operations = [
17 | migrations.AddField(
18 | model_name="governmentplan",
19 | name="organization",
20 | field=models.ForeignKey(
21 | blank=True,
22 | null=True,
23 | on_delete=django.db.models.deletion.SET_NULL,
24 | to="organization.organization",
25 | ),
26 | ),
27 | migrations.AddField(
28 | model_name="governmentplanupdate",
29 | name="url",
30 | field=models.URLField(blank=True),
31 | ),
32 | migrations.CreateModel(
33 | name="GovernmentPlansCMSPlugin",
34 | fields=[
35 | (
36 | "cmsplugin_ptr",
37 | models.OneToOneField(
38 | auto_created=True,
39 | on_delete=django.db.models.deletion.CASCADE,
40 | parent_link=True,
41 | primary_key=True,
42 | related_name="froide_govplan_governmentplanscmsplugin",
43 | serialize=False,
44 | to="cms.cmsplugin",
45 | ),
46 | ),
47 | (
48 | "count",
49 | models.PositiveIntegerField(
50 | default=1,
51 | help_text="0 means all the plans",
52 | verbose_name="number of plans",
53 | ),
54 | ),
55 | (
56 | "offset",
57 | models.PositiveIntegerField(
58 | default=0,
59 | help_text="number of plans to skip from top of list",
60 | verbose_name="offset",
61 | ),
62 | ),
63 | (
64 | "template",
65 | models.CharField(
66 | blank=True,
67 | choices=[("froide_govplan/plugins/default.html", "Normal")],
68 | help_text="template used to display the plugin",
69 | max_length=250,
70 | verbose_name="template",
71 | ),
72 | ),
73 | (
74 | "categories",
75 | models.ManyToManyField(
76 | blank=True, to="publicbody.Category", verbose_name="categories"
77 | ),
78 | ),
79 | (
80 | "government",
81 | models.ForeignKey(
82 | blank=True,
83 | null=True,
84 | on_delete=django.db.models.deletion.SET_NULL,
85 | to="froide_govplan.government",
86 | ),
87 | ),
88 | ],
89 | options={
90 | "abstract": False,
91 | },
92 | bases=("cms.cmsplugin",),
93 | ),
94 | ]
95 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0005_governmentplansection.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-03-14 10:14
2 |
3 | import django.db.models.deletion
4 | from django.conf import settings
5 | from django.db import migrations, models
6 |
7 | import cms.models.fields
8 | import filer.fields.image
9 |
10 |
11 | class Migration(migrations.Migration):
12 |
13 | dependencies = [
14 | ("publicbody", "0039_publicbody_alternative_emails"),
15 | migrations.swappable_dependency(settings.FILER_IMAGE_MODEL),
16 | ("cms", "0022_auto_20180620_1551"),
17 | ("froide_govplan", "0004_auto_20220311_2330"),
18 | ]
19 |
20 | operations = [
21 | migrations.CreateModel(
22 | name="GovernmentPlanSection",
23 | fields=[
24 | (
25 | "id",
26 | models.AutoField(
27 | auto_created=True,
28 | primary_key=True,
29 | serialize=False,
30 | verbose_name="ID",
31 | ),
32 | ),
33 | ("title", models.CharField(max_length=255, verbose_name="title")),
34 | (
35 | "slug",
36 | models.SlugField(max_length=255, unique=True, verbose_name="slug"),
37 | ),
38 | (
39 | "description",
40 | models.TextField(blank=True, verbose_name="description"),
41 | ),
42 | (
43 | "icon",
44 | models.CharField(
45 | blank=True,
46 | help_text='Enter an icon name from the FontAwesome 4 icon set',
47 | max_length=50,
48 | verbose_name="Icon",
49 | ),
50 | ),
51 | ("order", models.PositiveIntegerField(default=0)),
52 | ("featured", models.DateTimeField(blank=True, null=True)),
53 | (
54 | "categories",
55 | models.ManyToManyField(blank=True, to="publicbody.Category"),
56 | ),
57 | (
58 | "content_placeholder",
59 | cms.models.fields.PlaceholderField(
60 | editable=False,
61 | null=True,
62 | on_delete=django.db.models.deletion.CASCADE,
63 | slotname="content",
64 | to="cms.placeholder",
65 | ),
66 | ),
67 | (
68 | "government",
69 | models.ForeignKey(
70 | on_delete=django.db.models.deletion.CASCADE,
71 | to="froide_govplan.government",
72 | verbose_name="government",
73 | ),
74 | ),
75 | (
76 | "image",
77 | filer.fields.image.FilerImageField(
78 | blank=True,
79 | default=None,
80 | null=True,
81 | on_delete=django.db.models.deletion.SET_NULL,
82 | to=settings.FILER_IMAGE_MODEL,
83 | verbose_name="image",
84 | ),
85 | ),
86 | ],
87 | options={
88 | "verbose_name": "Government plan section",
89 | "verbose_name_plural": "Government plan sections",
90 | "ordering": ("order", "title"),
91 | },
92 | ),
93 | ]
94 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0012_government_georegion_alter_government_jurisdiction_and_more.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 4.1.4 on 2023-02-03 10:00
2 |
3 | import django.db.models.deletion
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ("cms", "0022_auto_20180620_1551"),
11 | ("publicbody", "0043_merge_20221019_1020"),
12 | ("georegion", "0011_georegion_invalid_on"),
13 | ("froide_govplan", "0011_governmentplan_properties"),
14 | ]
15 |
16 | operations = [
17 | migrations.AddField(
18 | model_name="government",
19 | name="georegion",
20 | field=models.ForeignKey(
21 | blank=True,
22 | null=True,
23 | on_delete=django.db.models.deletion.SET_NULL,
24 | to="georegion.georegion",
25 | verbose_name="georegion",
26 | ),
27 | ),
28 | migrations.AlterField(
29 | model_name="government",
30 | name="jurisdiction",
31 | field=models.ForeignKey(
32 | blank=True,
33 | null=True,
34 | on_delete=django.db.models.deletion.SET_NULL,
35 | to="publicbody.jurisdiction",
36 | verbose_name="jurisdiction",
37 | ),
38 | ),
39 | migrations.AlterField(
40 | model_name="governmentplanscmsplugin",
41 | name="cmsplugin_ptr",
42 | field=models.OneToOneField(
43 | auto_created=True,
44 | on_delete=django.db.models.deletion.CASCADE,
45 | parent_link=True,
46 | primary_key=True,
47 | related_name="%(app_label)s_%(class)s",
48 | serialize=False,
49 | to="cms.cmsplugin",
50 | ),
51 | ),
52 | migrations.AlterField(
53 | model_name="governmentplanscmsplugin",
54 | name="template",
55 | field=models.CharField(
56 | blank=True,
57 | choices=[
58 | ("froide_govplan/plugins/default.html", "Normal"),
59 | ("froide_govplan/plugins/progress.html", "Progress"),
60 | ("froide_govplan/plugins/progress_row.html", "Progress Row"),
61 | ("froide_govplan/plugins/time_used.html", "Time used"),
62 | ("froide_govplan/plugins/card_cols.html", "Card columns"),
63 | ("froide_govplan/plugins/search.html", "Search"),
64 | ],
65 | help_text="template used to display the plugin",
66 | max_length=250,
67 | verbose_name="template",
68 | ),
69 | ),
70 | migrations.AlterField(
71 | model_name="governmentplansectionscmsplugin",
72 | name="cmsplugin_ptr",
73 | field=models.OneToOneField(
74 | auto_created=True,
75 | on_delete=django.db.models.deletion.CASCADE,
76 | parent_link=True,
77 | primary_key=True,
78 | related_name="%(app_label)s_%(class)s",
79 | serialize=False,
80 | to="cms.cmsplugin",
81 | ),
82 | ),
83 | migrations.AlterField(
84 | model_name="governmentplanupdatescmsplugin",
85 | name="cmsplugin_ptr",
86 | field=models.OneToOneField(
87 | auto_created=True,
88 | on_delete=django.db.models.deletion.CASCADE,
89 | parent_link=True,
90 | primary_key=True,
91 | related_name="%(app_label)s_%(class)s",
92 | serialize=False,
93 | to="cms.cmsplugin",
94 | ),
95 | ),
96 | ]
97 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0004_auto_20220311_2330.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-03-11 22:30
2 |
3 | import django.db.models.deletion
4 | import django.utils.timezone
5 | from django.conf import settings
6 | from django.db import migrations, models
7 |
8 |
9 | class Migration(migrations.Migration):
10 |
11 | dependencies = [
12 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
13 | ("froide_govplan", "0003_auto_20220228_1051"),
14 | ]
15 |
16 | operations = [
17 | migrations.AlterField(
18 | model_name="governmentplanscmsplugin",
19 | name="template",
20 | field=models.CharField(
21 | blank=True,
22 | choices=[
23 | ("froide_govplan/plugins/default.html", "Normal"),
24 | ("froide_govplan/plugins/progress.html", "Progress"),
25 | ("froide_govplan/plugins/card_cols.html", "Card columns"),
26 | ],
27 | help_text="template used to display the plugin",
28 | max_length=250,
29 | verbose_name="template",
30 | ),
31 | ),
32 | migrations.CreateModel(
33 | name="GovernmentPlanFollower",
34 | fields=[
35 | (
36 | "id",
37 | models.AutoField(
38 | auto_created=True,
39 | primary_key=True,
40 | serialize=False,
41 | verbose_name="ID",
42 | ),
43 | ),
44 | ("email", models.CharField(blank=True, max_length=255)),
45 | ("confirmed", models.BooleanField(default=False)),
46 | (
47 | "timestamp",
48 | models.DateTimeField(
49 | default=django.utils.timezone.now,
50 | verbose_name="Timestamp of Following",
51 | ),
52 | ),
53 | ("context", models.JSONField(blank=True, null=True)),
54 | (
55 | "content_object",
56 | models.ForeignKey(
57 | on_delete=django.db.models.deletion.CASCADE,
58 | related_name="followers",
59 | to="froide_govplan.governmentplan",
60 | verbose_name="Government plan",
61 | ),
62 | ),
63 | (
64 | "user",
65 | models.ForeignKey(
66 | blank=True,
67 | null=True,
68 | on_delete=django.db.models.deletion.CASCADE,
69 | to=settings.AUTH_USER_MODEL,
70 | verbose_name="User",
71 | ),
72 | ),
73 | ],
74 | options={
75 | "verbose_name": "Government plan follower",
76 | "verbose_name_plural": "Government plan followers",
77 | "ordering": ("-timestamp",),
78 | "get_latest_by": "timestamp",
79 | "abstract": False,
80 | },
81 | ),
82 | migrations.AddConstraint(
83 | model_name="governmentplanfollower",
84 | constraint=models.UniqueConstraint(
85 | condition=models.Q(("user__isnull", False)),
86 | fields=("content_object", "user"),
87 | name="unique_user_follower_froide_govplan_governmentplanfollower",
88 | ),
89 | ),
90 | migrations.AddConstraint(
91 | model_name="governmentplanfollower",
92 | constraint=models.UniqueConstraint(
93 | condition=models.Q(("user__isnull", True)),
94 | fields=("content_object", "email"),
95 | name="unique_email_follower_froide_govplan_governmentplanfollower",
96 | ),
97 | ),
98 | ]
99 |
--------------------------------------------------------------------------------
/froide_govplan/plan_importer.py:
--------------------------------------------------------------------------------
1 | import datetime
2 | import re
3 |
4 | from django.template.defaultfilters import slugify
5 |
6 | from froide.publicbody.models import Category, PublicBody
7 |
8 | from .models import GovernmentPlan, GovernmentPlanSection
9 |
10 |
11 | class PlanImporter(object):
12 | def __init__(self, government, col_mapping=None):
13 | if col_mapping is None:
14 | col_mapping = {}
15 | self.col_mapping = col_mapping
16 | self.government = government
17 | self.post_save_list = []
18 |
19 | def import_rows(self, reader):
20 | for row in reader:
21 | self.import_row(row)
22 |
23 | def import_row(self, row):
24 | print("importing", row)
25 | title = row[self.col_mapping["title"]]
26 | if not title:
27 | return
28 | plan = GovernmentPlan.objects.filter(
29 | government=self.government, title=title
30 | ).first()
31 |
32 | if not plan:
33 | plan = GovernmentPlan(government=self.government)
34 |
35 | self.post_save_list = []
36 | for col, row_col in self.col_mapping.items():
37 | method_name = "handle_{}".format(col)
38 | if hasattr(self, method_name):
39 | getattr(self, method_name)(plan, row[row_col])
40 | else:
41 | setattr(plan, col, row[row_col])
42 | plan.save()
43 | for func in self.post_save_list:
44 | func(plan)
45 |
46 | def handle_title(self, plan, title):
47 | plan.title = title
48 | plan.slug = slugify(title)
49 |
50 | def handle_categories(self, plan, category_name):
51 | categories = [
52 | x.strip() for x in re.split(r", | & | und ", category_name) if x.strip()
53 | ]
54 | self.make_section(category_name, "-".join(categories), categories)
55 | if categories:
56 | self.post_save_list.append(lambda p: p.categories.set(*categories))
57 |
58 | def make_section(self, section_name, section_slug, categories):
59 | slug = slugify(section_slug)
60 | section, _created = GovernmentPlanSection.objects.get_or_create(
61 | slug=slug,
62 | defaults={
63 | "government": self.government,
64 | "title": section_name,
65 | },
66 | )
67 | section.categories.set([self.get_category(c) for c in categories])
68 |
69 | def get_category(self, cat_name):
70 | return Category.objects.get(name=cat_name)
71 |
72 | def handle_reference(self, plan, reference):
73 | plan.reference = ", ".join(re.split(r"\s*[,/]\s*", reference))
74 |
75 | def handle_responsible_publicbody(self, plan, pb):
76 | if not pb.strip():
77 | return
78 | pb = PublicBody.objects.get(
79 | jurisdiction=self.government.jurisdiction,
80 | other_names__iregex=r"(\W|^){}(\W|$)".format(pb),
81 | )
82 | plan.responsible_publicbody = pb
83 |
84 | def handle_due_date(self, plan, date_descr):
85 | if not date_descr.strip():
86 | return
87 |
88 | def parse_date(date_descr):
89 | match = re.search(r"(\d{4})", date_descr)
90 | if not match:
91 | return
92 | year = int(match.group(1))
93 | if "Mitte" in date_descr:
94 | return datetime.date(year, 7, 1)
95 | if "Ende" in date_descr:
96 | return datetime.date(year, 12, 1)
97 | if "Anfang" in date_descr:
98 | return datetime.date(year, 3, 1)
99 | if "Innerhalb" in date_descr:
100 | return datetime.date(year, 12, 31)
101 | if "Juni" in date_descr:
102 | return datetime.date(year, 6, 1)
103 | return datetime.date(year, 1, 1)
104 |
105 | plan.due_date = parse_date(date_descr)
106 |
107 | def handle_status(self, plan, status):
108 | status = status.strip()
109 | if not status or status == "noch nicht umgesetzt":
110 | status = "not_started"
111 | if status == "umgesetzt":
112 | status = "implemented"
113 | if status == "begonnen":
114 | status = "started"
115 | plan.status = status
116 |
--------------------------------------------------------------------------------
/froide_govplan/views.py:
--------------------------------------------------------------------------------
1 | from django.contrib import messages
2 | from django.contrib.auth.mixins import LoginRequiredMixin
3 | from django.shortcuts import get_object_or_404, redirect, render
4 | from django.utils.translation import gettext_lazy as _
5 | from django.views.generic import DetailView, UpdateView
6 | from froide.helper.breadcrumbs import BreadcrumbView
7 |
8 | from .auth import get_visible_plans
9 | from .forms import GovernmentPlanUpdateProposalForm
10 | from .models import Government, GovernmentPlan, GovernmentPlanSection
11 |
12 |
13 | class GovernmentMixin(BreadcrumbView):
14 | def dispatch(self, *args, **kwargs):
15 | self.get_government()
16 | return super().dispatch(*args, **kwargs)
17 |
18 | def get_government(self):
19 | filter_kwarg = {}
20 | if not self.request.user.is_authenticated or not self.request.user.is_staff:
21 | filter_kwarg["public"] = True
22 | self.government = get_object_or_404(
23 | Government, slug=self.kwargs["gov"], **filter_kwarg
24 | )
25 |
26 | def get_context_data(self, **kwargs):
27 | context = super().get_context_data(**kwargs)
28 | context["government"] = self.government
29 | return context
30 |
31 | def get_breadcrumbs(self, context):
32 | breadcrumbs = []
33 | if "request" in context:
34 | request = context["request"]
35 |
36 | title = request.current_page.get_title()
37 | url = request.current_page.get_absolute_url()
38 | breadcrumbs.append((title, url))
39 |
40 | breadcrumbs.append((self.government.name, self.government.get_absolute_url()))
41 | return breadcrumbs
42 |
43 |
44 | class GovPlanSectionDetailView(GovernmentMixin, DetailView):
45 | slug_url_kwarg = "section"
46 | template_name = "froide_govplan/section.html"
47 |
48 | def get_queryset(self):
49 | return GovernmentPlanSection.objects.filter(
50 | government=self.government
51 | ).select_related("government")
52 |
53 | def get_context_data(self, **kwargs):
54 | context = super().get_context_data(**kwargs)
55 | queryset = get_visible_plans(self.request)
56 | context["plans"] = context["object"].get_plans(queryset=queryset)
57 | return context
58 |
59 | def get_breadcrumbs(self, context):
60 | return super().get_breadcrumbs(context) + [
61 | (self.object.title, self.object.get_absolute_url())
62 | ]
63 |
64 |
65 | class GovPlanDetailView(GovernmentMixin, DetailView):
66 | slug_url_kwarg = "plan"
67 | template_name = "froide_govplan/detail.html"
68 |
69 | def get_queryset(self):
70 | qs = GovernmentPlan.objects.filter(government=self.government)
71 | if self.request.user.is_authenticated and self.request.user.is_staff:
72 | return qs
73 | return qs.filter(public=True).select_related(
74 | "responsible_publicbody", "organization"
75 | )
76 |
77 | def get_context_data(self, **kwargs):
78 | context = super().get_context_data(**kwargs)
79 | context["updates"] = self.object.updates.filter(public=True).order_by(
80 | "-timestamp"
81 | )
82 | context["section"] = self.object.get_section()
83 | if self.request.user.is_authenticated:
84 | context["update_proposal_form"] = GovernmentPlanUpdateProposalForm()
85 | # For CMS toolbar
86 | self.request.govplan = self.object
87 | return context
88 |
89 | def get_breadcrumbs(self, context):
90 | obj = context["object"]
91 | section = context["section"]
92 |
93 | breadcrumbs = super().get_breadcrumbs(context)
94 |
95 | if section:
96 | breadcrumbs.append((section.title, section.get_absolute_url()))
97 |
98 | return breadcrumbs + [
99 | (obj.title, obj.get_absolute_url()),
100 | ]
101 |
102 |
103 | class GovPlanProposeUpdateView(GovernmentMixin, LoginRequiredMixin, UpdateView):
104 | slug_url_kwarg = "plan"
105 | form_class = GovernmentPlanUpdateProposalForm
106 |
107 | def get(self, request, *args, **kwargs):
108 | self.object = self.get_object()
109 | return redirect(self.object)
110 |
111 | def get_queryset(self):
112 | qs = GovernmentPlan.objects.filter(
113 | government=self.government, government__active=True
114 | )
115 | if self.request.user.is_authenticated and self.request.user.is_staff:
116 | return qs
117 | return qs.filter(public=True)
118 |
119 | def get_success_url(self):
120 | return self.object.get_absolute_url()
121 |
122 | def form_valid(self, form):
123 | form.save(self.object, self.request.user)
124 | messages.add_message(
125 | self.request,
126 | messages.INFO,
127 | _(
128 | "Thank you for your proposal. We will send you an email when it has been approved."
129 | ),
130 | )
131 | return redirect(self.object)
132 |
133 | def form_invalid(self, form):
134 | messages.add_message(
135 | self.request,
136 | messages.ERROR,
137 | _("There's been an error with your form submission."),
138 | )
139 | return redirect(self.object)
140 |
141 |
142 | def search(request):
143 | q = request.GET.get("q", "")
144 | plans = GovernmentPlan.objects.filter(public=True)
145 | if q:
146 | plans = GovernmentPlan.objects.search(q, qs=plans)
147 |
148 | if request.GET.get("government"):
149 | try:
150 | gov_id = int(request.GET["government"])
151 | plans = plans.filter(government_id=gov_id)
152 | except ValueError:
153 | pass
154 | if request.GET.get("status"):
155 | try:
156 | status = request.GET["status"]
157 | plans = plans.filter(status=status)
158 | except ValueError:
159 | pass
160 |
161 | if q:
162 | # limit when there's a search
163 | plans = plans[:20]
164 | return render(
165 | request, "froide_govplan/plugins/card_cols.html", {"object_list": plans}
166 | )
167 |
--------------------------------------------------------------------------------
/project/settings.py:
--------------------------------------------------------------------------------
1 | """
2 | Django settings for project project.
3 |
4 | Generated by 'django-admin startproject' using Django 4.1.6.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/4.1/topics/settings/
8 |
9 | For the full list of settings and their values, see
10 | https://docs.djangoproject.com/en/4.1/ref/settings/
11 | """
12 |
13 | import os
14 | from pathlib import Path
15 |
16 | from django.utils.translation import gettext_lazy as _
17 |
18 | # Build paths inside the project like this: BASE_DIR / 'subdir'.
19 | BASE_DIR = Path(__file__).resolve().parent.parent
20 | PROJECT_DIR = Path(__file__).resolve().parent
21 |
22 | # Quick-start development settings - unsuitable for production
23 | # See https://docs.djangoproject.com/en/4.1/howto/deployment/checklist/
24 |
25 | # SECURITY WARNING: keep the secret key used in production secret!
26 | SECRET_KEY = "django-insecure-8qh(ha_fw#3mc#y+rtd^se+e$-+n5%1o*d3%3p0d379q1zxypu"
27 |
28 | # SECURITY WARNING: don't run with debug turned on in production!
29 | DEBUG = True
30 |
31 | ALLOWED_HOSTS = []
32 |
33 |
34 | # Application definition
35 |
36 | INSTALLED_APPS = [
37 | # "djangocms_admin_style",
38 | "django.contrib.admin",
39 | "django.contrib.auth",
40 | "django.contrib.sites",
41 | "django.contrib.contenttypes",
42 | "django.contrib.sessions",
43 | "django.contrib.messages",
44 | "django.contrib.staticfiles",
45 | "django.contrib.humanize",
46 | "django.contrib.gis",
47 | # Froide apps
48 | "froide_govplan.apps.FroideGovPlanConfig",
49 | "froide.georegion",
50 | "froide.publicbody",
51 | "froide.follow",
52 | "froide.organization",
53 | "froide.team",
54 | "froide.helper",
55 | # Third party apps
56 | "easy_thumbnails",
57 | "filer",
58 | "sekizai",
59 | "cms",
60 | "djangocms_alias",
61 | "menus",
62 | "treebeard",
63 | "taggit",
64 | "tinymce",
65 | ]
66 |
67 | MIDDLEWARE = [
68 | "django.middleware.security.SecurityMiddleware",
69 | "django.middleware.locale.LocaleMiddleware", # needs to be before CommonMiddleware
70 | "django.contrib.sessions.middleware.SessionMiddleware",
71 | "django.middleware.common.CommonMiddleware",
72 | "django.middleware.csrf.CsrfViewMiddleware",
73 | "django.contrib.auth.middleware.AuthenticationMiddleware",
74 | "django.contrib.messages.middleware.MessageMiddleware",
75 | "django.middleware.clickjacking.XFrameOptionsMiddleware",
76 | "cms.middleware.user.CurrentUserMiddleware",
77 | "cms.middleware.page.CurrentPageMiddleware",
78 | "cms.middleware.toolbar.ToolbarMiddleware",
79 | "cms.middleware.language.LanguageCookieMiddleware",
80 | ]
81 |
82 | ROOT_URLCONF = "project.urls"
83 |
84 | TEMPLATES = [
85 | {
86 | "BACKEND": "django.template.backends.django.DjangoTemplates",
87 | "DIRS": [
88 | PROJECT_DIR / "templates",
89 | ],
90 | "APP_DIRS": True,
91 | "OPTIONS": {
92 | "context_processors": [
93 | "django.template.context_processors.debug",
94 | "django.template.context_processors.request",
95 | "django.contrib.auth.context_processors.auth",
96 | "django.contrib.messages.context_processors.messages",
97 | "sekizai.context_processors.sekizai",
98 | "cms.context_processors.cms_settings",
99 | "froide.helper.context_processors.site_settings",
100 | ],
101 | },
102 | },
103 | ]
104 |
105 | WSGI_APPLICATION = "project.wsgi.application"
106 |
107 |
108 | # Database
109 | # https://docs.djangoproject.com/en/4.1/ref/settings/#databases
110 |
111 | DATABASES = {
112 | "default": {
113 | "ENGINE": "django.contrib.gis.db.backends.postgis", # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
114 | # "NAME": "fragdenstaat_de",
115 | "NAME": "govplan",
116 | "USER": "govplan",
117 | "PASSWORD": "govplan",
118 | "HOST": "localhost", # Set to empty string for localhost. Not used with sqlite3.
119 | "PORT": "5432", # Set to empty string for default. Not used with sqlite3.
120 | }
121 | }
122 | GDAL_LIBRARY_PATH = os.environ.get("GDAL_LIBRARY_PATH")
123 | GEOS_LIBRARY_PATH = os.environ.get("GEOS_LIBRARY_PATH")
124 |
125 |
126 | # Password validation
127 | # https://docs.djangoproject.com/en/4.1/ref/settings/#auth-password-validators
128 |
129 | AUTH_PASSWORD_VALIDATORS = [
130 | {
131 | "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
132 | },
133 | {
134 | "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
135 | },
136 | {
137 | "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
138 | },
139 | {
140 | "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
141 | },
142 | ]
143 |
144 |
145 | # Internationalization
146 | # https://docs.djangoproject.com/en/4.1/topics/i18n/
147 |
148 | LANGUAGE_CODE = "de"
149 | LANGUAGES = [("de", _("German"))]
150 |
151 |
152 | TIME_ZONE = "UTC"
153 |
154 | USE_I18N = True
155 |
156 | USE_TZ = True
157 |
158 |
159 | # Static files (CSS, JavaScript, Images)
160 | # https://docs.djangoproject.com/en/4.1/howto/static-files/
161 |
162 | STATIC_URL = "static/"
163 |
164 | # Default primary key field type
165 | # https://docs.djangoproject.com/en/4.1/ref/settings/#default-auto-field
166 |
167 | DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
168 | # AUTH_USER_MODEL = "account.User"
169 |
170 | TAGGIT_CASE_INSENSITIVE = True
171 | TAGGIT_STRIP_UNICODE_WHEN_SLUGIFYING = True
172 |
173 | LOGIN_URL = "admin:login"
174 | X_FRAME_OPTIONS = "SAMEORIGIN"
175 |
176 | # Django CMS
177 |
178 | CMS_TEMPLATES = [
179 | ("froide_govplan/base.html", "Govplan base template"),
180 | ]
181 |
182 | # Froide
183 |
184 | SITE_ID = 1
185 | SITE_NAME = "GovPlan"
186 | SITE_URL = "http://localhost:8000"
187 | SITE_EMAIL = "info@example.com"
188 | SITE_LOGO = ""
189 |
190 | FROIDE_CONFIG = {
191 | "bounce_enabled": False,
192 | "bounce_format": "bounce+{token}@example.com",
193 | "bounce_max_age": 60 * 60 * 24 * 14, # 14 days
194 | "unsubscribe_enabled": False,
195 | "unsubscribe_format": "unsub+{token}@example.com",
196 | }
197 |
198 | ELASTICSEARCH_INDEX_PREFIX = "govplan"
199 | CMS_CONFIRM_VERSION4 = True
200 |
201 | # Govplan settings
202 |
203 | GOVPLAN_NAME = "GovPlan"
204 | GOVPLAN_ENABLE_FOIREQUEST = False
205 |
--------------------------------------------------------------------------------
/froide_govplan/forms.py:
--------------------------------------------------------------------------------
1 | import copy
2 |
3 | import nh3
4 | from django import forms
5 | from django.conf import settings
6 | from django.contrib.auth import get_user_model
7 | from django.utils import timezone
8 | from django.utils.safestring import mark_safe
9 | from django.utils.translation import gettext_lazy as _
10 | from froide.helper.widgets import BootstrapSelect
11 | from tinymce.widgets import TinyMCE
12 |
13 | from .models import GovernmentPlan, GovernmentPlanUpdate, PlanRating, PlanStatus
14 |
15 | ALLOWED_TAGS = {
16 | "a",
17 | "strong",
18 | "b",
19 | "i",
20 | "em",
21 | "ul",
22 | "ol",
23 | "li",
24 | "p",
25 | "h3",
26 | "h4",
27 | "h5",
28 | "blockquote",
29 | }
30 |
31 |
32 | class BleachField(forms.CharField):
33 | """Bleach form field"""
34 |
35 | def to_python(self, value):
36 | """
37 | Strips any dodgy HTML tags from the input.
38 | Mark the return value as template safe.
39 | """
40 | if value in self.empty_values:
41 | return self.empty_value
42 | cleaned_html = nh3.clean(value, tags=ALLOWED_TAGS, link_rel="noopener")
43 | return mark_safe(cleaned_html)
44 |
45 |
46 | class GovernmentPlanForm(forms.ModelForm):
47 | description = BleachField(
48 | required=False, widget=TinyMCE(attrs={"cols": 80, "rows": 30})
49 | )
50 |
51 | class Meta:
52 | model = GovernmentPlan
53 | fields = "__all__"
54 |
55 |
56 | class GovernmentPlanUpdateForm(forms.ModelForm):
57 | content = BleachField(
58 | required=False, widget=TinyMCE(attrs={"cols": 80, "rows": 30})
59 | )
60 |
61 | class Meta:
62 | model = GovernmentPlanUpdate
63 | fields = "__all__"
64 |
65 |
66 | class GovernmentPlanUpdateProposalForm(forms.ModelForm):
67 | title = forms.CharField(
68 | label=_("title"),
69 | help_text=_("Summarize the update in a title."),
70 | widget=forms.TextInput(
71 | attrs={
72 | "class": "form-control",
73 | }
74 | ),
75 | )
76 | content = forms.CharField(
77 | required=False,
78 | label=_("details"),
79 | help_text=_("Optionally give more details."),
80 | widget=forms.Textarea(attrs={"class": "form-control", "rows": "3"}),
81 | )
82 | url = forms.URLField(
83 | label=_("source URL"),
84 | help_text=_("Please give provide a link."),
85 | widget=forms.URLInput(
86 | attrs={"class": "form-control", "placeholder": "https://"}
87 | ),
88 | )
89 | status = forms.ChoiceField(
90 | label=_("status"),
91 | help_text=_("Has the status of the plan changed?"),
92 | choices=[("", "---")] + PlanStatus.choices,
93 | required=False,
94 | widget=BootstrapSelect,
95 | )
96 | rating = forms.TypedChoiceField(
97 | label=_("rating"),
98 | help_text=_("What's your rating of the current implementation?"),
99 | choices=[("", "---")] + PlanRating.choices,
100 | coerce=int,
101 | empty_value=None,
102 | required=False,
103 | widget=BootstrapSelect,
104 | )
105 |
106 | class Meta:
107 | model = GovernmentPlanUpdate
108 | fields = (
109 | "title",
110 | "content",
111 | "url",
112 | "status",
113 | "rating",
114 | )
115 |
116 | def __init__(self, *args, **kwargs):
117 | super().__init__(*args, **kwargs)
118 |
119 | def save(self, plan, user):
120 | """
121 | This doesn't save instance, but saves
122 | the change proposal.
123 | """
124 | data = self.cleaned_data
125 | plan.proposals = plan.proposals or {}
126 | plan.proposals[user.id] = {
127 | "data": data,
128 | "timestamp": timezone.now().isoformat(),
129 | }
130 | plan.save(update_fields=["proposals"])
131 | return plan
132 |
133 |
134 | class GovernmentPlanUpdateAcceptProposalForm(GovernmentPlanUpdateProposalForm):
135 | def __init__(self, *args, **kwargs):
136 | self.plan = kwargs.pop("plan")
137 | super().__init__(*args, **kwargs)
138 |
139 | def get_proposals(self):
140 | data = copy.deepcopy(self.plan.proposals)
141 | user_ids = self.plan.proposals.keys()
142 | user_map = {
143 | str(u.id): u for u in get_user_model().objects.filter(id__in=user_ids)
144 | }
145 | status_dict = dict(PlanStatus.choices)
146 | rating_dict = dict(PlanRating.choices)
147 | for user_id, v in data.items():
148 | v["user"] = user_map[user_id]
149 | data[user_id]["data"]["rating_label"] = rating_dict.get(
150 | data[user_id]["data"]["rating"]
151 | )
152 | data[user_id]["data"]["status_label"] = status_dict.get(
153 | data[user_id]["data"]["status"]
154 | )
155 | return data
156 |
157 | def save(
158 | self,
159 | proposal_id=None,
160 | delete_proposals=None,
161 | ):
162 | update = super(forms.ModelForm, self).save(commit=False)
163 | update.plan = self.plan
164 |
165 | if delete_proposals is None:
166 | delete_proposals = []
167 | if proposal_id:
168 | proposals = self.get_proposals()
169 | proposal_user = proposals[proposal_id]["user"]
170 | proposal_user.send_mail(
171 | _("Your proposal for the plan “%s” was accepted") % self.plan.title,
172 | _(
173 | "Hello,\n\nA moderator has accepted your proposal for an update to the plan "
174 | "“{title}”. An update will be published soon.\n\nAll the Best,\n{site_name}"
175 | ).format(title=self.plan.title, site_name=settings.SITE_NAME),
176 | priority=False,
177 | )
178 | user_org = proposal_user.organization_set.all().first()
179 | if user_org:
180 | update.organization = user_org
181 | delete_proposals.append(proposal_id)
182 |
183 | self.delete_proposals(delete_proposals)
184 | update.save()
185 | return update
186 |
187 | def delete_proposals(self, delete_proposals):
188 | for pid in delete_proposals:
189 | if pid in self.plan.proposals:
190 | del self.plan.proposals[pid]
191 | if not self.plan.proposals:
192 | self.plan.proposals = None
193 | self.plan.save(update_fields=["proposals"])
194 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0001_initial.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.8 on 2022-02-15 19:55
2 |
3 | import django.db.models.deletion
4 | import django.utils.timezone
5 | from django.conf import settings
6 | from django.db import migrations, models
7 |
8 | import filer.fields.image
9 | import taggit.managers
10 |
11 | from .. import conf
12 |
13 |
14 | class Migration(migrations.Migration):
15 |
16 | initial = True
17 |
18 | dependencies = (
19 | [
20 | ("publicbody", "0039_publicbody_alternative_emails"),
21 | ("auth", "0012_alter_user_first_name_max_length"),
22 | ]
23 | + (
24 | [
25 | ("foirequest", "0054_alter_foirequest_options"),
26 | ]
27 | if conf.GOVPLAN_ENABLE_FOIREQUEST
28 | else []
29 | )
30 | + [
31 | migrations.swappable_dependency(settings.FILER_IMAGE_MODEL),
32 | ("organization", "0001_initial"),
33 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
34 | ]
35 | )
36 |
37 | operations = [
38 | migrations.CreateModel(
39 | name="CategorizedGovernmentPlan",
40 | fields=[
41 | (
42 | "id",
43 | models.AutoField(
44 | auto_created=True,
45 | primary_key=True,
46 | serialize=False,
47 | verbose_name="ID",
48 | ),
49 | ),
50 | ],
51 | options={
52 | "verbose_name": "Categorized Government Plan",
53 | "verbose_name_plural": "Categorized Government Plans",
54 | },
55 | ),
56 | migrations.CreateModel(
57 | name="Government",
58 | fields=[
59 | (
60 | "id",
61 | models.AutoField(
62 | auto_created=True,
63 | primary_key=True,
64 | serialize=False,
65 | verbose_name="ID",
66 | ),
67 | ),
68 | ("name", models.CharField(max_length=255)),
69 | ("slug", models.SlugField(max_length=255, unique=True)),
70 | ("public", models.BooleanField(default=False)),
71 | ("description", models.TextField(blank=True)),
72 | ("start_date", models.DateField(blank=True, null=True)),
73 | ("end_date", models.DateField(blank=True, null=True)),
74 | ("planning_document", models.URLField(blank=True)),
75 | (
76 | "jurisdiction",
77 | models.ForeignKey(
78 | null=True,
79 | on_delete=django.db.models.deletion.SET_NULL,
80 | to="publicbody.jurisdiction",
81 | ),
82 | ),
83 | ],
84 | options={
85 | "verbose_name": "Government",
86 | "verbose_name_plural": "Governments",
87 | },
88 | ),
89 | migrations.CreateModel(
90 | name="GovernmentPlan",
91 | fields=[
92 | (
93 | "id",
94 | models.AutoField(
95 | auto_created=True,
96 | primary_key=True,
97 | serialize=False,
98 | verbose_name="ID",
99 | ),
100 | ),
101 | ("title", models.CharField(max_length=255)),
102 | ("slug", models.SlugField(max_length=255, unique=True)),
103 | ("description", models.TextField(blank=True)),
104 | ("public", models.BooleanField(default=False)),
105 | (
106 | "status",
107 | models.CharField(
108 | choices=[
109 | ("not_started", "not started"),
110 | ("started", "started"),
111 | ("partially_implemented", "partially implemented"),
112 | ("implemented", "implemented"),
113 | ("deferred", "deferred"),
114 | ],
115 | default="needs_approval",
116 | max_length=25,
117 | ),
118 | ),
119 | (
120 | "rating",
121 | models.IntegerField(
122 | blank=True,
123 | choices=[
124 | (1, "terrible"),
125 | (2, "bad"),
126 | (3, "OK"),
127 | (4, "good"),
128 | (5, "excellent"),
129 | ],
130 | null=True,
131 | ),
132 | ),
133 | ("reference", models.CharField(blank=True, max_length=255)),
134 | (
135 | "categories",
136 | taggit.managers.TaggableManager(
137 | blank=True,
138 | help_text="A comma-separated list of tags.",
139 | through="froide_govplan.CategorizedGovernmentPlan",
140 | to="publicbody.Category",
141 | verbose_name="categories",
142 | ),
143 | ),
144 | (
145 | "government",
146 | models.ForeignKey(
147 | on_delete=django.db.models.deletion.CASCADE,
148 | to="froide_govplan.government",
149 | ),
150 | ),
151 | (
152 | "group",
153 | models.ForeignKey(
154 | blank=True,
155 | null=True,
156 | on_delete=django.db.models.deletion.SET_NULL,
157 | to="auth.group",
158 | ),
159 | ),
160 | (
161 | "image",
162 | filer.fields.image.FilerImageField(
163 | blank=True,
164 | default=None,
165 | null=True,
166 | on_delete=django.db.models.deletion.SET_NULL,
167 | to=settings.FILER_IMAGE_MODEL,
168 | verbose_name="image",
169 | ),
170 | ),
171 | (
172 | "responsible_publicbody",
173 | models.ForeignKey(
174 | blank=True,
175 | null=True,
176 | on_delete=django.db.models.deletion.SET_NULL,
177 | to="publicbody.publicbody",
178 | ),
179 | ),
180 | ],
181 | options={
182 | "verbose_name": "Government plan",
183 | "verbose_name_plural": "Government plans",
184 | "ordering": ("reference", "title"),
185 | },
186 | ),
187 | migrations.CreateModel(
188 | name="GovernmentPlanUpdate",
189 | fields=[
190 | (
191 | "id",
192 | models.AutoField(
193 | auto_created=True,
194 | primary_key=True,
195 | serialize=False,
196 | verbose_name="ID",
197 | ),
198 | ),
199 | ("timestamp", models.DateTimeField(default=django.utils.timezone.now)),
200 | ("title", models.CharField(blank=True, max_length=1024)),
201 | ("content", models.TextField(blank=True)),
202 | (
203 | "status",
204 | models.CharField(
205 | blank=True,
206 | choices=[
207 | ("not_started", "not started"),
208 | ("started", "started"),
209 | ("partially_implemented", "partially implemented"),
210 | ("implemented", "implemented"),
211 | ("deferred", "deferred"),
212 | ],
213 | default="",
214 | max_length=25,
215 | ),
216 | ),
217 | (
218 | "rating",
219 | models.IntegerField(
220 | blank=True,
221 | choices=[
222 | (1, "terrible"),
223 | (2, "bad"),
224 | (3, "OK"),
225 | (4, "good"),
226 | (5, "excellent"),
227 | ],
228 | null=True,
229 | ),
230 | ),
231 | ("public", models.BooleanField(default=False)),
232 | ]
233 | + (
234 | [
235 | (
236 | "foirequest",
237 | models.ForeignKey(
238 | blank=True,
239 | null=True,
240 | on_delete=django.db.models.deletion.SET_NULL,
241 | to="foirequest.foirequest",
242 | ),
243 | )
244 | ]
245 | if conf.GOVPLAN_ENABLE_FOIREQUEST
246 | else []
247 | )
248 | + [
249 | (
250 | "organization",
251 | models.ForeignKey(
252 | blank=True,
253 | null=True,
254 | on_delete=django.db.models.deletion.SET_NULL,
255 | to="organization.organization",
256 | ),
257 | ),
258 | (
259 | "plan",
260 | models.ForeignKey(
261 | on_delete=django.db.models.deletion.CASCADE,
262 | related_name="updates",
263 | to="froide_govplan.governmentplan",
264 | ),
265 | ),
266 | (
267 | "user",
268 | models.ForeignKey(
269 | blank=True,
270 | null=True,
271 | on_delete=django.db.models.deletion.SET_NULL,
272 | to=settings.AUTH_USER_MODEL,
273 | ),
274 | ),
275 | ],
276 | options={
277 | "verbose_name": "Plan update",
278 | "verbose_name_plural": "Plan updates",
279 | "ordering": ("-timestamp",),
280 | "get_latest_by": "timestamp",
281 | },
282 | ),
283 | migrations.AddField(
284 | model_name="categorizedgovernmentplan",
285 | name="content_object",
286 | field=models.ForeignKey(
287 | on_delete=django.db.models.deletion.CASCADE,
288 | to="froide_govplan.governmentplan",
289 | ),
290 | ),
291 | migrations.AddField(
292 | model_name="categorizedgovernmentplan",
293 | name="tag",
294 | field=models.ForeignKey(
295 | on_delete=django.db.models.deletion.CASCADE,
296 | related_name="categorized_governmentplan",
297 | to="publicbody.category",
298 | ),
299 | ),
300 | ]
301 |
--------------------------------------------------------------------------------
/froide_govplan/admin.py:
--------------------------------------------------------------------------------
1 | from adminsortable2.admin import SortableAdminMixin
2 | from django.contrib import admin, auth
3 | from django.contrib.auth.models import Group
4 | from django.shortcuts import get_object_or_404, redirect, render
5 | from django.urls import path, reverse, reverse_lazy
6 | from django.utils.translation import gettext_lazy as _
7 | from froide.follow.admin import FollowerAdmin
8 | from froide.helper.admin_utils import make_choose_object_action, make_emptyfilter
9 | from froide.helper.widgets import TagAutocompleteWidget
10 | from froide.organization.models import Organization
11 |
12 | from . import conf
13 | from .auth import get_allowed_plans, has_limited_access
14 | from .forms import (
15 | GovernmentPlanForm,
16 | GovernmentPlanUpdateAcceptProposalForm,
17 | GovernmentPlanUpdateForm,
18 | )
19 | from .models import (
20 | Government,
21 | GovernmentPlan,
22 | GovernmentPlanFollower,
23 | GovernmentPlanSection,
24 | GovernmentPlanUpdate,
25 | )
26 |
27 | User = auth.get_user_model()
28 |
29 |
30 | class GovPlanAdminSite(admin.AdminSite):
31 | site_header = conf.GOVPLAN_NAME
32 | site_url = None
33 |
34 |
35 | class GovernmentPlanAdminForm(GovernmentPlanForm):
36 | class Meta:
37 | model = GovernmentPlan
38 | fields = "__all__"
39 | widgets = {
40 | "categories": TagAutocompleteWidget(
41 | autocomplete_url=reverse_lazy("api:category-autocomplete")
42 | ),
43 | }
44 |
45 |
46 | class GovernmentAdmin(admin.ModelAdmin):
47 | prepopulated_fields = {"slug": ("name",)}
48 | list_display = ("name", "public", "start_date", "end_date")
49 | list_filter = ("public",)
50 | raw_id_fields = ("georegion",)
51 |
52 |
53 | def execute_assign_organization(admin, request, queryset, action_obj):
54 | queryset.update(organization=action_obj)
55 |
56 |
57 | def execute_assign_group(admin, request, queryset, action_obj):
58 | queryset.update(group=action_obj)
59 |
60 |
61 | PLAN_ACTIONS = {
62 | "assign_organization": make_choose_object_action(
63 | Organization, execute_assign_organization, _("Assign organization...")
64 | ),
65 | "assign_group": make_choose_object_action(
66 | Group, execute_assign_group, _("Assign permission group...")
67 | ),
68 | }
69 |
70 |
71 | class GovernmentPlanAdmin(admin.ModelAdmin):
72 | form = GovernmentPlanForm
73 |
74 | save_on_top = True
75 | prepopulated_fields = {"slug": ("title",)}
76 | search_fields = ("title",)
77 | raw_id_fields = ("responsible_publicbody",)
78 |
79 | actions = ["make_public"]
80 |
81 | def get_queryset(self, request):
82 | qs = get_allowed_plans(request)
83 | qs = qs.prefetch_related(
84 | "categories",
85 | "organization",
86 | "group",
87 | )
88 | return qs
89 |
90 | def get_actions(self, request):
91 | actions = super().get_actions(request)
92 | if not has_limited_access(request.user):
93 | admin_actions = {
94 | action: (
95 | func,
96 | action,
97 | func.short_description,
98 | )
99 | for action, func in PLAN_ACTIONS.items()
100 | }
101 | actions.update(admin_actions)
102 | return actions
103 |
104 | def get_urls(self):
105 | urls = super().get_urls()
106 | my_urls = [
107 | path(
108 | "
6 |
8 |
61 | {% if wrapper_classes %}
9 |
30 |
31 | {% if update.content or show_context %}
32 |
10 | {% if show_context %}
11 | {{ update.plan.get_section }}
12 | {% endif %}
13 | {% if show_context %}
14 |
19 | {{ update.plan }}
15 | {% else %} 16 |{{ update.title }}
17 | {% endif %} 18 |
20 |
21 | {% if update.user or update.organization %}
22 |
23 | von {{ update.user.get_full_name }}
24 | {% if update.user and update.organization %},{% endif %}
25 | {{ update.organization.name }}
26 |
27 | {% endif %}
28 |
29 |
33 | {% if show_context %}
42 | {% endif %}
43 | {% if update.url or update.foirequest or show_context %}
44 | {{ update.title }}
{% endif %} 34 | {% with update.content|markdown as content %} 35 | {% if show_context %} 36 | {{ content|truncatewords_html:50 }} 37 | {% else %} 38 | {{ content }} 39 | {% endif %} 40 | {% endwith %} 41 |
45 | {% if show_context %}
46 | → zum Vorhaben
47 | {% else %}
48 | {% if update.url %}
49 | → mehr auf {{ update.get_url_domain }} lesen…
53 | {% endif %}
54 | {% if update.foirequest %}
55 | → zur Anfrage
56 | {% endif %}
57 | {% endif %}
58 |
59 | {% endif %}
60 |
19 |
199 | {% endblock app_body %}
200 |
--------------------------------------------------------------------------------
/froide_govplan/migrations/0003_auto_20220228_1051.py:
--------------------------------------------------------------------------------
1 | # Generated by Django 3.2.12 on 2022-02-28 09:51
2 |
3 | import django.db.models.deletion
4 | import django.utils.timezone
5 | from django.conf import settings
6 | from django.db import migrations, models
7 |
8 | from .. import conf
9 |
10 |
11 | class Migration(migrations.Migration):
12 |
13 | dependencies = [
14 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
15 | ("publicbody", "0039_publicbody_alternative_emails"),
16 | ("organization", "0001_initial"),
17 | ("auth", "0012_alter_user_first_name_max_length"),
18 | ("froide_govplan", "0002_auto_20220215_2113"),
19 | ] + (
20 | [("foirequest", "0054_alter_foirequest_options")]
21 | if conf.GOVPLAN_ENABLE_FOIREQUEST
22 | else []
23 | )
24 |
25 | operations = (
26 | [
27 | migrations.AddField(
28 | model_name="governmentplan",
29 | name="due_date",
30 | field=models.DateField(blank=True, null=True, verbose_name="due date"),
31 | ),
32 | migrations.AddField(
33 | model_name="governmentplan",
34 | name="measure",
35 | field=models.CharField(
36 | blank=True, max_length=255, verbose_name="measure"
37 | ),
38 | ),
39 | migrations.AddField(
40 | model_name="governmentplan",
41 | name="quote",
42 | field=models.TextField(blank=True, verbose_name="quote"),
43 | ),
44 | migrations.AlterField(
45 | model_name="government",
46 | name="description",
47 | field=models.TextField(blank=True, verbose_name="description"),
48 | ),
49 | migrations.AlterField(
50 | model_name="government",
51 | name="end_date",
52 | field=models.DateField(blank=True, null=True, verbose_name="end date"),
53 | ),
54 | migrations.AlterField(
55 | model_name="government",
56 | name="jurisdiction",
57 | field=models.ForeignKey(
58 | null=True,
59 | on_delete=django.db.models.deletion.SET_NULL,
60 | to="publicbody.jurisdiction",
61 | verbose_name="jurisdiction",
62 | ),
63 | ),
64 | migrations.AlterField(
65 | model_name="government",
66 | name="name",
67 | field=models.CharField(max_length=255, verbose_name="name"),
68 | ),
69 | migrations.AlterField(
70 | model_name="government",
71 | name="planning_document",
72 | field=models.URLField(blank=True, verbose_name="planning document"),
73 | ),
74 | migrations.AlterField(
75 | model_name="government",
76 | name="public",
77 | field=models.BooleanField(default=False, verbose_name="is public?"),
78 | ),
79 | migrations.AlterField(
80 | model_name="government",
81 | name="slug",
82 | field=models.SlugField(
83 | max_length=255, unique=True, verbose_name="slug"
84 | ),
85 | ),
86 | migrations.AlterField(
87 | model_name="government",
88 | name="start_date",
89 | field=models.DateField(
90 | blank=True, null=True, verbose_name="start date"
91 | ),
92 | ),
93 | migrations.AlterField(
94 | model_name="governmentplan",
95 | name="description",
96 | field=models.TextField(blank=True, verbose_name="description"),
97 | ),
98 | migrations.AlterField(
99 | model_name="governmentplan",
100 | name="government",
101 | field=models.ForeignKey(
102 | on_delete=django.db.models.deletion.CASCADE,
103 | to="froide_govplan.government",
104 | verbose_name="government",
105 | ),
106 | ),
107 | migrations.AlterField(
108 | model_name="governmentplan",
109 | name="group",
110 | field=models.ForeignKey(
111 | blank=True,
112 | null=True,
113 | on_delete=django.db.models.deletion.SET_NULL,
114 | to="auth.group",
115 | verbose_name="group",
116 | ),
117 | ),
118 | migrations.AlterField(
119 | model_name="governmentplan",
120 | name="organization",
121 | field=models.ForeignKey(
122 | blank=True,
123 | null=True,
124 | on_delete=django.db.models.deletion.SET_NULL,
125 | to="organization.organization",
126 | verbose_name="organization",
127 | ),
128 | ),
129 | migrations.AlterField(
130 | model_name="governmentplan",
131 | name="public",
132 | field=models.BooleanField(default=False, verbose_name="is public?"),
133 | ),
134 | migrations.AlterField(
135 | model_name="governmentplan",
136 | name="rating",
137 | field=models.IntegerField(
138 | blank=True,
139 | choices=[
140 | (1, "terrible"),
141 | (2, "bad"),
142 | (3, "OK"),
143 | (4, "good"),
144 | (5, "excellent"),
145 | ],
146 | null=True,
147 | verbose_name="rating",
148 | ),
149 | ),
150 | migrations.AlterField(
151 | model_name="governmentplan",
152 | name="reference",
153 | field=models.CharField(
154 | blank=True, max_length=255, verbose_name="reference"
155 | ),
156 | ),
157 | migrations.AlterField(
158 | model_name="governmentplan",
159 | name="responsible_publicbody",
160 | field=models.ForeignKey(
161 | blank=True,
162 | null=True,
163 | on_delete=django.db.models.deletion.SET_NULL,
164 | to="publicbody.publicbody",
165 | verbose_name="responsible public body",
166 | ),
167 | ),
168 | migrations.AlterField(
169 | model_name="governmentplan",
170 | name="slug",
171 | field=models.SlugField(
172 | max_length=255, unique=True, verbose_name="slug"
173 | ),
174 | ),
175 | migrations.AlterField(
176 | model_name="governmentplan",
177 | name="status",
178 | field=models.CharField(
179 | choices=[
180 | ("not_started", "not started"),
181 | ("started", "started"),
182 | ("partially_implemented", "partially implemented"),
183 | ("implemented", "implemented"),
184 | ("deferred", "deferred"),
185 | ],
186 | default="not_started",
187 | max_length=25,
188 | verbose_name="status",
189 | ),
190 | ),
191 | migrations.AlterField(
192 | model_name="governmentplan",
193 | name="title",
194 | field=models.CharField(max_length=255, verbose_name="title"),
195 | ),
196 | migrations.AlterField(
197 | model_name="governmentplanupdate",
198 | name="content",
199 | field=models.TextField(blank=True, verbose_name="content"),
200 | ),
201 | ]
202 | + (
203 | [
204 | migrations.AlterField(
205 | model_name="governmentplanupdate",
206 | name="foirequest",
207 | field=models.ForeignKey(
208 | blank=True,
209 | null=True,
210 | on_delete=django.db.models.deletion.SET_NULL,
211 | to="foirequest.foirequest",
212 | verbose_name="FOI request",
213 | ),
214 | ),
215 | ]
216 | if conf.GOVPLAN_ENABLE_FOIREQUEST
217 | else []
218 | )
219 | + [
220 | migrations.AlterField(
221 | model_name="governmentplanupdate",
222 | name="organization",
223 | field=models.ForeignKey(
224 | blank=True,
225 | null=True,
226 | on_delete=django.db.models.deletion.SET_NULL,
227 | to="organization.organization",
228 | verbose_name="organization",
229 | ),
230 | ),
231 | migrations.AlterField(
232 | model_name="governmentplanupdate",
233 | name="plan",
234 | field=models.ForeignKey(
235 | on_delete=django.db.models.deletion.CASCADE,
236 | related_name="updates",
237 | to="froide_govplan.governmentplan",
238 | verbose_name="plan",
239 | ),
240 | ),
241 | migrations.AlterField(
242 | model_name="governmentplanupdate",
243 | name="public",
244 | field=models.BooleanField(default=False, verbose_name="is public?"),
245 | ),
246 | migrations.AlterField(
247 | model_name="governmentplanupdate",
248 | name="rating",
249 | field=models.IntegerField(
250 | blank=True,
251 | choices=[
252 | (1, "terrible"),
253 | (2, "bad"),
254 | (3, "OK"),
255 | (4, "good"),
256 | (5, "excellent"),
257 | ],
258 | null=True,
259 | verbose_name="rating",
260 | ),
261 | ),
262 | migrations.AlterField(
263 | model_name="governmentplanupdate",
264 | name="status",
265 | field=models.CharField(
266 | blank=True,
267 | choices=[
268 | ("not_started", "not started"),
269 | ("started", "started"),
270 | ("partially_implemented", "partially implemented"),
271 | ("implemented", "implemented"),
272 | ("deferred", "deferred"),
273 | ],
274 | default="",
275 | max_length=25,
276 | verbose_name="status",
277 | ),
278 | ),
279 | migrations.AlterField(
280 | model_name="governmentplanupdate",
281 | name="timestamp",
282 | field=models.DateTimeField(
283 | default=django.utils.timezone.now, verbose_name="timestamp"
284 | ),
285 | ),
286 | migrations.AlterField(
287 | model_name="governmentplanupdate",
288 | name="title",
289 | field=models.CharField(
290 | blank=True, max_length=1024, verbose_name="title"
291 | ),
292 | ),
293 | migrations.AlterField(
294 | model_name="governmentplanupdate",
295 | name="url",
296 | field=models.URLField(blank=True, verbose_name="URL"),
297 | ),
298 | migrations.AlterField(
299 | model_name="governmentplanupdate",
300 | name="user",
301 | field=models.ForeignKey(
302 | blank=True,
303 | null=True,
304 | on_delete=django.db.models.deletion.SET_NULL,
305 | to=settings.AUTH_USER_MODEL,
306 | verbose_name="user",
307 | ),
308 | ),
309 | ]
310 | )
311 |
--------------------------------------------------------------------------------
/froide_govplan/locale/de/LC_MESSAGES/django.po:
--------------------------------------------------------------------------------
1 | # SOME DESCRIPTIVE TITLE.
2 | # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
3 | # This file is distributed under the same license as the PACKAGE package.
4 | # FIRST AUTHOR
20 |
148 |
21 |
147 |
22 | {% if not government.active %}
23 |
146 | Dieses Vorhaben gehörte zur {{ government.name }} und wird nicht mehr aktualisiert.
24 | {% endif %}
25 | {{ object.title }}
26 |
27 |
42 | -
28 |
- 29 | {{ object.get_status_display }} 30 | 31 | {% for cat in object.categories.all %} 32 |
- 33 | {{ cat.name }} 35 | 36 | {% endfor %} 37 |
{% show_follow "govplan" object %}
40 | {% endif %}
41 |
43 |
145 |
44 |
79 | -
45 | {% if object.quote %}
46 |
- Ausschnitt aus dem Koalitionsvertrag 47 |
-
48 |
49 | {{ object.quote | addquotes | markdown }} 50 |
51 | {% with refs=object.get_reference_links %} 52 | {% if refs %} 53 |54 | 55 | {% if refs|length > 1 %} 56 | Quellen: 57 | {% else %} 58 | Quelle: 59 | {% endif %} 60 | 61 | {% for ref in refs %} 62 | {{ forloop.counter }} 63 | {% endfor %} 64 |
65 | {% endif %} 66 | {% endwith %} 67 | {% endif %} 68 |
69 | {% if object.description %}
70 | - Unsere Einschätzung 72 |
- 73 | {{ object.description | safe }} 74 | 75 |
71 |
76 | {% endif %}
77 |
80 |
144 | -
81 | {% if object.rating %}
82 |
- Bewertung 83 |
- 84 | {{ object.get_rating_display }} 85 | 86 | {% endif %} 87 | {% if object.measure %} 88 |
- Art der Umsetzung 89 |
- 90 | {{ object.measure }} 91 | 92 | {% endif %} 93 | {% if object.due_date %} 94 |
- Frist 95 |
- 96 | {{ object.due_date|date:"SHORT_DATE_FORMAT" }} 97 | 98 | {% endif %} 99 | {% if object.responsible_publicbody %} 100 |
- Federführung 101 |
- 102 | {{ object.responsible_publicbody.name }} 103 | 104 | {% endif %} 105 | {% if object.responsible_publicbody %} 106 | {% if not object.has_recent_foirequest and government.active %} 107 |
- Anfrage 115 |
- 116 | {% include "foirequest/snippets/request_item_mini.html" with object=foirequest %} 117 | 118 | {% endwith %} 119 | {% endif %} 120 | {% endif %} 121 | {% if object.organization %} 122 |
- Beobachtet von 123 |
-
124 |
125 | {% if object.organization.logo %}
126 | {% if object.organization.logo.url.lower|slice:"-4:" == ".svg" %}
127 | {# djlint:off H006 #}
128 |
131 | {% else %} 132 |
135 | {% endif %} 136 | {% else %} 137 | {{ object.organization.name }} 138 | {% endif %} 139 | 140 |
141 | {% endif %}
142 |
108 | Anfrage zum Vorhaben stellen 111 |
112 | {% elif object.has_recent_foirequest %} 113 | {% with foirequest=object.get_recent_foirequest %} 114 |
149 | {% include "froide_govplan/plugins/updates.html" with wrapper_classes="col col-12 col-lg-6 d-flex mb-4" %}
150 | {% if government.active %}
151 |
198 |
152 |
196 | {% endif %}
197 |
153 |
195 |
154 |
194 |
155 |
157 | Neue Entwicklung melden
156 |
158 | {% if request.user.is_authenticated %}
159 |
193 | Gibt es Neuigkeiten zu diesem Vorhaben, die wir noch nicht erfasst haben?
160 | 164 |
169 |
189 | {% else %}
190 | Bitte melden Sie sich an, um einen Änderungsvorschlag einzureichen.
191 | {% endif %}
192 |
170 |
187 |
188 |