vkk.workhours.accounting.periods.views

This submodule contains class based views.

  1"""
  2This submodule contains class based views.
  3"""
  4
  5from django.shortcuts import get_object_or_404
  6from vkk.workhours.accounting.views import AccountingDetailView
  7from vkk.workhours.models import Period, Project, Department
  8
  9
 10class AccountingPeriodDetailView(AccountingDetailView):
 11    """
 12    This class based `View` provides an overview over a `Period` and whether
 13    all projects for a department have been closed for said period.
 14    """
 15    model = Period
 16    fields = ['start', 'end', 'dead_line', 'dead_line_final']
 17    template_name = "vkk/workhours/accounting/period/details.html"
 18
 19    def get_context_data(self, **kwargs):
 20        """
 21        Returns a query set of `Departments` and whether all projects for the given
 22        department and period have been closed.
 23        """
 24        context = super().get_context_data(**kwargs)
 25        departments = Department.objects.raw(" \
 26            WITH selected_period AS ( \
 27                SELECT \
 28                    vkk_period.id AS period_id, \
 29                    vkk_period.start AS period_start, \
 30                    vkk_period.end AS period_end \
 31                FROM vkk_period \
 32                WHERE vkk_period.id = %s \
 33            ), \
 34            filtered_projects AS ( \
 35                SELECT \
 36                    vkk_project.id AS project_id, \
 37                    vkk_project.department_id, \
 38                    selected_period.period_id \
 39                FROM vkk_project, selected_period \
 40                WHERE  \
 41                    selected_period.period_end >= vkk_project.start  \
 42                    AND selected_period.period_start <= vkk_project.end \
 43            ), \
 44            closures AS ( \
 45                SELECT \
 46                    vkk_periodclosure.project_assignment_id, \
 47                    vkk_periodclosure.is_closed_manager \
 48                FROM  \
 49                    vkk_periodclosure JOIN selected_period \
 50                    ON vkk_periodclosure.period_id = selected_period.period_id \
 51            ), \
 52            not_closed_assignments AS ( \
 53                SELECT \
 54                    vkk_projectassignment.id AS assignment_id, \
 55                    vkk_projectassignment.project_id \
 56                FROM \
 57                    vkk_projectassignment LEFT JOIN closures \
 58                    ON vkk_projectassignment.id = closures.project_assignment_id \
 59                WHERE \
 60                    closures.is_closed_manager IS NULL \
 61                    OR closures.is_closed_manager = FALSE \
 62            ), \
 63            not_closed_projects AS ( \
 64                SELECT \
 65                    department_id, \
 66                    COUNT(project_id) AS not_closed \
 67                FROM \
 68                    filtered_projects p \
 69                WHERE  \
 70                    EXISTS ( \
 71                        SELECT assignment_id \
 72                        FROM not_closed_assignments c \
 73                        WHERE  \
 74                            c.project_id = p.project_id \
 75                    ) \
 76                GROUP BY department_id \
 77            ) \
 78            SELECT \
 79                id, \
 80                name, \
 81                accounting_entry, \
 82                invoice_number, \
 83                COALESCE(not_closed, 0) AS projects_not_closed \
 84                FROM \
 85                    vkk_department FULL JOIN not_closed_projects \
 86                    ON vkk_department.id = not_closed_projects.department_id \
 87                ORDER BY vkk_department.name \
 88            ;", [self.kwargs['pk']])
 89
 90        context["departments"] = departments
 91        return context
 92
 93
 94class AccountingPeriodDetailDepartmentView(AccountingDetailView):
 95    """
 96    A class based `View` offering an overview of all projects belonging to a 
 97    given department over a given period and whether they have been closed.
 98    """
 99    model = Period
