wbtasks 2.2.1__tar.gz

wbtasks-2.2.1/.gitignore

@@ -0,0 +1,181 @@
+~
+
+# Docker volumes
+volumes/
+# Poetry auth file
+auth.toml
+
+media/*
+media/
+mediafiles/
+mediafiles/*
+test/*
+staticfiles/*
+staticfiles/
+#
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+info/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+.dccache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+report.xml
+*/report.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+*.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+.idea/
+.idea.bkp/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+crm/
+# Cython debug symbols
+cython_debug/
+
+# Gitlab Runner
+builds
+builds/
+
+# Integrator Office 365 : reverse proxy tunnel for outlook365
+ngrok
+*/ngrok
+/modules/**/system/
+
+/modules/wbmailing/files/*
+/modules/wbmailing/mailing/*
+
+/projects/*/requirements.txt
+public
+
+# Ignore archive localization generated folder
+backend/modules/**/archive/*
+**/**/requirements.txt
+CHANGELOG-*

wbtasks-2.2.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.3
+Name: wbtasks
+Version: 2.2.1
+Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
+Requires-Dist: wbcore

wbtasks-2.2.1/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "wbtasks"
+description = ""
+authors = [{ name = "Christopher Wittlinger", email = "c.wittlinger@stainly.com"}]
+dynamic = ["version"]
+
+dependencies = [
+  "wbcore",
+]
+
+[tool.uv.sources]
+wbcore = { workspace = true }
+
+[tool.uv]
+package = true
+
+[tool.hatch.version]
+path = "../../pyproject.toml"
+
+[tool.hatch.build.targets.sdist]
+include = ["wbtasks/*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["wbtasks"]
+only-packages = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

wbtasks-2.2.1/wbtasks/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.0"
+

wbtasks-2.2.1/wbtasks/admin.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+from wbtasks.models import Task
+
+
+@admin.register(Task)
+class TaskModelAdmin(admin.ModelAdmin):
+    list_display = ("id", "title", "due_date", "requester", "in_charge")
+
+    autocomplete_fields = ["requester", "in_charge"]

wbtasks-2.2.1/wbtasks/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WbtasksConfig(AppConfig):
+    name = "wbtasks"

wbtasks-2.2.1/wbtasks/factories.py

@@ -0,0 +1,28 @@
+import factory
+import pytz
+from wbcore.contrib.authentication.factories import AuthenticatedPersonFactory
+from wbtasks.models import Task
+
+
+class TaskFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Task
+
+    title = factory.Faker("text", max_nb_chars=64)
+    due_date = factory.Faker("date_time", tzinfo=pytz.utc)
+    creation_date = factory.Faker("date_time_between", start_date="+2d", end_date="+3d", tzinfo=pytz.utc)
+    starting_date = factory.Faker("date_time_between", start_date="+2d", end_date="+3d", tzinfo=pytz.utc)
+    completion_date = factory.Faker("date_time_between", start_date="+4d", end_date="+5d", tzinfo=pytz.utc)
+    requester = factory.SubFactory(AuthenticatedPersonFactory)
+    in_charge = factory.SubFactory(AuthenticatedPersonFactory)
+    widget_endpoint = factory.Faker("text", max_nb_chars=64)
+    description = factory.Faker("paragraph")
+    comment = factory.Faker("paragraph")
+
+    @factory.post_generation
+    def assigned_to(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for participant in extracted:
+                self.assigned_to.add(participant)

wbtasks-2.2.1/wbtasks/filters.py

@@ -0,0 +1,54 @@
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import Entry, Person
+from wbtasks.models import Task
+
+
+def get_current_user_id(field, request, view):
+    return request.user.profile.id
+
+
+class TaskFilter(wb_filters.FilterSet):
+    in_charge = wb_filters.ModelChoiceFilter(
+        label="Assigned to",
+        queryset=Person.objects.all(),
+        endpoint=Person.get_representation_endpoint(),
+        value_key=Person.get_representation_value_key(),
+        label_key=Person.get_representation_label_key(),
+        filter_params={"only_internal_users": True},
+        # default=get_current_user_id,
+        method="filter_in_charge",
+    )
+
+    participants = wb_filters.ModelMultipleChoiceFilter(
+        label="Participants",
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+        # default=get_current_user_id,
+        method="filter_participants",
+    )
+
+    def filter_in_charge(self, queryset, name, value):
+        if value:
+            return queryset.filter(in_charge=value)
+        return queryset
+
+    def filter_participants(self, queryset, name, value):
+        if value:
+            return queryset.filter(assigned_to__in=value).distinct()
+        return queryset
+
+    class Meta:
+        model = Task
+        fields = {
+            "starting_date": ["gte", "exact", "lte"],
+            "completion_date": ["gte", "exact", "lte"],
+            "creation_date": ["gte", "exact", "lte"],
+            "due_date": ["gte", "exact", "lte"],
+            "requester": ["exact"],
+            # "in_charge": ["exact"],
+            "assigned_to": ["exact"],
+            "status": ["exact"],
+            "priority": ["exact"],
+        }

wbtasks-2.2.1/wbtasks/migrations/0001_initial_squashed_squashed_0006_alter_task_assigned_to_alter_task_in_charge_and_more.py

@@ -0,0 +1,114 @@
+# Generated by Django 4.1.8 on 2023-04-17 11:19
+
+import django.db.models.deletion
+import django_fsm
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("wbcore", "0001_initial_squashed_squashed_0010_preset_appliedpreset"),
+        ("directory", "0001_initial"),
+        ("tags", "0001_initial"),
+        ("agenda", "0002_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Task",
+            fields=[
+                ("tag_detail_endpoint", models.CharField(blank=True, max_length=255, null=True)),
+                ("tag_representation", models.CharField(blank=True, max_length=512, null=True)),
+                ("due_date", models.DateTimeField(blank=True, null=True, verbose_name="Due Date")),
+                ("creation_date", models.DateTimeField(auto_now_add=True, verbose_name="Creation Date")),
+                ("starting_date", models.DateTimeField(blank=True, null=True, verbose_name="Started at")),
+                ("completion_date", models.DateTimeField(blank=True, null=True, verbose_name="Completed at")),
+                (
+                    "status",
+                    django_fsm.FSMField(
+                        choices=[("UNSCHEDULED", "Unscheduled"), ("STARTED", "Started"), ("COMPLETED", "Completed")],
+                        default="UNSCHEDULED",
+                        max_length=50,
+                        verbose_name="Status",
+                    ),
+                ),
+                ("description", models.TextField(default="", verbose_name="Description")),
+                (
+                    "priority",
+                    models.CharField(
+                        choices=[("LOW", "Low"), ("MEDIUM", "Medium"), ("HIGH", "High")],
+                        default="LOW",
+                        max_length=16,
+                        verbose_name="Priority level",
+                    ),
+                ),
+                ("comment", models.TextField(default="", verbose_name="Comment")),
+                ("widget_endpoint", models.CharField(default="", max_length=256, verbose_name="Widget Endpoint")),
+                (
+                    "tags",
+                    models.ManyToManyField(blank=True, related_name="%(app_label)s_%(class)s_items", to="tags.tag"),
+                ),
+                (
+                    "assigned_to",
+                    models.ManyToManyField(
+                        blank=True,
+                        help_text="The list of participants",
+                        related_name="participates_tasks",
+                        to="directory.person",
+                        verbose_name="Participants",
+                    ),
+                ),
+                (
+                    "calendaritem_ptr",
+                    models.OneToOneField(
+                        auto_created=True,
+                        default=None,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        parent_link=True,
+                        primary_key=True,
+                        serialize=False,
+                        to="agenda.calendaritem",
+                    ),
+                ),
+                (
+                    "in_charge",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="in_charge_of_tasks",
+                        to="directory.person",
+                        verbose_name="In charge",
+                    ),
+                ),
+                (
+                    "requester",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="created_tasks",
+                        to="directory.person",
+                        verbose_name="Requester",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+        migrations.AlterField(
+            model_name="task",
+            name="calendaritem_ptr",
+            field=models.OneToOneField(
+                auto_created=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                parent_link=True,
+                primary_key=True,
+                serialize=False,
+                to="agenda.calendaritem",
+            ),
+        ),
+    ]

wbtasks-2.2.1/wbtasks/models.py

@@ -0,0 +1,221 @@
+from datetime import timedelta
+
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.utils import timezone
+from django_fsm import FSMField, transition
+from psycopg.types.range import TimestamptzRange
+from rest_framework.reverse import reverse
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.agenda.signals import draggable_calendar_item_ids
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.contrib.notifications.utils import create_notification_type
+from wbcore.contrib.tags.models import TagModelMixin
+from wbcore.enums import RequestType
+from wbcore.metadata.configs.buttons import ActionButton, ButtonDefaultColor
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.shares.signals import handle_widget_sharing
+
+
+def can_modify_status(instance, user):
+    return hasattr(user, "profile") and user.profile in [instance.requester, instance.in_charge]
+
+
+class Task(TagModelMixin, CalendarItem):
+    class Status(models.TextChoices):
+        UNSCHEDULED = "UNSCHEDULED", "Unscheduled"
+        STARTED = "STARTED", "Started"
+        COMPLETED = "COMPLETED", "Completed"
+
+    class Priority(models.TextChoices):
+        LOW = "LOW", "Low"
+        MEDIUM = "MEDIUM", "Medium"
+        HIGH = "HIGH", "High"
+
+    fsm_base_button_parameters = {
+        "method": RequestType.PATCH,
+        "identifiers": ("wbtasks:task",),
+        "description_fields": "<p>{{ title }}</p>",
+    }
+
+    start_button = ActionButton(
+        key="start",
+        label="Start",
+        action_label="start",
+        color=ButtonDefaultColor.WARNING,
+        icon=WBIcon.SEND.icon,
+        **fsm_base_button_parameters,
+    )
+
+    complete_button = ActionButton(
+        key="complete",
+        label="Complete",
+        action_label="complete",
+        color=ButtonDefaultColor.SUCCESS,
+        instance_display=create_simple_display([["comment"]]),
+        icon=WBIcon.CONFIRM.icon,
+        **fsm_base_button_parameters,
+    )
+
+    due_date = models.DateTimeField(verbose_name="Due Date", null=True, blank=True)
+    creation_date = models.DateTimeField(auto_now_add=True, verbose_name="Creation Date")
+    starting_date = models.DateTimeField(blank=True, null=True, verbose_name="Started at")
+    completion_date = models.DateTimeField(blank=True, null=True, verbose_name="Completed at")
+
+    requester = models.ForeignKey(
+        "directory.Person",
+        verbose_name="Requester",
+        related_name="created_tasks",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
+    in_charge = models.ForeignKey(
+        "directory.Person",
+        verbose_name="In charge",
+        related_name="in_charge_of_tasks",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+    )
+    assigned_to = models.ManyToManyField(
+        "directory.Person",
+        related_name="participates_tasks",
+        blank=True,
+        verbose_name="Participants",
+        help_text="The list of participants",
+    )
+    status = FSMField(default=Status.UNSCHEDULED, choices=Status.choices, verbose_name="Status")
+
+    description = models.TextField(default="", verbose_name="Description")
+    comment = models.TextField(default="", verbose_name="Comment")
+    priority = models.CharField(
+        default=Priority.LOW, choices=Priority.choices, verbose_name="Priority level", max_length=16
+    )
+
+    widget_endpoint = models.CharField(max_length=256, verbose_name="Widget Endpoint", default="")
+
+    class Meta:
+        notification_types = [
+            create_notification_type(
+                "wbtasks.task.notify", "Task Notification", "Sends a notification when a task is due."
+            ),
+        ]
+
+    @transition(
+        status,
+        source=[Status.UNSCHEDULED],
+        target=Status.STARTED,
+        permission=can_modify_status,
+        custom={"_transition_button": start_button},
+    )
+    def start(self, by=None, description=None, **kwargs):
+        self.starting_date = timezone.now()
+
+    @transition(
+        status,
+        source=[Status.STARTED],
+        target=Status.COMPLETED,
+        permission=can_modify_status,
+        custom={"_transition_button": complete_button},
+    )
+    def complete(self, by=None, description=None, **kwargs):
+        self.completion_date = timezone.now()
+
+    def get_tag_detail_endpoint(self):
+        return reverse("wbtasks:task-detail", [self.id])
+
+    def get_tag_representation(self):
+        return self.title
+
+    def get_color(self) -> str:
+        return "#f48474"  # light red
+
+    def get_icon(self) -> str:
+        return WBIcon.WARNING.icon
+
+    def save(self, *args, **kwargs):
+        if self.due_date and not (self.starting_date and self.completion_date):
+            start = self.due_date
+            end = self.due_date + timedelta(seconds=1)
+            self.period = TimestamptzRange(start, end)
+        elif self.starting_date and self.completion_date:
+            self.period = TimestamptzRange(self.starting_date, self.completion_date)
+
+        return super().save(*args, **kwargs)
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbtasks:task"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbtasks:taskrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "title"
+
+
+@receiver(post_save, sender=Task)
+def post_save_task(sender, instance: Task, created: bool, **kwargs):
+    """
+    Post save signal.
+    * Notifies assigned_to person that a task has been assigned to him
+    """
+
+    if (
+        created
+        and instance.requester != instance.in_charge
+        and instance.in_charge
+        and hasattr(instance.in_charge, "user_account")
+    ):
+        send_notification(
+            code="wbtasks.task.notify",
+            title="A new task has been assigned to you",
+            body=f"The task {instance.title} was requested by {str(instance.in_charge)} and is due {instance.due_date:%d.%m.%Y}, check it out!",
+            user=instance.in_charge.user_account,
+            reverse_name="wbtasks:task-detail",
+            reverse_args=[instance.id],
+        )
+
+    instance.entities.set(instance.assigned_to.values_list("id", flat=True))
+    if in_charge := instance.in_charge:
+        instance.entities.add(in_charge)
+    if requester := instance.requester:
+        instance.entities.add(requester)
+
+
+@receiver(draggable_calendar_item_ids, sender="agenda.CalendarItem")
+def tasks_draggable_calendar_item_ids(sender, request, **kwargs) -> models.QuerySet[CalendarItem]:
+    return Task.objects.filter(in_charge=request.user.profile, status=Task.Status.UNSCHEDULED).values("id")
+
+
+@receiver(handle_widget_sharing)
+def received_handle_share(
+    request,
+    widget_relative_endpoint,
+    task_share=None,
+    task_title=None,
+    task_description=None,
+    task_due_date=None,
+    task_in_charge=None,
+    **kwargs,
+):
+    if task_share and task_in_charge:
+        Task.objects.create(
+            requester=request.user.profile,
+            in_charge=task_in_charge,
+            title=task_title if task_title else "Share widget Task",
+            description=task_description if task_description else "",
+            widget_endpoint=widget_relative_endpoint,
+            due_date=task_due_date,
+        )

wbtasks-2.2.1/wbtasks/serializers.py

@@ -0,0 +1,159 @@
+from datetime import date, timedelta
+
+from django.utils.translation import gettext_lazy as _
+from wbcore import serializers as wb_serializers
+from wbcore import shares
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import (
+    InternalUserProfileRepresentationSerializer,
+    PersonRepresentationSerializer,
+)
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbcore.metadata.configs.display.instance_display import (
+    create_simple_section,
+    repeat_field,
+)
+from wbtasks.models import Task
+
+
+class TaskRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = Task
+        fields = ("id", "title")
+
+
+class TaskModelSerializer(TagSerializerMixin, wb_serializers.ModelSerializer):
+    _requester = PersonRepresentationSerializer(source="requester")
+    _in_charge = InternalUserProfileRepresentationSerializer(source="in_charge")
+    _assigned_to = PersonRepresentationSerializer(source="assigned_to", many=True)
+
+    @wb_serializers.register_resource()
+    def ressource(self, instance, request, user):
+        ressource = {}
+        if instance.widget_endpoint:
+            ressource["widget"] = instance.widget_endpoint
+        return ressource
+
+    def create(self, validated_data):
+        if request := self.context.get("request"):
+            validated_data["requester"] = request.user.profile
+        return super().create(validated_data)
+
+    def validate(self, attrs):
+        if self.instance:
+            assigned_to = attrs.get("assigned_to", self.instance.assigned_to)
+            in_charge = attrs.get("in_charge", self.instance.in_charge)
+        else:
+            assigned_to = attrs.get("assigned_to", [])
+            in_charge = attrs.get("in_charge", None)
+
+        if assigned_to or in_charge:
+            list_of_ids = []
+            if in_charge:
+                list_of_ids.append(in_charge.id)
+            if assigned_to:
+                if isinstance(assigned_to, list):
+                    for person in assigned_to:
+                        list_of_ids.append(person.id)
+                else:
+                    list_of_ids += assigned_to.values_list("id", flat=True)
+
+            attrs["entities"] = Person.objects.filter(id__in=list_of_ids).distinct()
+
+        return super().validate(attrs)
+
+    class Meta:
+        model = Task
+        required_fields = ("title", "requester")
+        read_only_fields = (
+            "starting_date",
+            "completion_date",
+            "creation_date",
+        )
+        fields = (
+            "id",
+            "title",
+            "starting_date",
+            "completion_date",
+            "creation_date",
+            "due_date",
+            "requester",
+            "_requester",
+            "in_charge",
+            "_in_charge",
+            "assigned_to",
+            "_assigned_to",
+            "status",
+            "description",
+            "comment",
+            "priority",
+            "tags",
+            "_tags",
+            "_additional_resources",
+        )
+
+
+class TaskToActivitySerializer(TaskModelSerializer):
+    title = wb_serializers.CharField(label="Title", required=False)
+    starting_date = wb_serializers.DateTimeField(label="Start")
+    completion_date = wb_serializers.DateTimeField(label="End")
+    requester = wb_serializers.PrimaryKeyRelatedField(queryset=Person.objects.all(), label="Creator")
+    in_charge = wb_serializers.PrimaryKeyRelatedField(queryset=Person.objects.all(), label="In charge to")
+    description = wb_serializers.TextField(label="Description")
+    comment = wb_serializers.TextField(label="Review")
+
+    class Meta:
+        model = Task
+        fields = (
+            "id",
+            "title",
+            "starting_date",
+            "completion_date",
+            "requester",
+            "_requester",
+            "in_charge",
+            "_in_charge",
+            "assigned_to",
+            "_assigned_to",
+            "description",
+            "comment",
+            "_requester",
+        )
+
+
+@shares.register(
+    section=create_simple_section(
+        "task_section",
+        _("Share as Task"),
+        [
+            [repeat_field(4, "task_share")],
+            [repeat_field(4, "task_title")],
+            [repeat_field(2, "task_due_date"), repeat_field(2, "task_in_charge")],
+            [repeat_field(4, "task_description")],
+        ],
+        collapsed=True,
+    )
+)
+class TaskShareSerializer(wb_serializers.Serializer):
+    task_share = wb_serializers.BooleanField(default=False, label=_("Share as Task"))
+    task_title = wb_serializers.CharField(
+        max_length=256, label=_("Title"), required=False, depends_on=[{"field": "task_share", "options": {}}]
+    )
+    task_description = wb_serializers.TextField(
+        label=_("Description"), required=False, depends_on=[{"field": "task_share", "options": {}}]
+    )
+    task_due_date = wb_serializers.DateField(
+        label=_("Date"),
+        required=False,
+        default=lambda: date.today() + timedelta(days=7),
+        depends_on=[{"field": "task_share", "options": {}}],
+    )
+    task_in_charge = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Person.objects.all(),
+        label=_("In Charge"),
+        required=False,
+        depends_on=[{"field": "task_share", "options": {}}],
+    )
+    _task_in_charge = PersonRepresentationSerializer(
+        source="task_in_charge", depends_on=[{"field": "task_share", "options": {}}]
+    )

wbtasks-2.2.1/wbtasks/tasks.py

@@ -0,0 +1,42 @@
+from __future__ import absolute_import, unicode_literals
+
+from datetime import timedelta
+
+from celery import shared_task
+from django.db.models import Q
+from django.utils import timezone
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbtasks.models import Task
+
+NOTIFY_DUE_TASKS_INTERVAL_MINUTES = 60
+
+
+@shared_task
+def notify_due_tasks(now=None, notification=None):
+    if not now:
+        now = timezone.now()
+    for task in Task.objects.filter(
+        ~Q(status=Task.Status.COMPLETED)
+        & Q(due_date__gt=now)
+        & Q(due_date__lt=now + timedelta(minutes=NOTIFY_DUE_TASKS_INTERVAL_MINUTES))
+    ):
+        if (profile := task.in_charge) and (user := profile.user_account):
+            send_notification(
+                code="wbtasks.task.notify",
+                title="Task is due",
+                body=f"the task {task.title} is due at {task.due_date:%d.%m.%Y}",
+                user=user,
+                reverse_name="wbtasks:task-detail",
+                reverse_args=[task.id],
+            )
+    return notification
+
+
+# from restbench.celery import app as celery_app
+
+# celery_app.conf.beat_schedule.update({
+#     'Tasks: Notify Due tasks': {
+#         'task': 'wbtasks.tasks.notify_due_tasks',
+#         'schedule': NOTIFY_DUE_TASKS_INTERVAL_MINUTES*60
+#     }
+# })

wbtasks-2.2.1/wbtasks/tests/conftest.py

@@ -0,0 +1,11 @@
+from django.apps import apps
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbtasks.factories import TaskFactory
+
+register(TaskFactory)
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbtasks"))

wbtasks-2.2.1/wbtasks/tests/test_filters.py

@@ -0,0 +1,35 @@
+import pytest
+from wbcore.contrib.authentication.factories import AuthenticatedPersonFactory
+from wbtasks.viewsets.viewsets import TaskModelViewSet
+
+
+@pytest.mark.django_db
+class TestSpecificFilters:
+    def test_filter_in_charge(self, task_factory):
+        person = AuthenticatedPersonFactory()
+        person2 = AuthenticatedPersonFactory()
+        task_factory(in_charge=person2)
+        mvs = TaskModelViewSet()
+        qs = mvs.get_serializer_class().Meta.model.objects.all()
+        assert mvs.filterset_class().filter_in_charge(qs, "", None) == qs
+        assert mvs.filterset_class().filter_in_charge(qs, "", person).count() == 0
+        assert mvs.filterset_class().filter_in_charge(qs, "", person2).count() == 1
+
+    def test_filter_participants(self, task_factory):
+        person = AuthenticatedPersonFactory()
+        person2 = AuthenticatedPersonFactory()
+        person3 = AuthenticatedPersonFactory()
+        task_factory(
+            in_charge=person2,
+            assigned_to=(
+                person2,
+                person3,
+            ),
+        )
+        mvs = TaskModelViewSet()
+        qs = mvs.get_serializer_class().Meta.model.objects.all()
+        assert mvs.filterset_class().filter_participants(qs, "", None) == qs
+        assert mvs.filterset_class().filter_participants(qs, "", [person]).count() == 0
+        assert mvs.filterset_class().filter_participants(qs, "", [person2]).count() == 1
+        assert mvs.filterset_class().filter_participants(qs, "", [person3]).count() == 1
+        assert mvs.filterset_class().filter_participants(qs, "", [person2, person3]).count() == 1

wbtasks-2.2.1/wbtasks/tests/test_models.py

@@ -0,0 +1,16 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestSpecificModels:
+    def test_start(self, task_factory):
+        obj = task_factory()
+        assert obj.status == obj.Status.UNSCHEDULED
+        obj.start()
+        assert obj.status == obj.Status.STARTED
+
+    def test_complete(self, task_factory):
+        obj = task_factory()
+        obj.start()
+        obj.complete()
+        assert obj.status == obj.Status.COMPLETED

wbtasks-2.2.1/wbtasks/tests/test_serializers.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestSpecificSerializers:
+    pass

wbtasks-2.2.1/wbtasks/tests/test_tasks.py

@@ -0,0 +1,6 @@
+import pytest
+
+
+@pytest.mark.django_db
+class TestSpecificTasks:
+    pass

wbtasks-2.2.1/wbtasks/tests/tests.py

@@ -0,0 +1,12 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(filter(lambda x: x.__module__.startswith("wbtasks"), value))
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbtasks-2.2.1/wbtasks/urls.py

@@ -0,0 +1,11 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbtasks.viewsets import viewsets
+
+router = WBCoreRouter()
+router.register(r"task", viewsets.TaskModelViewSet, basename="task")
+router.register(r"taskrepresentation", viewsets.TaskRepresentationViewSet, basename="taskrepresentation")
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

wbtasks-2.2.1/wbtasks/viewsets/__init__.py

@@ -0,0 +1,3 @@
+from wbtasks.viewsets.buttons import TaskButtonConfig
+from wbtasks.viewsets.display import TaskDisplayConfig
+from wbtasks.viewsets.titles import TaskTitleConfig

wbtasks-2.2.1/wbtasks/viewsets/buttons.py

@@ -0,0 +1,11 @@
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class TaskButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {
+            bt.WidgetButton(key="see_activity", label="Linked Activity", icon=WBIcon.CALENDAR.icon),
+            bt.WidgetButton(key="widget", label="Linked Widget", icon=WBIcon.LINK.icon),
+        }

wbtasks-2.2.1/wbtasks/viewsets/display.py

@@ -0,0 +1,78 @@
+from typing import Optional
+
+from wbcore.contrib.color.enums import WBColor
+from wbcore.enums import Operator
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+from wbtasks.models import Task
+
+
+class TaskDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="in_charge", label="In Charge"),
+                dp.Field(key="due_date", label="Due at"),
+                dp.Field(key="description", label="Description"),
+                dp.Field(key="tags", label="Tags"),
+            ],
+            formatting=[
+                dp.Formatting(
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.BLUE_LIGHT.value},
+                            condition=dp.Condition(operator=Operator.EQUAL, value=Task.Status.UNSCHEDULED),
+                        ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.YELLOW.value},
+                            condition=dp.Condition(operator=Operator.EQUAL, value=Task.Status.STARTED),
+                        ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREEN_LIGHT.value},
+                            condition=dp.Condition(operator=Operator.EQUAL, value=Task.Status.COMPLETED),
+                        ),
+                    ],
+                    column="status",
+                )
+            ],
+            legends=[
+                dp.Legend(
+                    key="status",
+                    items=[
+                        dp.LegendItem(
+                            label=Task.Status.UNSCHEDULED.label,
+                            icon=WBColor.BLUE_LIGHT.value,
+                            value=Task.Status.UNSCHEDULED.value,
+                        ),
+                        dp.LegendItem(
+                            label=Task.Status.STARTED.label,
+                            icon=WBColor.YELLOW.value,
+                            value=Task.Status.STARTED.value,
+                        ),
+                        dp.LegendItem(
+                            label=Task.Status.COMPLETED.label,
+                            icon=WBColor.GREEN_LIGHT.value,
+                            value=Task.Status.COMPLETED.value,
+                        ),
+                    ],
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["status", "status", "status"],
+                ["title", "title", "title"],
+                ["creation_date", "due_date", "."],
+                ["starting_date", "completion_date", "."],
+                ["requester", "in_charge", "tags"],
+                ["description", "description", "description"],
+                ["comment", "comment", "comment"],
+            ]
+        )

