1196 lines
47 KiB
Python
1196 lines
47 KiB
Python
# Copyright The IETF Trust 2013-2022, All Rights Reserved
|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
from collections import defaultdict
|
|
import datetime
|
|
import io
|
|
import os
|
|
import re
|
|
from tempfile import mkstemp
|
|
|
|
from django.http import Http404
|
|
from django.db.models import F, Prefetch
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
from django.contrib.auth.models import AnonymousUser
|
|
from django.urls import reverse
|
|
from django.shortcuts import get_object_or_404
|
|
from django.template.loader import render_to_string
|
|
from django.utils import timezone
|
|
|
|
import debug # pyflakes:ignore
|
|
|
|
from ietf.doc.models import Document
|
|
from ietf.group.utils import can_manage_some_groups, can_manage_group
|
|
from ietf.ietfauth.utils import has_role, user_is_person
|
|
from ietf.liaisons.utils import get_person_for_user
|
|
from ietf.mailtrigger.utils import gather_address_lists
|
|
from ietf.person.models import Person
|
|
from ietf.meeting.models import Meeting, Schedule, TimeSlot, SchedTimeSessAssignment, ImportantDate, SchedulingEvent, Session
|
|
from ietf.meeting.utils import session_requested_by, add_event_info_to_session_qs
|
|
from ietf.name.models import ImportantDateName, SessionPurposeName
|
|
from ietf.utils import log, meetecho
|
|
from ietf.utils.mail import send_mail
|
|
from ietf.utils.pipe import pipe
|
|
from ietf.utils.text import xslugify
|
|
|
|
|
|
def get_meeting(num=None, type_in=('ietf',), days=28):
|
|
meetings = Meeting.objects
|
|
if type_in is not None:
|
|
meetings = meetings.filter(type__in=type_in)
|
|
if num is None:
|
|
meetings = meetings.filter(
|
|
date__gte=timezone.now() - datetime.timedelta(days=days)
|
|
).order_by('date')
|
|
else:
|
|
meetings = meetings.filter(number=num)
|
|
if meetings.exists():
|
|
return meetings.first()
|
|
else:
|
|
raise Http404("No such meeting found: %s" % num)
|
|
|
|
def get_current_ietf_meeting():
|
|
meetings = Meeting.objects.filter(type='ietf',date__gte=timezone.now()-datetime.timedelta(days=31)).order_by('date')
|
|
return meetings.first()
|
|
|
|
def get_current_ietf_meeting_num():
|
|
cur = get_current_ietf_meeting()
|
|
return cur.number if cur else None
|
|
|
|
def get_ietf_meeting(num=None):
|
|
if num:
|
|
meeting = Meeting.objects.filter(type='ietf', number=num).first()
|
|
else:
|
|
meeting = get_current_ietf_meeting()
|
|
return meeting
|
|
|
|
def get_schedule(meeting, name=None):
|
|
if name is None:
|
|
schedule = meeting.schedule
|
|
else:
|
|
schedule = get_object_or_404(meeting.schedule_set, name=name)
|
|
return schedule
|
|
|
|
# seems this belongs in ietf/person/utils.py?
|
|
def get_person_by_email(email):
|
|
# email == None may actually match people who haven't set an email!
|
|
if email is None:
|
|
return None
|
|
return Person.objects.filter(email__address=email).distinct().first()
|
|
|
|
def get_schedule_by_name(meeting, owner, name):
|
|
if owner is not None:
|
|
return meeting.schedule_set.filter(owner = owner, name = name).first()
|
|
else:
|
|
return meeting.schedule_set.filter(name = name).first()
|
|
|
|
def preprocess_assignments_for_agenda(assignments_queryset, meeting, extra_prefetches=()):
|
|
"""Add computed properties to assignments
|
|
|
|
For each assignment a, adds
|
|
a.start_timestamp
|
|
a.end_timestamp
|
|
a.session.rescheduled_to (if rescheduled)
|
|
a.session.prefetched_active_materials
|
|
a.session.order_number
|
|
"""
|
|
assignments_queryset = assignments_queryset.prefetch_related(
|
|
'timeslot', 'timeslot__type', 'timeslot__meeting',
|
|
'timeslot__location', 'timeslot__location__floorplan', 'timeslot__location__urlresource_set',
|
|
Prefetch(
|
|
"session",
|
|
queryset=add_event_info_to_session_qs(Session.objects.all().prefetch_related(
|
|
'group', 'group__charter', 'group__charter__group',
|
|
Prefetch('materials',
|
|
queryset=Document.objects.exclude(states__type=F("type"), states__slug='deleted').order_by('presentations__order').prefetch_related('states'),
|
|
to_attr='prefetched_active_materials'
|
|
)
|
|
))
|
|
),
|
|
*extra_prefetches
|
|
)
|
|
|
|
|
|
# removed list(); it was consuming a very large amount of processor time
|
|
# assignments = list(assignments_queryset) # make sure we're set in stone
|
|
assignments = assignments_queryset
|
|
|
|
# replace groups with historic counterparts
|
|
groups = [ ]
|
|
for a in assignments:
|
|
if a.session:
|
|
# Ensure that all Sessions refer to the same Meeting instance so they can share the
|
|
# _groups_at_the_time() cache. The Sessions should all belong to the same meeting, but
|
|
# check before blindly assigning to meeting just in case.
|
|
if a.session.meeting.pk == meeting.pk:
|
|
a.session.meeting = meeting
|
|
a.session.order_number = a.session.order_in_meeting() if a.session.group else None
|
|
|
|
if a.session.group and a.session.group not in groups:
|
|
groups.append(a.session.group)
|
|
|
|
sessions_for_groups = defaultdict(list)
|
|
for a in assignments:
|
|
if a.session and a.session.group:
|
|
sessions_for_groups[(a.session.group, a.session.type_id)].append(a)
|
|
|
|
timeslot_by_session_pk = {a.session_id: a.timeslot for a in assignments}
|
|
|
|
for a in assignments:
|
|
|
|
if a.session.current_status == 'resched':
|
|
a.session.rescheduled_to = timeslot_by_session_pk.get(a.session.tombstone_for_id)
|
|
|
|
for d in a.session.prefetched_active_materials:
|
|
# make sure these are precomputed with the meeting instead
|
|
# of having to look it up
|
|
d.get_href(meeting=meeting)
|
|
d.get_versionless_href(meeting=meeting)
|
|
|
|
a.start_timestamp = int(a.timeslot.utc_start_time().timestamp())
|
|
a.end_timestamp = int(a.timeslot.utc_end_time().timestamp())
|
|
|
|
return assignments
|
|
|
|
|
|
class AgendaKeywordTool:
|
|
"""Base class for agenda keyword-related organizers
|
|
|
|
The purpose of this class is to hold utility methods and data needed by keyword generation
|
|
helper classes. It ensures consistency of, e.g., definitions of when to use legacy keywords or what
|
|
timeslot types should be used to define filters.
|
|
"""
|
|
def __init__(self, *, assignments=None, sessions=None):
|
|
# n.b., single star argument means only keyword parameters are allowed when calling constructor
|
|
if assignments is not None and sessions is None:
|
|
self.assignments = assignments
|
|
self.sessions = [a.session for a in self.assignments if a.session]
|
|
elif sessions is not None and assignments is None:
|
|
self.assignments = None
|
|
self.sessions = sessions
|
|
else:
|
|
raise RuntimeError('Exactly one of assignments or sessions must be specified')
|
|
|
|
self.meeting = self.sessions[0].meeting if len(self.sessions) > 0 else None
|
|
|
|
def _use_legacy_keywords(self):
|
|
"""Should legacy keyword handling be used for this meeting?"""
|
|
# Only IETF meetings need legacy handling. These are identified
|
|
# by having a purely numeric meeting.number.
|
|
return (self.meeting is not None
|
|
and self.meeting.number.isdigit()
|
|
and int(self.meeting.number) <= settings.MEETING_LEGACY_OFFICE_HOURS_END)
|
|
|
|
# Helper methods
|
|
@staticmethod
|
|
def _get_group(s):
|
|
"""Get group of a session, handling historic groups"""
|
|
return s.group_at_the_time()
|
|
|
|
def _get_group_parent(self, s):
|
|
"""Get parent of a group or parent of a session's group, handling historic groups"""
|
|
if isinstance(s, Session):
|
|
return s.group_parent_at_the_time()
|
|
else:
|
|
# Assumption is that s is a group...
|
|
return s and s.parent
|
|
|
|
def _purpose_keyword(self, purpose):
|
|
"""Get the keyword corresponding to a session purpose"""
|
|
return purpose.slug.lower()
|
|
|
|
def _group_keyword(self, group):
|
|
"""Get the keyword corresponding to a session group"""
|
|
return group.acronym.lower()
|
|
|
|
def _session_name_keyword(self, session):
|
|
"""Get the keyword identifying a session by name"""
|
|
return xslugify(session.name) if session.name else None
|
|
|
|
@property
|
|
def filterable_purposes(self):
|
|
return SessionPurposeName.objects.exclude(slug='none').order_by('name')
|
|
|
|
|
|
class AgendaFilterOrganizer(AgendaKeywordTool):
|
|
"""Helper class to organize agenda filters given a list of assignments or sessions
|
|
|
|
Either assignments or sessions must be specified (but not both). Keywords should be applied
|
|
to these items before calling either of the 'get_' methods, otherwise some special filters
|
|
may not be included (e.g., 'BoF' or 'Plenary'). If the session's group has a GroupHistory
|
|
object active at the time of the start of the session's meeting, and/or the session's group
|
|
parent had an active GroupHistory object active at the time, these will be used instead of
|
|
the group or parent.
|
|
|
|
The organizer will process its inputs once, when one of its get_ methods is first called.
|
|
|
|
Terminology:
|
|
* column: group of related buttons, usually with a heading button.
|
|
* heading: button at the top of a column, e.g. an area. Has a keyword that applies to all in its column.
|
|
* category: a set of columns displayed as separate from other categories
|
|
* group filters: filters whose keywords derive from the group owning the session, such as for working groups
|
|
* non-group filters: filters whose keywords come from something other than a session's group
|
|
* special filters: group filters of type "special" that have no heading, end up in the catch-all column
|
|
* extra filters: ad hoc filters created based on the extra_labels list, go in the catch-all column
|
|
* catch-all column: column with no heading where extra filters and special filters are gathered
|
|
"""
|
|
# group acronyms in this list will never be used as filter buttons
|
|
exclude_acronyms = ('iesg', 'ietf', 'secretariat')
|
|
# extra keywords to include in the no-heading column if they apply to any sessions
|
|
extra_labels = ('BoF',)
|
|
# group types whose acronyms should be word-capitalized
|
|
capitalized_group_types = ('team',)
|
|
# group types whose acronyms should be all-caps
|
|
uppercased_group_types = ('area', 'ietf', 'irtf')
|
|
# check that the group labeling sets are disjoint
|
|
assert(set(capitalized_group_types).isdisjoint(uppercased_group_types))
|
|
# group acronyms that need special handling
|
|
special_group_labels = dict(edu='EDU', iepg='IEPG')
|
|
|
|
def __init__(self, *, single_category=False, **kwargs):
|
|
super(AgendaFilterOrganizer, self).__init__(**kwargs)
|
|
self.single_category = single_category
|
|
# filled in when _organize_filters() is called
|
|
self.filter_categories = None
|
|
self.special_filters = None
|
|
if self._use_legacy_keywords():
|
|
self.extra_labels += ('Plenary',) # need this when not using session purpose
|
|
self.manual_extra_labels = set()
|
|
|
|
def add_extra_filter(self, kw):
|
|
self.manual_extra_labels.add(kw)
|
|
|
|
def get_non_area_keywords(self):
|
|
"""Get list of any 'non-area' (aka 'special') keywords
|
|
|
|
These are the keywords corresponding to the right-most, headingless button column.
|
|
"""
|
|
if self.special_filters is None:
|
|
self._organize_filters()
|
|
return [sf['keyword'] for sf in self.special_filters['children']]
|
|
|
|
def get_filter_categories(self):
|
|
"""Get a list of filter categories
|
|
|
|
If single_category is True, this will be a list with one element. Otherwise it
|
|
may have multiple elements. Each element is a list of filter columns.
|
|
"""
|
|
if self.filter_categories is None:
|
|
self._organize_filters()
|
|
return self.filter_categories
|
|
|
|
def _organize_filters(self):
|
|
"""Process inputs to construct and categorize filter lists"""
|
|
headings, special = self._group_filter_headings()
|
|
self.filter_categories = self._categorize_group_filters(headings)
|
|
|
|
# Create an additional category with non-group filters and special/extra filters
|
|
non_group_category = self._non_group_filters()
|
|
|
|
# special filters include self.extra_labels and any 'special' group filters
|
|
self.special_filters = self._extra_filters()
|
|
for g in special:
|
|
self.special_filters['children'].append(self._group_filter_entry(g))
|
|
if len(self.special_filters['children']) > 0:
|
|
self.special_filters['children'].sort(key=self._group_sort_key)
|
|
non_group_category.append(self.special_filters)
|
|
|
|
# if we have any additional filters, add them
|
|
if len(non_group_category) > 0:
|
|
if self.single_category:
|
|
# if a single category is requested, just add them to that category
|
|
self.filter_categories[0].extend(non_group_category)
|
|
else:
|
|
# otherwise add these as a separate category
|
|
self.filter_categories.append(non_group_category)
|
|
|
|
def _group_filter_headings(self):
|
|
"""Collect group-based filters
|
|
|
|
Output is a tuple (dict(group->set), set). The dict keys are groups to be used as headings
|
|
with sets of child groups as associated values. The set is 'special' groups that have no
|
|
heading group.
|
|
"""
|
|
# groups in the schedule that have a historic_parent group
|
|
groups = set(self._get_group(s) for s in self.sessions
|
|
if s
|
|
and self._get_group(s))
|
|
# Verify that we're not using the same acronym for more than one distinct group, accounting for
|
|
# the possibility that some groups are GroupHistory instances. This assertion will fail if a Group
|
|
# and GroupHistory for the same group have a different acronym - in that event, the filter will
|
|
# not match the meeting display, so we should be alerted that this has actually occurred.
|
|
log.assertion(
|
|
"len(set(getattr(g, 'group_id', g.id) for g in groups)) "
|
|
"== len(set(g.acronym for g in groups))"
|
|
)
|
|
|
|
group_parents = set(self._get_group_parent(g) for g in groups if self._get_group_parent(g))
|
|
# See above for explanation of this assertion
|
|
log.assertion(
|
|
"len(set(getattr(gp, 'group_id', gp.id) for gp in group_parents)) "
|
|
"== len(set(gp.acronym for gp in group_parents))"
|
|
)
|
|
|
|
all_groups = groups.union(group_parents)
|
|
all_groups.difference_update([g for g in all_groups if g.acronym in self.exclude_acronyms])
|
|
headings = {g: set()
|
|
for g in all_groups
|
|
if g.features.agenda_filter_type_id == 'heading'}
|
|
special = set(g for g in all_groups
|
|
if g.features.agenda_filter_type_id == 'special')
|
|
|
|
for g in groups:
|
|
if g.features.agenda_filter_type_id == 'normal':
|
|
# normal filter group with a heading parent goes in that column
|
|
p = self._get_group_parent(g)
|
|
if p in headings:
|
|
headings[p].add(g)
|
|
else:
|
|
# normal filter group with no heading parent is 'special'
|
|
special.add(g)
|
|
|
|
return headings, special
|
|
|
|
def _categorize_group_filters(self, headings):
|
|
"""Categorize the group-based filters
|
|
|
|
Returns a list of one or more categories of filter columns. When single_category is True,
|
|
it will always be only one category.
|
|
"""
|
|
area_category = [] # headings are area groups
|
|
non_area_category = [] # headings are non-area groups
|
|
|
|
for h in headings:
|
|
if h.type_id == 'area' or self.single_category:
|
|
area_category.append(self._group_filter_column(h, headings[h]))
|
|
else:
|
|
non_area_category.append(self._group_filter_column(h, headings[h]))
|
|
area_category.sort(key=self._group_sort_key)
|
|
if self.single_category:
|
|
return [area_category]
|
|
non_area_category.sort(key=self._group_sort_key)
|
|
return [area_category, non_area_category]
|
|
|
|
def _non_group_filters(self):
|
|
"""Get list of non-group filter columns
|
|
|
|
Empty columns will be omitted.
|
|
"""
|
|
if self.sessions is None:
|
|
sessions = [a.session for a in self.assignments]
|
|
else:
|
|
sessions = self.sessions
|
|
|
|
# Call legacy version for older meetings
|
|
if self._use_legacy_keywords():
|
|
return self._legacy_non_group_filters(sessions)
|
|
|
|
# Not using legacy version
|
|
filter_cols = []
|
|
for purpose in self.filterable_purposes:
|
|
if purpose.slug == 'regular':
|
|
continue
|
|
|
|
# Map label to its keyword, discarding duplicate labels.
|
|
# This does what we want as long as sessions with the same
|
|
# name and purpose belong to the same group.
|
|
sessions_by_name = {
|
|
session.name: session
|
|
for session in sessions if session.purpose == purpose
|
|
}
|
|
if len(sessions_by_name) > 0:
|
|
# keyword needs to match what's tagged in filter_keywords_for_session()
|
|
heading_kw = self._purpose_keyword(purpose)
|
|
children = []
|
|
for name, session in sessions_by_name.items():
|
|
children.append(self._filter_entry(
|
|
label=name,
|
|
keyword=self._session_name_keyword(session),
|
|
toggled_by=[self._group_keyword(session.group)] if session.group else None,
|
|
is_bof=False,
|
|
))
|
|
column = self._filter_column(
|
|
label=purpose.name,
|
|
keyword=heading_kw,
|
|
children=children,
|
|
)
|
|
filter_cols.append(column)
|
|
|
|
return filter_cols
|
|
|
|
def _legacy_non_group_filters(self, sessions):
|
|
"""Get list of non-group filters for older meetings
|
|
|
|
Returns a list of filter columns
|
|
"""
|
|
office_hours_items = set()
|
|
suffix = ' office hours'
|
|
for s in sessions:
|
|
if s.name.lower().endswith(suffix):
|
|
office_hours_items.add((s.name[:-len(suffix)].strip(), s.group))
|
|
|
|
headings = []
|
|
# currently we only do office hours
|
|
if len(office_hours_items) > 0:
|
|
column = self._filter_column(
|
|
label='Office Hours',
|
|
keyword='officehours',
|
|
children=[
|
|
self._filter_entry(
|
|
label=label,
|
|
keyword=f'{label.lower().replace(" ", "")}-officehours',
|
|
toggled_by=[self._group_keyword(group)] if group else None,
|
|
is_bof=False,
|
|
)
|
|
for label, group in sorted(office_hours_items, key=lambda item: item[0].upper())
|
|
])
|
|
headings.append(column)
|
|
return headings
|
|
|
|
def _extra_filters(self):
|
|
"""Get list of filters corresponding to self.extra_labels"""
|
|
item_source = self.assignments or self.sessions or []
|
|
candidates = set(self.extra_labels).union(self.manual_extra_labels)
|
|
return self._filter_column(
|
|
label=None,
|
|
keyword=None,
|
|
children=[
|
|
self._filter_entry(label=label, keyword=xslugify(label), toggled_by=[], is_bof=False)
|
|
for label in candidates if label in self.manual_extra_labels or any(
|
|
# Keep only those that will affect at least one session
|
|
[label.lower() in item.filter_keywords for item in item_source]
|
|
)]
|
|
)
|
|
|
|
@staticmethod
|
|
def _filter_entry(label, keyword, is_bof, toggled_by=None):
|
|
"""Construct a filter entry representation"""
|
|
# get our own copy of the list for toggled_by
|
|
if toggled_by is None:
|
|
toggled_by = []
|
|
if is_bof:
|
|
toggled_by = ['bof'] + toggled_by
|
|
return dict(
|
|
label=label,
|
|
keyword=keyword,
|
|
toggled_by=toggled_by,
|
|
is_bof=is_bof,
|
|
)
|
|
|
|
def _filter_column(self, label, keyword, children):
|
|
"""Construct a filter column given a label, keyword, and list of child entries"""
|
|
entry = self._filter_entry(label, keyword, False) # heading
|
|
entry['children'] = children
|
|
# all children should be controlled by the heading keyword
|
|
if keyword:
|
|
for child in children:
|
|
if keyword not in child['toggled_by']:
|
|
child['toggled_by'] = [keyword] + child['toggled_by']
|
|
return entry
|
|
|
|
def _group_label(self, group):
|
|
"""Generate a label for a group filter button"""
|
|
label = group.acronym
|
|
if label in self.special_group_labels:
|
|
return self.special_group_labels[label]
|
|
elif group.type_id in self.capitalized_group_types:
|
|
return label.capitalize()
|
|
elif group.type_id in self.uppercased_group_types:
|
|
return label.upper()
|
|
return label
|
|
|
|
def _group_filter_entry(self, group):
|
|
"""Construct a filter_entry for a group filter button"""
|
|
return self._filter_entry(
|
|
label=self._group_label(group),
|
|
keyword=self._group_keyword(group),
|
|
toggled_by=[self._group_keyword(group.parent)] if group.parent else None,
|
|
is_bof=group.is_bof(),
|
|
)
|
|
|
|
def _group_filter_column(self, heading, children):
|
|
"""Construct a filter column given a heading group and a list of its child groups"""
|
|
return self._filter_column(
|
|
label=None if heading is None else self._group_label(heading),
|
|
keyword=self._group_keyword(heading),
|
|
children=sorted([self._group_filter_entry(g) for g in children], key=self._group_sort_key),
|
|
)
|
|
|
|
@staticmethod
|
|
def _group_sort_key(g):
|
|
return 'zzzzzzzz' if g is None else g['label'].upper() # sort blank to the end
|
|
|
|
|
|
class AgendaKeywordTagger(AgendaKeywordTool):
|
|
"""Class for applying keywords to agenda timeslot assignments.
|
|
|
|
This is the other side of the agenda filtering: AgendaFilterOrganizer generates the
|
|
filter buttons, this applies keywords to the entries being filtered.
|
|
"""
|
|
def apply(self):
|
|
"""Apply tags to sessions / assignments"""
|
|
if self.assignments is not None:
|
|
self._tag_assignments_with_filter_keywords()
|
|
else:
|
|
self._tag_sessions_with_filter_keywords()
|
|
|
|
def apply_session_keywords(self):
|
|
"""Tag each item with its session-specific keyword"""
|
|
if self.assignments is not None:
|
|
for a in self.assignments:
|
|
a.session_keyword = self.filter_keyword_for_specific_session(a.session)
|
|
else:
|
|
for s in self.sessions:
|
|
s.session_keyword = self.filter_keyword_for_specific_session(s)
|
|
|
|
def _is_regular_agenda_filter_group(self, group):
|
|
"""Should this group appear in the 'regular' agenda filter button lists?"""
|
|
parent = self._get_group_parent(group)
|
|
return (
|
|
group.features.agenda_filter_type_id == 'normal'
|
|
and parent
|
|
and parent.features.agenda_filter_type_id == 'heading'
|
|
)
|
|
|
|
def _tag_assignments_with_filter_keywords(self):
|
|
"""Add keywords for agenda filtering
|
|
|
|
Keywords are all lower case.
|
|
"""
|
|
for a in self.assignments:
|
|
a.filter_keywords = self._filter_keywords_for_assignment(a)
|
|
a.filter_keywords = sorted(list(a.filter_keywords))
|
|
|
|
def _tag_sessions_with_filter_keywords(self):
|
|
for s in self.sessions:
|
|
s.filter_keywords = self._filter_keywords_for_session(s)
|
|
s.filter_keywords = sorted(list(s.filter_keywords))
|
|
|
|
@staticmethod
|
|
def _legacy_extra_session_keywords(session):
|
|
"""Get extra keywords for a session at a legacy meeting"""
|
|
extra = []
|
|
if session.type_id == 'plenary':
|
|
extra.append('plenary')
|
|
office_hours_match = re.match(r'^ *\w+(?: +\w+)* +office hours *$', session.name, re.IGNORECASE)
|
|
if office_hours_match is not None:
|
|
suffix = 'officehours'
|
|
extra.extend([
|
|
'officehours',
|
|
session.name.lower().replace(' ', '')[:-len(suffix)] + '-officehours',
|
|
])
|
|
return extra
|
|
|
|
def _filter_keywords_for_session(self, session):
|
|
keywords = set()
|
|
if session.purpose in self.filterable_purposes:
|
|
keywords.add(self._purpose_keyword(session.purpose))
|
|
|
|
group = self._get_group(session)
|
|
if group is not None:
|
|
if group.state_id == 'bof':
|
|
keywords.add('bof')
|
|
keywords.add(self._group_keyword(group))
|
|
specific_kw = self.filter_keyword_for_specific_session(session)
|
|
if specific_kw is not None:
|
|
keywords.add(specific_kw)
|
|
|
|
kw = self._session_name_keyword(session)
|
|
if kw:
|
|
keywords.add(kw)
|
|
|
|
# Only sessions belonging to "regular" groups should respond to the
|
|
# parent group filter keyword (often the 'area'). This must match
|
|
# the test used by the agenda() view to decide whether a group
|
|
# gets an area or non-area filter button.
|
|
if self._is_regular_agenda_filter_group(group):
|
|
area = self._get_group_parent(group)
|
|
if area is not None:
|
|
keywords.add(self._group_keyword(area))
|
|
|
|
if self._use_legacy_keywords():
|
|
keywords.update(self._legacy_extra_session_keywords(session))
|
|
|
|
return sorted(keywords)
|
|
|
|
def _filter_keywords_for_assignment(self, assignment):
|
|
keywords = self._filter_keywords_for_session(assignment.session)
|
|
return sorted(keywords)
|
|
|
|
def filter_keyword_for_specific_session(self, session):
|
|
"""Get keyword that identifies a specific session
|
|
|
|
Returns None if the session cannot be selected individually.
|
|
"""
|
|
group = self._get_group(session)
|
|
if group is None:
|
|
return None
|
|
kw = self._group_keyword(group) # start with this
|
|
token = session.docname_token_only_for_multiple()
|
|
return kw if token is None else '{}-{}'.format(kw, token)
|
|
|
|
|
|
def read_session_file(type, num, doc):
|
|
# XXXX FIXME: the path fragment in the code below should be moved to
|
|
# settings.py. The *_PATH settings should be generalized to format()
|
|
# style python format, something like this:
|
|
# DOC_PATH_FORMAT = { "agenda": "/foo/bar/agenda-{meeting.number}/agenda-{meeting-number}-{doc.group}*", }
|
|
#
|
|
# FIXME: uploaded_filename should be replaced with a function call that computes names that are fixed
|
|
path = os.path.join(settings.AGENDA_PATH, "%s/%s/%s" % (num, type, doc.uploaded_filename))
|
|
if doc.uploaded_filename and os.path.exists(path):
|
|
with io.open(path, 'rb') as f:
|
|
return f.read(), path
|
|
else:
|
|
return None, path
|
|
|
|
def read_agenda_file(num, doc):
|
|
return read_session_file('agenda', num, doc)
|
|
|
|
def convert_draft_to_pdf(doc_name):
|
|
inpath = os.path.join(settings.IDSUBMIT_REPOSITORY_PATH, doc_name + ".txt")
|
|
outpath = os.path.join(settings.INTERNET_DRAFT_PDF_PATH, doc_name + ".pdf")
|
|
|
|
try:
|
|
infile = io.open(inpath, "r")
|
|
except IOError:
|
|
return
|
|
|
|
t,tempname = mkstemp()
|
|
os.close(t)
|
|
tempfile = io.open(tempname, "w")
|
|
|
|
pageend = 0;
|
|
newpage = 0;
|
|
formfeed = 0;
|
|
for line in infile:
|
|
line = re.sub("\r","",line)
|
|
line = re.sub("[ \t]+$","",line)
|
|
if re.search(r"\[?[Pp]age [0-9ivx]+\]?[ \t]*$",line):
|
|
pageend=1
|
|
tempfile.write(line)
|
|
continue
|
|
if re.search("^[ \t]*\f",line):
|
|
formfeed=1
|
|
tempfile.write(line)
|
|
continue
|
|
if re.search("^ *INTERNET.DRAFT.+[0-9]+ *$",line) or re.search("^ *Internet.Draft.+[0-9]+ *$",line) or re.search("^draft-[-a-z0-9_.]+.*[0-9][0-9][0-9][0-9]$",line) or re.search("^RFC.+[0-9]+$",line):
|
|
newpage=1
|
|
if re.search("^[ \t]*$",line) and pageend and not newpage:
|
|
continue
|
|
if pageend and newpage and not formfeed:
|
|
tempfile.write("\f")
|
|
pageend=0
|
|
formfeed=0
|
|
newpage=0
|
|
tempfile.write(line)
|
|
|
|
infile.close()
|
|
tempfile.close()
|
|
t,psname = mkstemp()
|
|
os.close(t)
|
|
pipe("enscript --margins 76::76: -B -q -p "+psname + " " +tempname)
|
|
os.unlink(tempname)
|
|
pipe("ps2pdf "+psname+" "+outpath)
|
|
os.unlink(psname)
|
|
|
|
def schedule_permissions(meeting, schedule, user):
|
|
# do this in positive logic.
|
|
cansee = False
|
|
canedit = False
|
|
secretariat = False
|
|
|
|
if has_role(user, 'Secretariat'):
|
|
cansee = True
|
|
secretariat = True
|
|
# NOTE: secretariat is not superuser for edit!
|
|
elif schedule.public:
|
|
cansee = True
|
|
elif schedule.visible and has_role(user, ['Area Director', 'IAB Chair', 'IRTF Chair']):
|
|
cansee = True
|
|
|
|
if user_is_person(user, schedule.owner):
|
|
cansee = True
|
|
canedit = not schedule.is_official_record
|
|
|
|
return cansee, canedit, secretariat
|
|
|
|
|
|
# -------------------------------------------------
|
|
# Interim Meeting Helpers
|
|
# -------------------------------------------------
|
|
|
|
|
|
def can_approve_interim_request(meeting, user):
|
|
'''Returns True if the user has permissions to approve an interim meeting request'''
|
|
if not user or isinstance(user,AnonymousUser):
|
|
return False
|
|
if meeting.type.slug != 'interim':
|
|
return False
|
|
if has_role(user, 'Secretariat'):
|
|
return True
|
|
person = get_person_for_user(user)
|
|
session = meeting.session_set.first()
|
|
if not session:
|
|
return False
|
|
group = session.group
|
|
if group.type.slug in ['wg','ag']:
|
|
if group.parent.role_set.filter(name='ad', person=person) or group.role_set.filter(name='ad', person=person):
|
|
return True
|
|
if group.type.slug in ['rg','rag'] and group.parent.role_set.filter(name='chair', person=person):
|
|
return True
|
|
if group.type.slug == 'program':
|
|
if person.role_set.filter(group__acronym='iab', name='member'):
|
|
return True
|
|
return False
|
|
|
|
|
|
def can_edit_interim_request(meeting, user):
|
|
'''Returns True if the user can edit the interim meeting request'''
|
|
if meeting.type.slug != 'interim':
|
|
return False
|
|
if has_role(user, 'Secretariat'): # Consider removing - can_manage_group should handle this
|
|
return True
|
|
session = meeting.session_set.first()
|
|
if not session:
|
|
return False
|
|
group = session.group
|
|
if can_manage_group(user, group):
|
|
return True
|
|
elif can_approve_interim_request(meeting, user):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def can_request_interim_meeting(user):
|
|
return can_manage_some_groups(user)
|
|
|
|
def can_view_interim_request(meeting, user):
|
|
'''Returns True if the user can see the pending interim request in the pending interim view'''
|
|
if meeting.type.slug != 'interim':
|
|
return False
|
|
session = meeting.session_set.first()
|
|
if not session:
|
|
return False
|
|
group = session.group
|
|
return can_manage_group(user, group)
|
|
|
|
|
|
def create_interim_meeting(group, date, city='', country='', timezone='UTC',
|
|
person=None):
|
|
"""Helper function to create interim meeting and associated schedule"""
|
|
if not person:
|
|
person = Person.objects.get(name='(System)')
|
|
number = get_next_interim_number(group.acronym, date)
|
|
meeting = Meeting.objects.create(
|
|
number=number,
|
|
type_id='interim',
|
|
date=date,
|
|
days=1,
|
|
city=city,
|
|
country=country,
|
|
time_zone=timezone)
|
|
schedule = Schedule.objects.create(
|
|
meeting=meeting,
|
|
owner=person,
|
|
visible=True,
|
|
public=True)
|
|
meeting.schedule = schedule
|
|
meeting.save()
|
|
return meeting
|
|
|
|
|
|
def get_announcement_initial(meeting, is_change=False):
|
|
'''Returns a dictionary suitable to initialize an InterimAnnouncementForm
|
|
(Message ModelForm)'''
|
|
group = meeting.session_set.first().group
|
|
in_person = bool(meeting.city)
|
|
initial = {}
|
|
addrs = gather_address_lists('interim_announced',group=group).as_strings()
|
|
initial['to'] = addrs.to
|
|
initial['cc'] = addrs.cc
|
|
initial['frm'] = settings.INTERIM_ANNOUNCE_FROM_EMAIL_PROGRAM if group.type_id=='program' else settings.INTERIM_ANNOUNCE_FROM_EMAIL_DEFAULT
|
|
if in_person:
|
|
desc = 'Interim'
|
|
else:
|
|
desc = 'Virtual'
|
|
if is_change:
|
|
change = ' CHANGED'
|
|
else:
|
|
change = ''
|
|
type = group.type.slug.upper()
|
|
if group.type.slug == 'wg' and group.state.slug == 'bof':
|
|
type = 'BOF'
|
|
|
|
assignments = SchedTimeSessAssignment.objects.filter(
|
|
schedule__in=[meeting.schedule, meeting.schedule.base if meeting.schedule else None],
|
|
session__in=meeting.session_set.not_canceled()
|
|
).order_by('timeslot__time')
|
|
|
|
initial['subject'] = '{name} ({acronym}) {type} {desc} Meeting: {date}{change}'.format(
|
|
name=group.name,
|
|
acronym=group.acronym,
|
|
type=type,
|
|
desc=desc,
|
|
date=meeting.date,
|
|
change=change)
|
|
body = render_to_string('meeting/interim_announcement.txt', locals() | {"settings": settings})
|
|
initial['body'] = body
|
|
return initial
|
|
|
|
|
|
def get_earliest_session_date(formset):
|
|
'''Return earliest date from InterimSession Formset'''
|
|
return sorted([f.cleaned_data['date'] for f in formset.forms if f.cleaned_data.get('date')])[0]
|
|
|
|
|
|
def is_interim_meeting_approved(meeting):
|
|
return add_event_info_to_session_qs(meeting.session_set.all()).first().current_status == 'apprw'
|
|
|
|
def get_next_interim_number(acronym,date):
|
|
'''
|
|
This function takes a group acronym and date object and returns the next number
|
|
to use for an interim meeting. The format is interim-[year]-[acronym]-[01-99]
|
|
'''
|
|
base = 'interim-%s-%s-' % (date.year, acronym)
|
|
# can't use count() to calculate the next number in case one was deleted
|
|
meetings = Meeting.objects.filter(type='interim', number__startswith=base)
|
|
if meetings:
|
|
serial = sorted([ int(x.number.split('-')[-1]) for x in meetings ])[-1]
|
|
else:
|
|
serial = 0
|
|
return "%s%02d" % (base, serial+1)
|
|
|
|
def get_next_agenda_name(meeting):
|
|
"""Returns the next name to use for an agenda document for *meeting*"""
|
|
group = meeting.session_set.first().group
|
|
documents = Document.objects.filter(type='agenda', session__meeting=meeting)
|
|
if documents:
|
|
sequences = [int(d.name.split('-')[-1]) for d in documents]
|
|
last_sequence = sorted(sequences)[-1]
|
|
else:
|
|
last_sequence = 0
|
|
return 'agenda-{meeting}-{group}-{sequence}'.format(
|
|
meeting=meeting.number,
|
|
group=group.acronym,
|
|
sequence=str(last_sequence + 1).zfill(2))
|
|
|
|
|
|
def make_materials_directories(meeting):
|
|
'''
|
|
This function takes a meeting object and creates the appropriate materials directories
|
|
'''
|
|
path = meeting.get_materials_path()
|
|
# Default umask is 0x022, meaning strip write permission for group and others.
|
|
# Change this temporarily to 0x0, to keep write permission for group and others.
|
|
# (WHY??) (Note: this code is old -- was present already when the secretariat code
|
|
# was merged with the regular datatracker code; then in secr/proceedings/views.py
|
|
# in make_directories())
|
|
saved_umask = os.umask(0)
|
|
for leaf in ('slides','agenda','minutes', 'narrativeminutes', 'id','rfc','bluesheets'):
|
|
target = os.path.join(path,leaf)
|
|
if not os.path.exists(target):
|
|
os.makedirs(target)
|
|
os.umask(saved_umask)
|
|
|
|
|
|
def send_interim_approval_request(meetings):
|
|
"""Sends an email to the secretariat, group chairs, and responsible area
|
|
director or the IRTF chair noting that approval has been requested for a
|
|
new interim meeting. Takes a list of one or more meetings."""
|
|
first_session = meetings[0].session_set.first()
|
|
group = first_session.group
|
|
requester = session_requested_by(first_session)
|
|
(to_email, cc_list) = gather_address_lists('session_requested',group=group,person=requester)
|
|
from_email = (settings.SESSION_REQUEST_FROM_EMAIL)
|
|
subject = '{group} - New Interim Meeting Request'.format(group=group.acronym)
|
|
template = 'meeting/interim_approval_request.txt'
|
|
approval_urls = []
|
|
for meeting in meetings:
|
|
url = settings.IDTRACKER_BASE_URL + reverse('ietf.meeting.views.interim_request_details', kwargs={'number': meeting.number})
|
|
approval_urls.append(url)
|
|
if len(meetings) > 1:
|
|
is_series = True
|
|
else:
|
|
is_series = False
|
|
approver_set = set()
|
|
for authrole in group.features.groupman_authroles: # NOTE: This makes an assumption that the authroles are exactly the set of approvers
|
|
approver_set.add(authrole)
|
|
approvers = list(approver_set)
|
|
context = {
|
|
'group': group,
|
|
'is_series': is_series,
|
|
'meetings': meetings,
|
|
'approvers': approvers,
|
|
'requester': requester,
|
|
'approval_urls': approval_urls,
|
|
}
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc=cc_list)
|
|
|
|
def send_interim_approval(user, meeting):
|
|
"""Send an email to chairs and whoever initiated the action that resulted in approval that an interim is approved"""
|
|
first_session = meeting.session_set.first()
|
|
(to_email,cc_list) = gather_address_lists('interim_approved',group=first_session.group,person=user.person)
|
|
from_email = (settings.SESSION_REQUEST_FROM_EMAIL)
|
|
subject = f'{meeting.number} interim approved'
|
|
template = 'meeting/interim_approval.txt'
|
|
context = {
|
|
'meeting': meeting,
|
|
'group' : first_session.group,
|
|
'requester' : session_requested_by(first_session),
|
|
}
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc=cc_list)
|
|
|
|
def send_interim_announcement_request(meeting):
|
|
"""Sends an email to the secretariat that an interim meeting is ready for
|
|
announcement, includes the link to send the official announcement"""
|
|
first_session = meeting.session_set.first()
|
|
group = first_session.group
|
|
requester = session_requested_by(first_session)
|
|
(to_email, cc_list) = gather_address_lists('interim_announce_requested')
|
|
from_email = (settings.SESSION_REQUEST_FROM_EMAIL)
|
|
subject = '{group} - interim meeting ready for announcement'.format(group=group.acronym)
|
|
template = 'meeting/interim_announcement_request.txt'
|
|
announce_url = settings.IDTRACKER_BASE_URL + reverse('ietf.meeting.views.interim_request_details', kwargs={'number': meeting.number})
|
|
context = locals()
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc_list)
|
|
|
|
def send_interim_meeting_cancellation_notice(meeting):
|
|
"""Sends an email that a scheduled interim meeting has been cancelled."""
|
|
session = meeting.session_set.first()
|
|
group = session.group
|
|
(to_email, cc_list) = gather_address_lists('interim_cancelled',group=group)
|
|
from_email = settings.INTERIM_ANNOUNCE_FROM_EMAIL_PROGRAM if group.type_id=='program' else settings.INTERIM_ANNOUNCE_FROM_EMAIL_DEFAULT
|
|
subject = '{group} ({acronym}) {type} Interim Meeting Cancelled (was {date})'.format(
|
|
group=group.name,
|
|
acronym=group.acronym,
|
|
type=group.type.slug.upper(),
|
|
date=meeting.date.strftime('%Y-%m-%d'))
|
|
start_time = session.official_timeslotassignment().timeslot.time
|
|
end_time = start_time + session.requested_duration
|
|
is_multi_day = session.meeting.session_set.with_current_status().filter(current_status='sched').count() > 1
|
|
template = 'meeting/interim_meeting_cancellation_notice.txt'
|
|
context = locals()
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc=cc_list)
|
|
|
|
|
|
def send_interim_session_cancellation_notice(session):
|
|
"""Sends an email that one session of a scheduled interim meeting has been cancelled."""
|
|
group = session.group
|
|
start_time = session.official_timeslotassignment().timeslot.time
|
|
end_time = start_time + session.requested_duration
|
|
(to_email, cc_list) = gather_address_lists('interim_cancelled',group=group)
|
|
from_email = settings.INTERIM_ANNOUNCE_FROM_EMAIL_PROGRAM if group.type_id=='program' else settings.INTERIM_ANNOUNCE_FROM_EMAIL_DEFAULT
|
|
|
|
if session.name:
|
|
description = '"%s" session' % session.name
|
|
else:
|
|
description = 'interim meeting session'
|
|
|
|
subject = '{group} ({acronym}) {type} {description} cancelled (was {date})'.format(
|
|
group=group.name,
|
|
acronym=group.acronym,
|
|
type=group.type.slug.upper(),
|
|
description=description,
|
|
date=start_time.date().strftime('%Y-%m-%d'))
|
|
is_multi_day = session.meeting.session_set.with_current_status().filter(current_status='sched').count() > 1
|
|
template = 'meeting/interim_session_cancellation_notice.txt'
|
|
context = locals()
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc=cc_list)
|
|
|
|
|
|
def send_interim_minutes_reminder(meeting):
|
|
"""Sends an email reminding chairs to submit minutes of interim *meeting*"""
|
|
session = meeting.session_set.first()
|
|
group = session.group
|
|
(to_email, cc_list) = gather_address_lists('session_minutes_reminder',group=group)
|
|
from_email = 'proceedings@ietf.org'
|
|
subject = 'Action Required: Minutes from {group} ({acronym}) {type} Interim Meeting on {date}'.format(
|
|
group=group.name,
|
|
acronym=group.acronym,
|
|
type=group.type.slug.upper(),
|
|
date=meeting.date.strftime('%Y-%m-%d'))
|
|
template = 'meeting/interim_minutes_reminder.txt'
|
|
context = locals()
|
|
send_mail(None,
|
|
to_email,
|
|
from_email,
|
|
subject,
|
|
template,
|
|
context,
|
|
cc=cc_list)
|
|
|
|
|
|
def sessions_post_save(request, forms):
|
|
"""Helper function to perform various post save operations on each form of a
|
|
InterimSessionModelForm formset"""
|
|
for form in forms:
|
|
if not form.has_changed():
|
|
continue
|
|
|
|
if form.instance.pk is not None and not SchedulingEvent.objects.filter(session=form.instance).exists():
|
|
if not form.requires_approval:
|
|
status_id = 'scheda'
|
|
else:
|
|
status_id = 'apprw'
|
|
SchedulingEvent.objects.create(
|
|
session=form.instance,
|
|
status_id=status_id,
|
|
by=request.user.person,
|
|
)
|
|
|
|
update_interim_session_assignment(form)
|
|
if 'agenda' in form.changed_data:
|
|
form.save_agenda()
|
|
|
|
try:
|
|
create_interim_session_conferences(
|
|
form.instance for form in forms
|
|
if form.cleaned_data.get('remote_participation', None) == 'meetecho'
|
|
)
|
|
except RuntimeError:
|
|
messages.warning(
|
|
request,
|
|
'An error occurred while creating a Meetecho conference. The interim meeting request '
|
|
'has been created without complete remote participation information. '
|
|
'Please edit the request to add this or contact the secretariat if you require assistance.',
|
|
)
|
|
|
|
|
|
def create_interim_session_conferences(sessions):
|
|
error_occurred = False
|
|
if hasattr(settings, 'MEETECHO_API_CONFIG'): # do nothing if not configured
|
|
meetecho_manager = meetecho.ConferenceManager(settings.MEETECHO_API_CONFIG)
|
|
for session in sessions:
|
|
ts = session.official_timeslotassignment().timeslot
|
|
try:
|
|
confs = meetecho_manager.create(
|
|
group=session.group,
|
|
session_id=session.pk,
|
|
description=str(session),
|
|
start_time=ts.utc_start_time(),
|
|
duration=ts.duration,
|
|
)
|
|
except Exception as err:
|
|
log.log(f'Exception creating Meetecho conference for {session}: {err}')
|
|
confs = []
|
|
|
|
if len(confs) == 1:
|
|
session.remote_instructions = confs[0].url
|
|
session.save()
|
|
else:
|
|
error_occurred = True
|
|
if error_occurred:
|
|
raise RuntimeError('error creating meetecho conferences')
|
|
|
|
|
|
def delete_interim_session_conferences(sessions):
|
|
"""Delete Meetecho conference for the session, if any"""
|
|
if hasattr(settings, 'MEETECHO_API_CONFIG'): # do nothing if Meetecho API not configured
|
|
meetecho_manager = meetecho.ConferenceManager(settings.MEETECHO_API_CONFIG)
|
|
for session in sessions:
|
|
if session.remote_instructions:
|
|
for conference in meetecho_manager.fetch(session.group):
|
|
if conference.url == session.remote_instructions:
|
|
conference.delete()
|
|
break
|
|
|
|
|
|
def sessions_post_cancel(request, sessions):
|
|
"""Clean up after session cancellation
|
|
|
|
When this is called, the session has already been canceled, so exceptions should
|
|
not be raised.
|
|
"""
|
|
try:
|
|
delete_interim_session_conferences(sessions)
|
|
except Exception as err:
|
|
sess_pks = ', '.join(str(s.pk) for s in sessions)
|
|
log.log(f'Exception deleting Meetecho conferences for sessions [{sess_pks}]: {err}')
|
|
messages.warning(
|
|
request,
|
|
'An error occurred while cleaning up Meetecho conferences for the canceled sessions. '
|
|
'The session or sessions have been canceled, but Meetecho conferences may not have been cleaned '
|
|
'up properly.',
|
|
)
|
|
|
|
|
|
def update_interim_session_assignment(form):
|
|
"""Helper function to create / update timeslot assigned to interim session
|
|
|
|
form is an InterimSessionModelForm
|
|
|
|
Only updates timeslot time (a datetime) and duration
|
|
"""
|
|
session = form.instance
|
|
meeting = session.meeting
|
|
time = meeting.tz().localize(
|
|
datetime.datetime.combine(form.cleaned_data['date'], form.cleaned_data['time'])
|
|
)
|
|
if session.official_timeslotassignment():
|
|
slot = session.official_timeslotassignment().timeslot
|
|
if slot.time != time or slot.duration != session.requested_duration:
|
|
slot.time = time
|
|
slot.duration = session.requested_duration
|
|
slot.save()
|
|
else:
|
|
slot = TimeSlot.objects.create(
|
|
meeting=meeting,
|
|
type_id='regular',
|
|
duration=session.requested_duration,
|
|
time=time)
|
|
SchedTimeSessAssignment.objects.create(
|
|
timeslot=slot,
|
|
session=session,
|
|
schedule=meeting.schedule)
|
|
|
|
def populate_important_dates(meeting):
|
|
assert ImportantDate.objects.filter(meeting=meeting).exists() is False
|
|
assert meeting.type_id=='ietf'
|
|
for datename in ImportantDateName.objects.filter(used=True):
|
|
ImportantDate.objects.create(meeting=meeting,name=datename,date=meeting.date+datetime.timedelta(days=datename.default_offset_days))
|
|
|
|
def update_important_dates(meeting):
|
|
assert meeting.type_id=='ietf'
|
|
for datename in ImportantDateName.objects.filter(used=True):
|
|
date = meeting.date+datetime.timedelta(days=datename.default_offset_days)
|
|
d = ImportantDate.objects.filter(meeting=meeting, name=datename).first()
|
|
if d:
|
|
d.date = date
|
|
d.save()
|
|
else:
|
|
ImportantDate.objects.create(meeting=meeting, name=datename, date=date)
|