100    fields = ['start', 'end', 'dead_line', 'dead_line_final']
101    template_name = "vkk/workhours/accounting/period/projects.html"
102
103    def get_context_data(self, **kwargs):
104        """
105        Returns a query set of `Projects` over a period and beloginging to a given
106        department with the added information whether they have been closed or not.
107        """
108        context = super().get_context_data(**kwargs)
109        department = get_object_or_404(
110            Department, pk=self.kwargs["department_pk"])
111        projects_open = Project.objects.raw(" \
112            WITH selected_period AS ( \
113                SELECT \
114                    vkk_period.id AS period_id, \
115                    vkk_period.start AS period_start, \
116                    vkk_period.end AS period_end \
117                FROM vkk_period \
118                WHERE vkk_period.id = %s \
119            ), \
120            filtered_projects AS ( \
121                SELECT \
122                    selected_period.period_id, \
123                    vkk_project.id, \
124                    vkk_project.invoice_number, \
125                    vkk_project.name, \
126                    vkk_project.contractor, \
127                    vkk_project.start, \
128                    vkk_project.end, \
129                    vkk_project.department_id \
130                FROM vkk_project, selected_period \
131                WHERE  \
132                    selected_period.period_end >= vkk_project.start  \
133                    AND selected_period.period_start <= vkk_project.end \
134                    AND vkk_project.department_id = %s \
135            ), \
136            closures AS ( \
137                SELECT \
138                    vkk_periodclosure.project_assignment_id, \
139                    vkk_periodclosure.is_closed_manager \
140                FROM  \
141                    vkk_periodclosure JOIN selected_period \
142                    ON vkk_periodclosure.period_id = selected_period.period_id \
143            ), \
144            not_closed_assignments AS ( \
145                SELECT \
146                    vkk_projectassignment.id AS assignment_id, \
147                    vkk_projectassignment.project_id \
148                FROM \
149                    vkk_projectassignment LEFT JOIN closures \
150                    ON vkk_projectassignment.id = closures.project_assignment_id \
151                WHERE \
152                    closures.is_closed_manager IS NULL \
153                    OR closures.is_closed_manager = FALSE \
154            ) \
155            SELECT \
156                p.id, \
157                p.invoice_number, \
158                p.name, \
159                p.contractor, \
160                p.start, \
161                p.end, \
162                p.department_id \
163            FROM \
164                filtered_projects p \
165            WHERE  \
166                EXISTS ( \
167                    SELECT assignment_id \
168                    FROM not_closed_assignments c \
169                    WHERE  \
170                        c.project_id = p.id \
171                ) \
172            ORDER BY p.invoice_number;",
173            [self.kwargs['pk'], self.kwargs["department_pk"]]
174        )
175
176        projects_closed = Project.objects.raw(" \
177            WITH selected_period AS ( \
178                SELECT \
179                    vkk_period.id AS period_id, \
180                    vkk_period.start AS period_start, \
181                    vkk_period.end AS period_end \
182                FROM vkk_period \
183                WHERE vkk_period.id = %s \
184            ), \
185            filtered_projects AS ( \
186                SELECT \
187                    selected_period.period_id, \
188                    vkk_project.id, \
189                    vkk_project.invoice_number, \
190                    vkk_project.name, \
191                    vkk_project.contractor, \
192                    vkk_project.start, \
193                    vkk_project.end, \
194                    vkk_project.department_id, \
195                    selected_period.period_start, \
196                    selected_period.period_end \
197                FROM vkk_project, selected_period \
198                WHERE  \
199                    selected_period.period_end >= vkk_project.start  \
200                    AND selected_period.period_start <= vkk_project.end \
201                    AND vkk_project.department_id = %s \
202            ), \
203            closures AS ( \
204                SELECT \
205                    vkk_periodclosure.project_assignment_id, \
206                    vkk_periodclosure.is_closed_manager \
207                FROM  \
208                    vkk_periodclosure JOIN selected_period \
209                    ON vkk_periodclosure.period_id = selected_period.period_id \
210            ), \
211            not_closed_assignments AS ( \
212                SELECT \
213                    vkk_projectassignment.id AS assignment_id, \
214                    vkk_projectassignment.project_id \
215                FROM \
216                    vkk_projectassignment LEFT JOIN closures \
217                    ON vkk_projectassignment.id = closures.project_assignment_id \
218                WHERE \
219                    closures.is_closed_manager IS NULL \
220                    OR closures.is_closed_manager = FALSE \
221            ) \
222            SELECT \
223                p.id, \
224                p.invoice_number, \
225                p.name, \
226                p.contractor, \
227                p.start, \
228                p.end, \
229                p.department_id, \
230                CASE  \
231                    WHEN EXISTS ( \
232                        SELECT 1 \
233                            FROM vkk_receipt \
234                            WHERE \
235                                p.id = vkk_receipt.project_id \
236                                AND p.period_start = vkk_receipt.start \
237                                AND p.period_end = vkk_receipt.end \
238                    ) THEN TRUE \
239                    ELSE FALSE \
240                END AS exists_receipt \
241            FROM \
242                filtered_projects p \
243            WHERE  \
244                NOT EXISTS ( \
245                    SELECT assignment_id \
246                    FROM not_closed_assignments c \
247                    WHERE  \
248                        c.project_id = p.id \
249                ) \
250            ORDER BY p.invoice_number;",
251            [self.kwargs['pk'], self.kwargs["department_pk"]]
252        )
253
254        context["department"] = department
255        context["projects_open"] = projects_open
256        context["projects_closed"] = projects_closed
257        return context
258
259class AccountingPeriodDetailNoDepartmentView(AccountingDetailView):
260    """
261    A class based `View` providing an overview of projects which do not belong to any
262    department for the given period.
263    """
264    model = Period
265    fields = ['start', 'end', 'dead_line', 'dead_line_final']
266    template_name = "vkk/workhours/accounting/period/projects.html"
267
268    def get_context_data(self, **kwargs):
269        context = super().get_context_data(**kwargs)
270        projects_open = Project.objects.raw(" \
271            WITH selected_period AS ( \
272                SELECT \
273                    vkk_period.id AS period_id, \
274                    vkk_period.start AS period_start, \
275                    vkk_period.end AS period_end \
276                FROM vkk_period \
277                WHERE vkk_period.id = %s \
278            ), \
279            filtered_projects AS ( \
280                SELECT \
281                    selected_period.period_id, \
282                    vkk_project.id, \
283                    vkk_project.invoice_number, \
284                    vkk_project.name, \
285                    vkk_project.contractor, \
286                    vkk_project.start, \
287                    vkk_project.end, \
288                    vkk_project.department_id \
289                FROM vkk_project, selected_period \
290                WHERE  \
291                    selected_period.period_end >= vkk_project.start  \
292                    AND selected_period.period_start <= vkk_project.end \
293                    AND vkk_project.department_id IS NULL \
294            ), \
295            closures AS ( \
296                SELECT \
297                    vkk_periodclosure.project_assignment_id, \
298                    vkk_periodclosure.is_closed_manager \
299                FROM  \
300                    vkk_periodclosure JOIN selected_period \
301                    ON vkk_periodclosure.period_id = selected_period.period_id \
302            ), \
303            not_closed_assignments AS ( \
304                SELECT \
305                    vkk_projectassignment.id AS assignment_id, \
306                    vkk_projectassignment.project_id \
307                FROM \
308                    vkk_projectassignment LEFT JOIN closures \
309                    ON vkk_projectassignment.id = closures.project_assignment_id \
310                WHERE \
311                    closures.is_closed_manager IS NULL \
312                    OR closures.is_closed_manager = FALSE \
313            ) \
314            SELECT \
315                p.id, \
316                p.invoice_number, \
317                p.name, \
318                p.contractor, \
319                p.start, \
320                p.end, \
321                p.department_id \
322            FROM \
323                filtered_projects p \
324            WHERE  \
325                EXISTS ( \
326                    SELECT assignment_id \
327                    FROM not_closed_assignments c \
328                    WHERE  \
329                        c.project_id = p.id \
330                ) \
331            ORDER BY p.invoice_number;",
332            [self.kwargs['pk']]
333        )
334
335        projects_closed = Project.objects.raw(" \
336            WITH selected_period AS ( \
337                SELECT \
338                    vkk_period.id AS period_id, \
339                    vkk_period.start AS period_start, \
340                    vkk_period.end AS period_end \
341                FROM vkk_period \
342                WHERE vkk_period.id = %s \
343            ), \
344            filtered_projects AS ( \
345                SELECT \
346                    selected_period.period_id, \
347                    vkk_project.id, \
348                    vkk_project.invoice_number, \
349                    vkk_project.name, \
350                    vkk_project.contractor, \
351                    vkk_project.start, \
352                    vkk_project.end, \
353                    vkk_project.department_id, \
354                    selected_period.period_start, \
355                    selected_period.period_end \
356                FROM vkk_project, selected_period \
357                WHERE  \
358                    selected_period.period_end >= vkk_project.start  \
359                    AND selected_period.period_start <= vkk_project.end \
360                    AND vkk_project.department_id IS NULL \
361            ), \
362            closures AS ( \
363                SELECT \
364                    vkk_periodclosure.project_assignment_id, \
365                    vkk_periodclosure.is_closed_manager \
366                FROM  \
367                    vkk_periodclosure JOIN selected_period \
368                    ON vkk_periodclosure.period_id = selected_period.period_id \
369            ), \
370            not_closed_assignments AS ( \
371                SELECT \
372                    vkk_projectassignment.id AS assignment_id, \
373                    vkk_projectassignment.project_id \
374                FROM \
375                    vkk_projectassignment LEFT JOIN closures \
376                    ON vkk_projectassignment.id = closures.project_assignment_id \
377                WHERE \
378                    closures.is_closed_manager IS NULL \
379                    OR closures.is_closed_manager = FALSE \
380            ) \
381            SELECT \
382                p.id, \
383                p.invoice_number, \
384                p.name, \
385                p.contractor, \
386                p.start, \
387                p.end, \
388                p.department_id, \
389                CASE  \
390                    WHEN EXISTS ( \
391                        SELECT 1 \
392                            FROM vkk_receipt \
393                            WHERE \
394                                p.id = vkk_receipt.project_id \
395                                AND p.period_start = vkk_receipt.start \
396                                AND p.period_end = vkk_receipt.end \
397                    ) THEN TRUE \
398                    ELSE FALSE \
399                END AS exists_receipt \
400            FROM \
401                filtered_projects p \
402            WHERE  \
403                NOT EXISTS ( \
404                    SELECT assignment_id \
405                    FROM not_closed_assignments c \
406                    WHERE  \
407                        c.project_id = p.id \
408                ) \
409            ORDER BY p.invoice_number;",
410            [self.kwargs['pk']]
411        )
412
413        context["department"] = None
414        context["projects_open"] = projects_open
415        context["projects_closed"] = projects_closed
416        return context
class AccountingPeriodDetailView(vkk.workhours.accounting.views.AccountingDetailView):
11class AccountingPeriodDetailView(AccountingDetailView):
12    """
13    This class based `View` provides an overview over a `Period` and whether
14    all projects for a department have been closed for said period.
15    """
16    model = Period
17    fields = ['start', 'end', 'dead_line', 'dead_line_final']
18    template_name = "vkk/workhours/accounting/period/details.html"
19
20    def get_context_data(self, **kwargs):
21        """
22        Returns a query set of `Departments` and whether all projects for the given
23        department and period have been closed.
24        """
25        context = super().get_context_data(**kwargs)
26        departments = Department.objects.raw(" \
27            WITH selected_period AS ( \
28                SELECT \
29                    vkk_period.id AS period_id, \
30                    vkk_period.start AS period_start, \
31                    vkk_period.end AS period_end \
32                FROM vkk_period \
33                WHERE vkk_period.id = %s \
34            ), \
35            filtered_projects AS ( \
36                SELECT \
37                    vkk_project.id AS project_id, \
38                    vkk_project.department_id, \
39                    selected_period.period_id \
40                FROM vkk_project, selected_period \
41                WHERE  \
42                    selected_period.period_end >= vkk_project.start  \
43                    AND selected_period.period_start <= vkk_project.end \
44            ), \
45            closures AS ( \
46                SELECT \
47                    vkk_periodclosure.project_assignment_id, \
48                    vkk_periodclosure.is_closed_manager \
49                FROM  \
50                    vkk_periodclosure JOIN selected_period \
51                    ON vkk_periodclosure.period_id = selected_period.period_id \
52            ), \
53            not_closed_assignments AS ( \
54                SELECT \
55                    vkk_projectassignment.id AS assignment_id, \
56                    vkk_projectassignment.project_id \
57                FROM \
58                    vkk_projectassignment LEFT JOIN closures \
59                    ON vkk_projectassignment.id = closures.project_assignment_id \
60                WHERE \
61                    closures.is_closed_manager IS NULL \
62                    OR closures.is_closed_manager = FALSE \
63            ), \
64            not_closed_projects AS ( \
65                SELECT \
66                    department_id, \
67                    COUNT(project_id) AS not_closed \
68                FROM \
69                    filtered_projects p \
70                WHERE  \
71                    EXISTS ( \
72                        SELECT assignment_id \
73                        FROM not_closed_assignments c \
74                        WHERE  \
75                            c.project_id = p.project_id \
76                    ) \
77                GROUP BY department_id \
78            ) \
79            SELECT \
80                id, \
81                name, \
82                accounting_entry, \
83                invoice_number, \
84                COALESCE(not_closed, 0) AS projects_not_closed \
85                FROM \
86                    vkk_department FULL JOIN not_closed_projects \
87                    ON vkk_department.id = not_closed_projects.department_id \
88                ORDER BY vkk_department.name \
89            ;", [self.kwargs['pk']])
90
91        context["departments"] = departments
92        return context