wbtasks-2.2.1/wbtasks/viewsets/menu.py

@@ -0,0 +1,11 @@
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+TASK_MENUITEM = MenuItem(
+    label="Tasks",
+    endpoint="wbtasks:task-list",
+    add=MenuItem(label="Create Task", endpoint="wbtasks:task-list"),
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user), permissions=["wbtasks.view_task"]
+    ),
+)

wbtasks-2.2.1/wbtasks/viewsets/titles.py

@@ -0,0 +1,12 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class TaskTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return "{{title}}"
+
+    def get_list_title(self):
+        return "Tasks"
+
+    def get_create_title(self):
+        return "Create Task"

wbtasks-2.2.1/wbtasks/viewsets/viewsets.py

@@ -0,0 +1,36 @@
+from rest_framework import filters
+from wbcore.filters import DjangoFilterBackend
+from wbcore.viewsets import ModelViewSet, RepresentationViewSet
+from wbtasks.filters import TaskFilter
+from wbtasks.models import Task
+from wbtasks.serializers import TaskModelSerializer, TaskRepresentationSerializer
+from wbtasks.viewsets import TaskButtonConfig, TaskDisplayConfig, TaskTitleConfig
+
+
+class TaskRepresentationViewSet(RepresentationViewSet):
+    serializer_class = TaskRepresentationSerializer
+    queryset = Task.objects.all()
+
+    search_fields = ("title",)
+
+
+class TaskModelViewSet(ModelViewSet):
+    IDENTIFIER = "wbtasks:task"
+
+    filter_backends = (
+        DjangoFilterBackend,
+        filters.SearchFilter,
+        filters.OrderingFilter,
+    )
+
+    ordering_fields = ["due_date", "creation_date", "starting_date", "completion_date"]
+    ordering = ["-due_date"]
+    search_fields = ["title", "requester__computed_str", "assigned_to__computed_str", "description"]
+
+    serializer_class = TaskModelSerializer
+    filterset_class = TaskFilter
+    queryset = Task.objects.all()
+
+    display_config_class = TaskDisplayConfig
+    button_config_class = TaskButtonConfig
+    title_config_class = TaskTitleConfig