This class based View provides an overview over a Period and whether all projects for a department have been closed for said period.

model = <class 'vkk.workhours.models.Period'>
fields = ['start', 'end', 'dead_line', 'dead_line_final']
template_name = 'vkk/workhours/accounting/period/details.html'
def get_context_data(self, **kwargs):
20    def get_context_data(self, **kwargs):
21        """
22        Returns a query set of `Departments` and whether all projects for the given
23        department and period have been closed.
24        """
25        context = super().get_context_data(**kwargs)
26        departments = Department.objects.raw(" \
27            WITH selected_period AS ( \
28                SELECT \
29                    vkk_period.id AS period_id, \
30                    vkk_period.start AS period_start, \
31                    vkk_period.end AS period_end \
32                FROM vkk_period \
33                WHERE vkk_period.id = %s \
34            ), \
35            filtered_projects AS ( \
36                SELECT \
37                    vkk_project.id AS project_id, \
38                    vkk_project.department_id, \
39                    selected_period.period_id \
40                FROM vkk_project, selected_period \
41                WHERE  \
42                    selected_period.period_end >= vkk_project.start  \
43                    AND selected_period.period_start <= vkk_project.end \
44            ), \
45            closures AS ( \
46                SELECT \
47                    vkk_periodclosure.project_assignment_id, \
48                    vkk_periodclosure.is_closed_manager \
49                FROM  \
50                    vkk_periodclosure JOIN selected_period \
51                    ON vkk_periodclosure.period_id = selected_period.period_id \
52            ), \
53            not_closed_assignments AS ( \
54                SELECT \
55                    vkk_projectassignment.id AS assignment_id, \
56                    vkk_projectassignment.project_id \
57                FROM \
58                    vkk_projectassignment LEFT JOIN closures \
59                    ON vkk_projectassignment.id = closures.project_assignment_id \
60                WHERE \
61                    closures.is_closed_manager IS NULL \
62                    OR closures.is_closed_manager = FALSE \
63            ), \
64            not_closed_projects AS ( \
65                SELECT \
66                    department_id, \
67                    COUNT(project_id) AS not_closed \
68                FROM \
69                    filtered_projects p \
70                WHERE  \
71                    EXISTS ( \
72                        SELECT assignment_id \
73                        FROM not_closed_assignments c \
74                        WHERE  \
75                            c.project_id = p.project_id \
76                    ) \
77                GROUP BY department_id \
78            ) \
79            SELECT \
80                id, \
81                name, \
82                accounting_entry, \
83                invoice_number, \
84                COALESCE(not_closed, 0) AS projects_not_closed \
85                FROM \
86                    vkk_department FULL JOIN not_closed_projects \
87                    ON vkk_department.id = not_closed_projects.department_id \
88                ORDER BY vkk_department.name \
89            ;", [self.kwargs['pk']])
90
91        context["departments"] = departments
92        return context

Returns a query set of Departments and whether all projects for the given department and period have been closed.

Inherited Members
django.views.generic.base.View
View
http_method_names
view_is_async
as_view
setup
http_method_not_allowed
options
vkk.workhours.accounting.mixins.AccountantRequiredMixin
dispatch
django.contrib.auth.mixins.AccessMixin
login_url
permission_denied_message
raise_exception
redirect_field_name
get_login_url
get_permission_denied_message
get_redirect_field_name
handle_no_permission
vkk.generic.views.CustomDetailView
action_options
django.views.generic.detail.SingleObjectTemplateResponseMixin
template_name_field
template_name_suffix
get_template_names
django.views.generic.base.TemplateResponseMixin
template_engine
response_class
content_type
render_to_response
django.views.generic.detail.BaseDetailView
get
django.views.generic.detail.SingleObjectMixin
queryset
slug_field
context_object_name
slug_url_kwarg
pk_url_kwarg
query_pk_and_slug
get_object
get_queryset
get_slug_field
get_context_object_name
django.views.generic.base.ContextMixin
extra_context
class AccountingPeriodDetailDepartmentView(vkk.workhours.accounting.views.AccountingDetailView):
 95class AccountingPeriodDetailDepartmentView(AccountingDetailView):
 96    """
 97    A class based `View` offering an overview of all projects belonging to a 
 98    given department over a given period and whether they have been closed.
 99    """
100    model = Period
101    fields = ['start', 'end', 'dead_line', 'dead_line_final']
102    template_name = "vkk/workhours/accounting/period/projects.html"
103
104    def get_context_data(self, **kwargs):
105        """
106        Returns a query set of `Projects` over a period and beloginging to a given
107        department with the added information whether they have been closed or not.
108        """
109        context = super().get_context_data(**kwargs)
110        department = get_object_or_404(
111            Department, pk=self.kwargs["department_pk"])
112        projects_open = Project.objects.raw(" \
113            WITH selected_period AS ( \
114                SELECT \
115                    vkk_period.id AS period_id, \
116                    vkk_period.start AS period_start, \
117                    vkk_period.end AS period_end \
118                FROM vkk_period \
119                WHERE vkk_period.id = %s \
120            ), \
121            filtered_projects AS ( \
122                SELECT \
123                    selected_period.period_id, \
124                    vkk_project.id, \
125                    vkk_project.invoice_number, \
126                    vkk_project.name, \
127                    vkk_project.contractor, \
128                    vkk_project.start, \
129                    vkk_project.end, \
130                    vkk_project.department_id \
131                FROM vkk_project, selected_period \
132                WHERE  \
133                    selected_period.period_end >= vkk_project.start  \
134                    AND selected_period.period_start <= vkk_project.end \
135                    AND vkk_project.department_id = %s \
136            ), \
137            closures AS ( \
138                SELECT \
139                    vkk_periodclosure.project_assignment_id, \
140                    vkk_periodclosure.is_closed_manager \
141                FROM  \
142                    vkk_periodclosure JOIN selected_period \
143                    ON vkk_periodclosure.period_id = selected_period.period_id \
144            ), \
145            not_closed_assignments AS ( \
146                SELECT \
147                    vkk_projectassignment.id AS assignment_id, \
148                    vkk_projectassignment.project_id \
149                FROM \
150                    vkk_projectassignment LEFT JOIN closures \
151                    ON vkk_projectassignment.id = closures.project_assignment_id \
152                WHERE \
153                    closures.is_closed_manager IS NULL \
154                    OR closures.is_closed_manager = FALSE \
155            ) \
156            SELECT \
157                p.id, \
158                p.invoice_number, \
159                p.name, \
160                p.contractor, \
161                p.start, \
162                p.end, \
163                p.department_id \
164            FROM \
165                filtered_projects p \
166            WHERE  \
167                EXISTS ( \
168                    SELECT assignment_id \
169                    FROM not_closed_assignments c \
170                    WHERE  \
171                        c.project_id = p.id \
172                ) \
173            ORDER BY p.invoice_number;",
174            [self.kwargs['pk'], self.kwargs["department_pk"]]
175        )
176
177        projects_closed = Project.objects.raw(" \
178            WITH selected_period AS ( \
179                SELECT \
180                    vkk_period.id AS period_id, \
181                    vkk_period.start AS period_start, \
182                    vkk_period.end AS period_end \
183                FROM vkk_period \
184                WHERE vkk_period.id = %s \
185            ), \
186            filtered_projects AS ( \
187                SELECT \
188                    selected_period.period_id, \
189                    vkk_project.id, \
190                    vkk_project.invoice_number, \
191                    vkk_project.name, \
192                    vkk_project.contractor, \
193                    vkk_project.start, \
194                    vkk_project.end, \
195                    vkk_project.department_id, \
196                    selected_period.period_start, \
197                    selected_period.period_end \
198                FROM vkk_project, selected_period \
199                WHERE  \
200                    selected_period.period_end >= vkk_project.start  \
201                    AND selected_period.period_start <= vkk_project.end \
202                    AND vkk_project.department_id = %s \
203            ), \
204            closures AS ( \
205                SELECT \
206                    vkk_periodclosure.project_assignment_id, \
207                    vkk_periodclosure.is_closed_manager \
208                FROM  \
209                    vkk_periodclosure JOIN selected_period \
210                    ON vkk_periodclosure.period_id = selected_period.period_id \
211            ), \
212            not_closed_assignments AS ( \
213                SELECT \
214                    vkk_projectassignment.id AS assignment_id, \
215                    vkk_projectassignment.project_id \
216                FROM \
217                    vkk_projectassignment LEFT JOIN closures \
218                    ON vkk_projectassignment.id = closures.project_assignment_id \
219                WHERE \
220                    closures.is_closed_manager IS NULL \
221                    OR closures.is_closed_manager = FALSE \
222            ) \
223            SELECT \
224                p.id, \
225                p.invoice_number, \
226                p.name, \
227                p.contractor, \
228                p.start, \
229                p.end, \
230                p.department_id, \
231                CASE  \
232                    WHEN EXISTS ( \
233                        SELECT 1 \
234                            FROM vkk_receipt \
235                            WHERE \
236                                p.id = vkk_receipt.project_id \
237                                AND p.period_start = vkk_receipt.start \
238                                AND p.period_end = vkk_receipt.end \
239                    ) THEN TRUE \
240                    ELSE FALSE \
241                END AS exists_receipt \
242            FROM \
243                filtered_projects p \
244            WHERE  \
245                NOT EXISTS ( \
246                    SELECT assignment_id \
247                    FROM not_closed_assignments c \
248                    WHERE  \
249                        c.project_id = p.id \
250                ) \
251            ORDER BY p.invoice_number;",
252            [self.kwargs['pk'], self.kwargs["department_pk"]]
253        )
254
255        context["department"] = department
256        context["projects_open"] = projects_open
257        context["projects_closed"] = projects_closed
258        return context

A class based View offering an overview of all projects belonging to a given department over a given period and whether they have been closed.

model = <class 'vkk.workhours.models.Period'>
fields = ['start', 'end', 'dead_line', 'dead_line_final']
template_name = 'vkk/workhours/accounting/period/projects.html'
def get_context_data(self, **kwargs):
104    def get_context_data(self, **kwargs):
105        """
106        Returns a query set of `Projects` over a period and beloginging to a given
107        department with the added information whether they have been closed or not.
108        """
109        context = super().get_context_data(**kwargs)
110        department = get_object_or_404(
111            Department, pk=self.kwargs["department_pk"])
112        projects_open = Project.objects.raw(" \
113            WITH selected_period AS ( \
114                SELECT \
115                    vkk_period.id AS period_id, \
116                    vkk_period.start AS period_start, \
117                    vkk_period.end AS period_end \
118                FROM vkk_period \
119                WHERE vkk_period.id = %s \
120            ), \
121            filtered_projects AS ( \
122                SELECT \
123                    selected_period.period_id, \
124                    vkk_project.id, \
125                    vkk_project.invoice_number, \
126                    vkk_project.name, \
127                    vkk_project.contractor, \
128                    vkk_project.start, \
129                    vkk_project.end, \
130                    vkk_project.department_id \
131                FROM vkk_project, selected_period \
132                WHERE  \
133                    selected_period.period_end >= vkk_project.start  \
134                    AND selected_period.period_start <= vkk_project.end \
135                    AND vkk_project.department_id = %s \
136            ), \
137            closures AS ( \
138                SELECT \
139                    vkk_periodclosure.project_assignment_id, \
140                    vkk_periodclosure.is_closed_manager \
141                FROM  \
142                    vkk_periodclosure JOIN selected_period \
143                    ON vkk_periodclosure.period_id = selected_period.period_id \
144            ), \
145            not_closed_assignments AS ( \
146                SELECT \
147                    vkk_projectassignment.id AS assignment_id, \
148                    vkk_projectassignment.project_id \
149                FROM \
150                    vkk_projectassignment LEFT JOIN closures \
151                    ON vkk_projectassignment.id = closures.project_assignment_id \
152                WHERE \
153                    closures.is_closed_manager IS NULL \
154                    OR closures.is_closed_manager = FALSE \
155            ) \
156            SELECT \
157                p.id, \
158                p.invoice_number, \
159                p.name, \
160                p.contractor, \
161                p.start, \
162                p.end, \
163                p.department_id \
164            FROM \
165                filtered_projects p \
166            WHERE  \
167                EXISTS ( \
168                    SELECT assignment_id \
169                    FROM not_closed_assignments c \
170                    WHERE  \
171                        c.project_id = p.id \
172                ) \
173            ORDER BY p.invoice_number;",
174            [self.kwargs['pk'], self.kwargs["department_pk"]]
175        )
176
177        projects_closed = Project.objects.raw(" \
178            WITH selected_period AS ( \
179                SELECT \
180                    vkk_period.id AS period_id, \
181                    vkk_period.start AS period_start, \
182                    vkk_period.end AS period_end \
183                FROM vkk_period \
184                WHERE vkk_period.id = %s \
185            ), \
186            filtered_projects AS ( \
187                SELECT \
188                    selected_period.period_id, \
189                    vkk_project.id, \
190                    vkk_project.invoice_number, \
191                    vkk_project.name, \
192                    vkk_project.contractor, \
193                    vkk_project.start, \
194                    vkk_project.end, \
195                    vkk_project.department_id, \
196                    selected_period.period_start, \
197                    selected_period.period_end \
198                FROM vkk_project, selected_period \
199                WHERE  \
200                    selected_period.period_end >= vkk_project.start  \
201                    AND selected_period.period_start <= vkk_project.end \
202                    AND vkk_project.department_id = %s \
203            ), \
204            closures AS ( \
205                SELECT \
206                    vkk_periodclosure.project_assignment_id, \
207                    vkk_periodclosure.is_closed_manager \
208                FROM  \
209                    vkk_periodclosure JOIN selected_period \
210                    ON vkk_periodclosure.period_id = selected_period.period_id \
211            ), \
212            not_closed_assignments AS ( \
213                SELECT \
214                    vkk_projectassignment.id AS assignment_id, \
215                    vkk_projectassignment.project_id \
216                FROM \
217                    vkk_projectassignment LEFT JOIN closures \
218                    ON vkk_projectassignment.id = closures.project_assignment_id \
219                WHERE \
220                    closures.is_closed_manager IS NULL \
221                    OR closures.is_closed_manager = FALSE \
222            ) \
223            SELECT \
224                p.id, \
225                p.invoice_number, \
226                p.name, \
227                p.contractor, \
228                p.start, \
229                p.end, \
230                p.department_id, \
231                CASE  \
232                    WHEN EXISTS ( \
233                        SELECT 1 \
234                            FROM vkk_receipt \
235                            WHERE \
236                                p.id = vkk_receipt.project_id \
237                                AND p.period_start = vkk_receipt.start \
238                                AND p.period_end = vkk_receipt.end \
239                    ) THEN TRUE \
240                    ELSE FALSE \
241                END AS exists_receipt \
242            FROM \
243                filtered_projects p \
244            WHERE  \
245                NOT EXISTS ( \
246                    SELECT assignment_id \
247                    FROM not_closed_assignments c \
248                    WHERE  \
249                        c.project_id = p.id \
250                ) \
251            ORDER BY p.invoice_number;",
252            [self.kwargs['pk'], self.kwargs["department_pk"]]
253        )
254
255        context["department"] = department
256        context["projects_open"] = projects_open
257        context["projects_closed"] = projects_closed
258        return context

Returns a query set of Projects over a period and beloginging to a given department with the added information whether they have been closed or not.

Inherited Members
django.views.generic.base.View
View
http_method_names
view_is_async
as_view
setup
http_method_not_allowed
options
vkk.workhours.accounting.mixins.AccountantRequiredMixin
dispatch
django.contrib.auth.mixins.AccessMixin
login_url
permission_denied_message
raise_exception
redirect_field_name
get_login_url
get_permission_denied_message
get_redirect_field_name
handle_no_permission
vkk.generic.views.CustomDetailView
action_options
django.views.generic.detail.SingleObjectTemplateResponseMixin
template_name_field
template_name_suffix
get_template_names
django.views.generic.base.TemplateResponseMixin
template_engine
response_class
content_type
render_to_response
django.views.generic.detail.BaseDetailView
get
django.views.generic.detail.SingleObjectMixin
queryset
slug_field
context_object_name
slug_url_kwarg
pk_url_kwarg
query_pk_and_slug
get_object
get_queryset
get_slug_field
get_context_object_name
django.views.generic.base.ContextMixin
extra_context
class AccountingPeriodDetailNoDepartmentView(vkk.workhours.accounting.views.AccountingDetailView):
260class AccountingPeriodDetailNoDepartmentView(AccountingDetailView):
261    """
262    A class based `View` providing an overview of projects which do not belong to any
263    department for the given period.
264    """
265    model = Period
266    fields = ['start', 'end', 'dead_line', 'dead_line_final']
267    template_name = "vkk/workhours/accounting/period/projects.html"
268
269    def get_context_data(self, **kwargs):
270        context = super().get_context_data(**kwargs)
271        projects_open = Project.objects.raw(" \
272            WITH selected_period AS ( \
273                SELECT \
274                    vkk_period.id AS period_id, \
275                    vkk_period.start AS period_start, \
276                    vkk_period.end AS period_end \
277                FROM vkk_period \
278                WHERE vkk_period.id = %s \
279            ), \
280            filtered_projects AS ( \
281                SELECT \
282                    selected_period.period_id, \
283                    vkk_project.id, \
284                    vkk_project.invoice_number, \
285                    vkk_project.name, \
286                    vkk_project.contractor, \
287                    vkk_project.start, \
288                    vkk_project.end, \
289                    vkk_project.department_id \
290                FROM vkk_project, selected_period \
291                WHERE  \
292                    selected_period.period_end >= vkk_project.start  \
293                    AND selected_period.period_start <= vkk_project.end \
294                    AND vkk_project.department_id IS NULL \
295            ), \
296            closures AS ( \
297                SELECT \
298                    vkk_periodclosure.project_assignment_id, \
299                    vkk_periodclosure.is_closed_manager \
300                FROM  \
301                    vkk_periodclosure JOIN selected_period \
302                    ON vkk_periodclosure.period_id = selected_period.period_id \
303            ), \
304            not_closed_assignments AS ( \
305                SELECT \
306                    vkk_projectassignment.id AS assignment_id, \
307                    vkk_projectassignment.project_id \
308                FROM \
309                    vkk_projectassignment LEFT JOIN closures \
310                    ON vkk_projectassignment.id = closures.project_assignment_id \
311                WHERE \
312                    closures.is_closed_manager IS NULL \
313                    OR closures.is_closed_manager = FALSE \
314            ) \
315            SELECT \
316                p.id, \
317                p.invoice_number, \
318                p.name, \
319                p.contractor, \
320                p.start, \
321                p.end, \
322                p.department_id \
323            FROM \
324                filtered_projects p \
325            WHERE  \
326                EXISTS ( \
327                    SELECT assignment_id \
328                    FROM not_closed_assignments c \
329                    WHERE  \
330                        c.project_id = p.id \
331                ) \
332            ORDER BY p.invoice_number;",
333            [self.kwargs['pk']]
334        )
335
336        projects_closed = Project.objects.raw(" \
337            WITH selected_period AS ( \
338                SELECT \
339                    vkk_period.id AS period_id, \
340                    vkk_period.start AS period_start, \
341                    vkk_period.end AS period_end \
342                FROM vkk_period \
343                WHERE vkk_period.id = %s \
344            ), \
345            filtered_projects AS ( \
346                SELECT \
347                    selected_period.period_id, \
348                    vkk_project.id, \
349                    vkk_project.invoice_number, \
350                    vkk_project.name, \
351                    vkk_project.contractor, \
352                    vkk_project.start, \
353                    vkk_project.end, \
354                    vkk_project.department_id, \
355                    selected_period.period_start, \
356                    selected_period.period_end \
357                FROM vkk_project, selected_period \
358                WHERE  \
359                    selected_period.period_end >= vkk_project.start  \
360                    AND selected_period.period_start <= vkk_project.end \
361                    AND vkk_project.department_id IS NULL \
362            ), \
363            closures AS ( \
364                SELECT \
365                    vkk_periodclosure.project_assignment_id, \
366                    vkk_periodclosure.is_closed_manager \
367                FROM  \
368                    vkk_periodclosure JOIN selected_period \
369                    ON vkk_periodclosure.period_id = selected_period.period_id \
370            ), \
371            not_closed_assignments AS ( \
372                SELECT \
373                    vkk_projectassignment.id AS assignment_id, \
374                    vkk_projectassignment.project_id \
375                FROM \
376                    vkk_projectassignment LEFT JOIN closures \
377                    ON vkk_projectassignment.id = closures.project_assignment_id \
378                WHERE \
379                    closures.is_closed_manager IS NULL \
380                    OR closures.is_closed_manager = FALSE \
381            ) \
382            SELECT \
383                p.id, \
384                p.invoice_number, \
385                p.name, \
386                p.contractor, \
387                p.start, \
388                p.end, \
389                p.department_id, \
390                CASE  \
391                    WHEN EXISTS ( \
392                        SELECT 1 \
393                            FROM vkk_receipt \
394                            WHERE \
395                                p.id = vkk_receipt.project_id \
396                                AND p.period_start = vkk_receipt.start \
397                                AND p.period_end = vkk_receipt.end \
398                    ) THEN TRUE \
399                    ELSE FALSE \
400                END AS exists_receipt \
401            FROM \
402                filtered_projects p \
403            WHERE  \
404                NOT EXISTS ( \
405                    SELECT assignment_id \
406                    FROM not_closed_assignments c \
407                    WHERE  \
408                        c.project_id = p.id \
409                ) \
410            ORDER BY p.invoice_number;",
411            [self.kwargs['pk']]
412        )
413
414        context["department"] = None
415        context["projects_open"] = projects_open
416        context["projects_closed"] = projects_closed
417        return context

A class based View providing an overview of projects which do not belong to any department for the given period.

model = <class 'vkk.workhours.models.Period'>
fields = ['start', 'end', 'dead_line', 'dead_line_final']
template_name = 'vkk/workhours/accounting/period/projects.html'
def get_context_data(self, **kwargs):
269    def get_context_data(self, **kwargs):
270        context = super().get_context_data(**kwargs)
271        projects_open = Project.objects.raw(" \
272            WITH selected_period AS ( \
273                SELECT \
274                    vkk_period.id AS period_id, \
275                    vkk_period.start AS period_start, \
276                    vkk_period.end AS period_end \
277                FROM vkk_period \
278                WHERE vkk_period.id = %s \
279            ), \
280            filtered_projects AS ( \
281                SELECT \
282                    selected_period.period_id, \
283                    vkk_project.id, \
284                    vkk_project.invoice_number, \
285                    vkk_project.name, \
286                    vkk_project.contractor, \
287                    vkk_project.start, \
288                    vkk_project.end, \
289                    vkk_project.department_id \
290                FROM vkk_project, selected_period \
291                WHERE  \
292                    selected_period.period_end >= vkk_project.start  \
293                    AND selected_period.period_start <= vkk_project.end \
294                    AND vkk_project.department_id IS NULL \
295            ), \
296            closures AS ( \
297                SELECT \
298                    vkk_periodclosure.project_assignment_id, \
299                    vkk_periodclosure.is_closed_manager \
300                FROM  \
301                    vkk_periodclosure JOIN selected_period \
302                    ON vkk_periodclosure.period_id = selected_period.period_id \
303            ), \
304            not_closed_assignments AS ( \
305                SELECT \
306                    vkk_projectassignment.id AS assignment_id, \
307                    vkk_projectassignment.project_id \
308                FROM \
309                    vkk_projectassignment LEFT JOIN closures \
310                    ON vkk_projectassignment.id = closures.project_assignment_id \
311                WHERE \
312                    closures.is_closed_manager IS NULL \
313                    OR closures.is_closed_manager = FALSE \
314            ) \
315            SELECT \
316                p.id, \
317                p.invoice_number, \
318                p.name, \
319                p.contractor, \
320                p.start, \
321                p.end, \
322                p.department_id \
323            FROM \
324                filtered_projects p \
325            WHERE  \
326                EXISTS ( \
327                    SELECT assignment_id \
328                    FROM not_closed_assignments c \
329                    WHERE  \
330                        c.project_id = p.id \
331                ) \
332            ORDER BY p.invoice_number;",
333            [self.kwargs['pk']]
334        )
335
336        projects_closed = Project.objects.raw(" \
337            WITH selected_period AS ( \
338                SELECT \
339                    vkk_period.id AS period_id, \
340                    vkk_period.start AS period_start, \
341                    vkk_period.end AS period_end \
342                FROM vkk_period \
343                WHERE vkk_period.id = %s \
344            ), \
345            filtered_projects AS ( \
346                SELECT \
347                    selected_period.period_id, \
348                    vkk_project.id, \
349                    vkk_project.invoice_number, \
350                    vkk_project.name, \
351                    vkk_project.contractor, \
352                    vkk_project.start, \
353                    vkk_project.end, \
354                    vkk_project.department_id, \
355                    selected_period.period_start, \
356                    selected_period.period_end \
357                FROM vkk_project, selected_period \
358                WHERE  \
359                    selected_period.period_end >= vkk_project.start  \
360                    AND selected_period.period_start <= vkk_project.end \
361                    AND vkk_project.department_id IS NULL \
362            ), \
363            closures AS ( \
364                SELECT \
365                    vkk_periodclosure.project_assignment_id, \
366                    vkk_periodclosure.is_closed_manager \
367                FROM  \
368                    vkk_periodclosure JOIN selected_period \
369                    ON vkk_periodclosure.period_id = selected_period.period_id \
370            ), \
371            not_closed_assignments AS ( \
372                SELECT \
373                    vkk_projectassignment.id AS assignment_id, \
374                    vkk_projectassignment.project_id \
375                FROM \
376                    vkk_projectassignment LEFT JOIN closures \
377                    ON vkk_projectassignment.id = closures.project_assignment_id \
378                WHERE \
379                    closures.is_closed_manager IS NULL \
380                    OR closures.is_closed_manager = FALSE \
381            ) \
382            SELECT \
383                p.id, \
384                p.invoice_number, \
385                p.name, \
386                p.contractor, \
387                p.start, \
388                p.end, \
389                p.department_id, \
390                CASE  \
391                    WHEN EXISTS ( \
392                        SELECT 1 \
393                            FROM vkk_receipt \
394                            WHERE \
395                                p.id = vkk_receipt.project_id \
396                                AND p.period_start = vkk_receipt.start \
397                                AND p.period_end = vkk_receipt.end \
398                    ) THEN TRUE \
399                    ELSE FALSE \
400                END AS exists_receipt \
401            FROM \
402                filtered_projects p \
403            WHERE  \
404                NOT EXISTS ( \
405                    SELECT assignment_id \
406                    FROM not_closed_assignments c \
407                    WHERE  \
408                        c.project_id = p.id \
409                ) \
410            ORDER BY p.invoice_number;",
411            [self.kwargs['pk']]
412        )
413
414        context["department"] = None
415        context["projects_open"] = projects_open
416        context["projects_closed"] = projects_closed
417        return context

Insert the single object into the context dict.

Inherited Members
django.views.generic.base.View
View
http_method_names
view_is_async
as_view
setup
http_method_not_allowed
options
vkk.workhours.accounting.mixins.AccountantRequiredMixin
dispatch
django.contrib.auth.mixins.AccessMixin
login_url
permission_denied_message
raise_exception
redirect_field_name
get_login_url
get_permission_denied_message
get_redirect_field_name
handle_no_permission
vkk.generic.views.CustomDetailView
action_options
django.views.generic.detail.SingleObjectTemplateResponseMixin
template_name_field
template_name_suffix
get_template_names
django.views.generic.base.TemplateResponseMixin
template_engine
response_class
content_type
render_to_response
django.views.generic.detail.BaseDetailView
get
django.views.generic.detail.SingleObjectMixin
queryset
slug_field
context_object_name
slug_url_kwarg
pk_url_kwarg
query_pk_and_slug
get_object
get_queryset
get_slug_field
get_context_object_name
django.views.generic.base.ContextMixin
extra_context