def can_adopt(user, draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES and (
not draft.stream_id or draft.stream_id
in ["ietf", "irtf"]) and draft.group.type_id == "individ":
person = get_person_for_user(user)
if not person:
return False
return is_wgchair(person) or is_rgchair(person) or is_wgdelegate(
person) or is_rgdelegate() or is_secretariat(user)
else:
return is_secretariat(user)
def set_from_field(self):
if is_secretariat(self.user):
sdos = Group.objects.filter(type="sdo", state="active")
else:
sdos = Group.objects.filter(type="sdo", state="active", role__person=self.person, role__name__in=("liaiman", "auth")).distinct()
self.fields['from_field'].choices = [('sdo_%s' % i.pk, i.name) for i in sdos.order_by("name")]
self.fields['from_field'].widget.submitter = unicode(self.person)
def liaison_approval_detail(request, object_id):
if is_secretariat(request.user):
to_approve = LiaisonDetail.objects.filter(approved=None).order_by("-submitted")
else:
person = get_person_for_user(request.user)
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
to_approve = approvable_liaison_statements(approval_codes).order_by("-submitted")
else:
to_approve = LiaisonDetail.objects.filter(approval__isnull=False, approval__approved=False, from_raw_code__in=approval_codes).order_by("-submitted_date")
if request.method=='POST' and request.POST.get('do_approval', False):
try:
liaison = to_approve.get(pk=object_id)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
liaison.approved = datetime.datetime.now()
liaison.save()
else:
approval = liaison.approval
if not approval:
approval = OutgoingLiaisonApproval.objects.create(approved=True, approval_date=datetime.datetime.now())
liaison.approval = approval
liaison.save()
else:
approval.approved=True
approval.save()
liaison.send_by_email()
except LiaisonDetail.DoesNotExist:
pass
return HttpResponseRedirect(reverse('liaison_list'))
return object_detail(request,
to_approve,
object_id=object_id,
template_name='liaisons/liaisondetail_approval_detail.html',
)
def is_chair_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
if isinstance(user, basestring):
return False
return user.is_authenticated() and bool(
Role.objects.filter(
group__acronym=stream.slug, name="chair", person__user=user))
def can_manage_writeup_of_a_document_no_state(user, document):
person = get_person_for_user(user)
if not person or not document.group:
return False
group = document.group.ietfwg
return (is_secretariat(user) or is_group_chair(person, group)
or is_area_director_for_group(person, group)
or is_group_delegate(person, group))
def can_adopt(user, draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES and (not draft.stream_id or draft.stream_id in ["ietf", "irtf"]) and draft.group.type_id == "individ":
person = get_person_for_user(user)
if not person:
return False
return is_wgchair(person) or is_rgchair(person) or is_wgdelegate(person) or is_rgdelegate() or is_secretariat(user)
else:
return is_secretariat(user)
def set_from_field(self):
if is_secretariat(self.user):
sdos = SDOs.objects.all()
else:
sdo_managed = [i.sdo for i in self.person.liaisonmanagers_set.all()]
sdo_authorized = [i.sdo for i in self.person.sdoauthorizedindividual_set.all()]
sdos = set(sdo_managed).union(sdo_authorized)
self.fields['from_field'].choices = [('sdo_%s' % i.pk, i.sdo_name) for i in sdos]
self.fields['from_field'].widget.submitter = unicode(self.person)
def can_manage_writeup_of_a_document_no_state(user, document):
person = get_person_for_user(user)
if not person or not document.group:
return False
group = document.group.ietfwg
return (is_secretariat(user) or
is_group_chair(person, group) or
is_area_director_for_group(person, group) or
is_group_delegate(person, group))
def _can_take_care(liaison, user):
if not liaison.deadline_date or liaison.action_taken:
return False
if user.is_authenticated():
if is_secretariat(user):
return True
else:
return _find_person_in_emails(liaison, get_person_for_user(user))
return False
def _can_take_care(liaison, user):
if not liaison.deadline_date or liaison.action_taken:
return False
if user.is_authenticated():
if is_secretariat(user):
return True
else:
return _find_person_in_emails(liaison, get_person_for_user(user))
return False
def set_from_field(self):
if is_secretariat(self.user):
sdos = Group.objects.filter(type="sdo", state="active")
else:
sdos = Group.objects.filter(type="sdo",
state="active",
role__person=self.person,
role__name__in=("liaiman",
"auth")).distinct()
self.fields['from_field'].choices = [('sdo_%s' % i.pk, i.name)
for i in sdos.order_by("name")]
self.fields['from_field'].widget.submitter = unicode(self.person)
def __init__(self, user, *args, **kwargs):
self.user = user
self.fake_person = None
self.person = get_person_for_user(user)
if kwargs.get('data', None):
kwargs['data'].update({'person': self.person.pk})
if is_secretariat(self.user) and 'from_fake_user' in kwargs['data'].keys():
self.fake_person = PersonOrOrgInfo.objects.get(pk=kwargs['data']['from_fake_user'])
kwargs['data'].update({'person': self.fake_person.pk})
super(LiaisonForm, self).__init__(*args, **kwargs)
self.hm = IETFHM
self.set_from_field()
self.set_replyto_field()
self.set_organization_field()
def is_authorized_in_draft_streamREDESIGN(user, draft):
if is_secretariat(user):
return True
from ietf.doc.models import Document
if not super(Document, draft).stream:
return False
# must be a chair or delegate of the stream group (or draft group)
group_req = Q(group__acronym=super(Document, draft).stream.slug)
if draft.group and super(Document, draft).stream.slug in ["ietf", "irtf"]:
group_req |= Q(group=draft.group)
return user.is_authenticated() and bool(Role.objects.filter(name__in=("chair", "secr", "delegate"), person__user=user).filter(group_req))
def liaison_approval_list(request):
if is_secretariat(request.user):
to_approve = LiaisonDetail.objects.filter(approved=None).order_by("-submitted")
else:
person = get_person_for_user(request.user)
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
to_approve = approvable_liaison_statements(approval_codes).order_by("-submitted")
else:
to_approve = LiaisonDetail.objects.filter(approval__isnull=False, approval__approved=False, from_raw_code__in=approval_codes).order_by("-submitted_date")
return object_list(request, to_approve,
allow_empty=True,
template_name='liaisons/liaisondetail_approval_list.html',
)
def set_from_field(self):
if is_secretariat(self.user):
self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
elif is_sdo_liaison_manager(self.person):
self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
all_entities = []
for i in self.hm.get_entities_for_person(self.person):
all_entities += i[1]
if all_entities:
self.fields['from_field'].widget.full_power_on = [i[0] for i in all_entities]
self.fields['from_field'].widget.reduced_to_set = ['sdo_%s' % i.sdo.pk for i in self.person.liaisonmanagers_set.all().distinct()]
else:
self.fields['from_field'].choices = self.hm.get_entities_for_person(self.person)
self.fields['from_field'].widget.submitter = unicode(self.person)
self.fieldsets[0] = ('From', ('from_field', 'replyto', 'approved'))
def set_from_field(self):
if is_secretariat(self.user):
self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
elif is_sdo_liaison_manager(self.person):
self.fields['from_field'].choices = self.hm.get_all_incoming_entities()
all_entities = []
for i in self.hm.get_entities_for_person(self.person):
all_entities += i[1]
if all_entities:
self.fields['from_field'].widget.full_power_on = [i[0] for i in all_entities]
self.fields['from_field'].widget.reduced_to_set = ['sdo_%s' % i.pk for i in liaison_manager_sdos(self.person)]
else:
self.fields['from_field'].choices = self.hm.get_entities_for_person(self.person)
self.fields['from_field'].widget.submitter = unicode(self.person)
self.fieldsets[0] = ('From', ('from_field', 'replyto', 'approved'))
def liaison_list(request):
user = request.user
can_send_outgoing = can_add_outgoing_liaison(user)
can_send_incoming = can_add_incoming_liaison(user)
can_approve = False
can_edit = False
person = get_person_for_user(request.user)
if person:
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if is_secretariat(request.user):
can_approve = LiaisonDetail.objects.filter(approved=None).order_by("-submitted").count()
else:
can_approve = approvable_liaison_statements(approval_codes).count()
else:
can_approve = LiaisonDetail.objects.filter(approval__isnull=False, approval__approved=False, from_raw_code__in=approval_codes).count()
order = request.GET.get('order_by', 'submitted_date')
plain_order = order
reverse_order = order.startswith('-')
if reverse_order:
plain_order = order[1:]
if plain_order not in ('submitted_date', 'deadline_date', 'title', 'to_body', 'from_raw_body'):
order = 'submitted_date'
reverse_order = True
plain_order = 'submitted_date'
elif plain_order in ('submitted_date', 'deadline_date'):
# Reverse order for date fields, humans find it more natural
if reverse_order:
order = plain_order
else:
order = '-%s' % plain_order
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
public_liaisons = LiaisonDetail.objects.exclude(approved=None).order_by(order)
else:
public_liaisons = LiaisonDetail.objects.filter(Q(approval__isnull=True)|Q(approval__approved=True)).order_by(order)
return object_list(request, public_liaisons,
allow_empty=True,
template_name='liaisons/liaisondetail_list.html',
extra_context={'can_manage': can_approve or can_send_incoming or can_send_outgoing,
'can_approve': can_approve,
'can_edit': can_edit,
'can_send_incoming': can_send_incoming,
'can_send_outgoing': can_send_outgoing,
plain_order: not reverse_order and '-' or None},
)
def is_authorized_in_draft_streamREDESIGN(user, draft):
if is_secretariat(user):
return True
from ietf.doc.models import Document
if not super(Document, draft).stream:
return False
# must be a chair or delegate of the stream group (or draft group)
group_req = Q(group__acronym=super(Document, draft).stream.slug)
if draft.group and super(Document, draft).stream.slug in ["ietf", "irtf"]:
group_req |= Q(group=draft.group)
return user.is_authenticated() and bool(
Role.objects.filter(name__in=("chair", "secr", "delegate"),
person__user=user).filter(group_req))
def get_info(request):
person = get_person_for_user(request.user)
to_entity_id = request.GET.get('to_entity_id', None)
from_entity_id = request.GET.get('from_entity_id', None)
result = {
'poc': [],
'cc': [],
'needs_approval': False,
'post_only': False,
'full_list': []
}
to_error = 'Invalid TO entity id'
if to_entity_id:
to_entity = IETFHM.get_entity_by_key(to_entity_id)
if to_entity:
to_error = ''
from_error = 'Invalid FROM entity id'
if from_entity_id:
from_entity = IETFHM.get_entity_by_key(from_entity_id)
if from_entity:
from_error = ''
if to_error or from_error:
result.update({'error': '\n'.join([to_error, from_error])})
else:
result.update({'error': False,
'cc': [i.email() for i in to_entity.get_cc(person=person)] +\
[i.email() for i in from_entity.get_from_cc(person=person)],
'poc': [i.email() for i in to_entity.get_poc()],
'needs_approval': from_entity.needs_approval(person=person),
'post_only': from_entity.post_only(person=person, user=request.user)})
if is_secretariat(request.user):
full_list = [(i.pk, i.email())
for i in set(from_entity.full_user_list())]
full_list.sort(lambda x, y: cmp(x[1], y[1]))
full_list = [(person.pk, person.email())] + full_list
result.update({'full_list': full_list})
json_result = simplejson.dumps(result)
return HttpResponse(json_result, mimetype='text/javascript')
def liaison_approval_detail(request, object_id):
if is_secretariat(request.user):
to_approve = LiaisonDetail.objects.filter(
approved=None).order_by("-submitted")
else:
person = get_person_for_user(request.user)
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
to_approve = approvable_liaison_statements(
approval_codes).order_by("-submitted")
else:
to_approve = LiaisonDetail.objects.filter(
approval__isnull=False,
approval__approved=False,
from_raw_code__in=approval_codes).order_by("-submitted_date")
if request.method == 'POST' and request.POST.get('do_approval', False):
try:
liaison = to_approve.get(pk=object_id)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
liaison.approved = datetime.datetime.now()
liaison.save()
else:
approval = liaison.approval
if not approval:
approval = OutgoingLiaisonApproval.objects.create(
approved=True, approval_date=datetime.datetime.now())
liaison.approval = approval
liaison.save()
else:
approval.approved = True
approval.save()
liaison.send_by_email()
except LiaisonDetail.DoesNotExist:
pass
return HttpResponseRedirect(reverse('liaison_list'))
return object_detail(
request,
to_approve,
object_id=object_id,
template_name='liaisons/liaisondetail_approval_detail.html',
)
def __init__(self, user, *args, **kwargs):
self.user = user
self.fake_person = None
self.person = get_person_for_user(user)
if kwargs.get('data', None):
if is_secretariat(
self.user) and 'from_fake_user' in kwargs['data'].keys():
self.fake_person = Person.objects.get(
pk=kwargs['data']['from_fake_user'])
kwargs['data'].update({'person': self.fake_person.pk})
else:
kwargs['data'].update({'person': self.person.pk})
self.instance = kwargs.pop("instance", None)
super(LiaisonForm, self).__init__(*args, **kwargs)
# now copy in values from instance, like a ModelForm
if self.instance:
for name, field in self.fields.iteritems():
try:
x = getattr(self.instance, name)
if name == "purpose": # proxy has a name-clash on purpose so help it
x = x.order
try:
x = x.pk # foreign keys need the .pk, not the actual object
except AttributeError:
pass
self.initial[name] = x
except AttributeError:
# we have some fields on the form that aren't in the model
pass
self.fields["purpose"].choices = [("", "---------")] + [
(str(l.order), l.name)
for l in LiaisonStatementPurposeName.objects.all()
]
self.hm = IETFHM
self.set_from_field()
self.set_replyto_field()
self.set_organization_field()
def liaison_approval_list(request):
if is_secretariat(request.user):
to_approve = LiaisonDetail.objects.filter(
approved=None).order_by("-submitted")
else:
person = get_person_for_user(request.user)
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
to_approve = approvable_liaison_statements(
approval_codes).order_by("-submitted")
else:
to_approve = LiaisonDetail.objects.filter(
approval__isnull=False,
approval__approved=False,
from_raw_code__in=approval_codes).order_by("-submitted_date")
return object_list(
request,
to_approve,
allow_empty=True,
template_name='liaisons/liaisondetail_approval_list.html',
)
def is_authorized_in_draft_stream(user, draft):
if is_secretariat(user):
return True
person = get_person_for_user(user)
if not person:
return False
streamed = get_streamed_draft(draft)
if not streamed or not streamed.stream:
return False
# Check if the person is chair of the stream
if is_chair_of_stream(user, streamed.stream):
return True
# Check if the person is delegate of the stream
if is_delegate_of_stream(user, streamed.stream):
return True
# Check if the person is chair of the related group
chairs = streamed.stream.get_chairs_for_document(draft)
if chairs and person in [i.person for i in chairs]:
return True
# Check if the person is authorized by a delegate system
delegates = streamed.stream.get_delegates_for_document(draft)
return bool(person in delegates)
def is_authorized_in_draft_stream(user, draft):
if is_secretariat(user):
return True
person = get_person_for_user(user)
if not person:
return False
streamed = get_streamed_draft(draft)
if not streamed or not streamed.stream:
return False
# Check if the person is chair of the stream
if is_chair_of_stream(user, streamed.stream):
return True
# Check if the person is delegate of the stream
if is_delegate_of_stream(user, streamed.stream):
return True
# Check if the person is chair of the related group
chairs = streamed.stream.get_chairs_for_document(draft)
if chairs and person in [i.person for i in chairs]:
return True
# Check if the person is authorized by a delegate system
delegates = streamed.stream.get_delegates_for_document(draft)
return bool(person in delegates)
def __init__(self, user, *args, **kwargs):
self.user = user
self.fake_person = None
self.person = get_person_for_user(user)
if kwargs.get('data', None):
if is_secretariat(self.user) and 'from_fake_user' in kwargs['data'].keys():
self.fake_person = Person.objects.get(pk=kwargs['data']['from_fake_user'])
kwargs['data'].update({'person': self.fake_person.pk})
else:
kwargs['data'].update({'person': self.person.pk})
self.instance = kwargs.pop("instance", None)
super(LiaisonForm, self).__init__(*args, **kwargs)
# now copy in values from instance, like a ModelForm
if self.instance:
self.initial["person"] = self.instance.from_contact.person_id if self.instance.from_contact else None
self.initial["replyto"] = self.instance.reply_to
self.initial["to_poc"] = self.instance.to_contact
self.initial["response_contact"] = self.instance.response_contact
self.initial["technical_contact"] = self.instance.technical_contact
self.initial["cc1"] = self.instance.cc
self.initial["purpose"] = self.instance.purpose.order
self.initial["deadline_date"] = self.instance.deadline
self.initial["submitted_date"] = self.instance.submitted.date() if self.instance.submitted else None
self.initial["title"] = self.instance.title
self.initial["body"] = self.instance.body
self.initial["attachments"] = self.instance.attachments.all()
self.initial["related_to"] = self.instance.related_to_id
if "approved" in self.fields:
self.initial["approved"] = bool(self.instance.approved)
self.fields["purpose"].choices = [("", "---------")] + [(str(l.order), l.name) for l in LiaisonStatementPurposeName.objects.all()]
self.hm = IETFHM
self.set_from_field()
self.set_replyto_field()
self.set_organization_field()
def get_info(request):
person = get_person_for_user(request.user)
to_entity_id = request.GET.get('to_entity_id', None)
from_entity_id = request.GET.get('from_entity_id', None)
result = {'poc': [], 'cc': [], 'needs_approval': False, 'post_only': False, 'full_list': []}
to_error = 'Invalid TO entity id'
if to_entity_id:
to_entity = IETFHM.get_entity_by_key(to_entity_id)
if to_entity:
to_error = ''
from_error = 'Invalid FROM entity id'
if from_entity_id:
from_entity = IETFHM.get_entity_by_key(from_entity_id)
if from_entity:
from_error = ''
if to_error or from_error:
result.update({'error': '\n'.join([to_error, from_error])})
else:
result.update({'error': False,
'cc': [i.email() for i in to_entity.get_cc(person=person)] +\
[i.email() for i in from_entity.get_from_cc(person=person)],
'poc': [i.email() for i in to_entity.get_poc()],
'needs_approval': from_entity.needs_approval(person=person),
'post_only': from_entity.post_only(person=person, user=request.user)})
if is_secretariat(request.user):
full_list = [(i.pk, i.email()) for i in set(from_entity.full_user_list())]
full_list.sort(lambda x,y: cmp(x[1], y[1]))
full_list = [(person.pk, person.email())] + full_list
result.update({'full_list': full_list})
json_result = simplejson.dumps(result)
return HttpResponse(json_result, mimetype='text/javascript')
def __init__(self, user, *args, **kwargs):
self.user = user
self.fake_person = None
self.person = get_person_for_user(user)
if kwargs.get('data', None):
if is_secretariat(self.user) and 'from_fake_user' in kwargs['data'].keys():
self.fake_person = Person.objects.get(pk=kwargs['data']['from_fake_user'])
kwargs['data'].update({'person': self.fake_person.pk})
else:
kwargs['data'].update({'person': self.person.pk})
self.instance = kwargs.pop("instance", None)
super(LiaisonForm, self).__init__(*args, **kwargs)
# now copy in values from instance, like a ModelForm
if self.instance:
for name, field in self.fields.iteritems():
try:
x = getattr(self.instance, name)
if name == "purpose": # proxy has a name-clash on purpose so help it
x = x.order
try:
x = x.pk # foreign keys need the .pk, not the actual object
except AttributeError:
pass
self.initial[name] = x
except AttributeError:
# we have some fields on the form that aren't in the model
pass
self.fields["purpose"].choices = [("", "---------")] + [(str(l.order), l.name) for l in LiaisonStatementPurposeName.objects.all()]
self.hm = IETFHM
self.set_from_field()
self.set_replyto_field()
self.set_organization_field()
def can_do_wg_workflow_in_group(user, group):
person = get_person_for_user(user)
if not person:
return False
return (is_secretariat(user) or is_group_chair(person, group))
def can_edit_stream(user, draft):
return is_secretariat(user)
def can_edit_state(user, draft):
return (is_secretariat(user) or
is_authorized_in_draft_stream(user, draft))
def can_edit_stream(user, draft):
return is_secretariat(user)
def is_delegate_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
return user.is_authenticated() and bool(Role.objects.filter(group__acronym=stream.slug, name="delegate", person__user=user))
def is_chair_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
if isinstance(user, basestring):
return False
return user.is_authenticated() and bool(Role.objects.filter(group__acronym=stream.slug, name="chair", person__user=user))
def is_chair_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_chair(person)
def can_do_wg_workflow_in_group(user, group):
person = get_person_for_user(user)
if not person:
return False
return (is_secretariat(user) or is_group_chair(person, group))
def can_do_wg_workflow_in_document(user, document):
person = get_person_for_user(user)
if not person or not document.group:
return False
return (is_secretariat(user) or can_do_wg_workflow_in_group(document.group.ietfwg))
def liaison_list(request):
user = request.user
can_send_outgoing = can_add_outgoing_liaison(user)
can_send_incoming = can_add_incoming_liaison(user)
can_approve = False
can_edit = False
person = get_person_for_user(request.user)
if person:
approval_codes = IETFHM.get_all_can_approve_codes(person)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if is_secretariat(request.user):
can_approve = LiaisonDetail.objects.filter(
approved=None).order_by("-submitted").count()
else:
can_approve = approvable_liaison_statements(
approval_codes).count()
else:
can_approve = LiaisonDetail.objects.filter(
approval__isnull=False,
approval__approved=False,
from_raw_code__in=approval_codes).count()
order = request.GET.get('order_by', 'submitted_date')
plain_order = order
reverse_order = order.startswith('-')
if reverse_order:
plain_order = order[1:]
if plain_order not in ('submitted_date', 'deadline_date', 'title',
'to_body', 'from_raw_body'):
order = 'submitted_date'
reverse_order = True
plain_order = 'submitted_date'
elif plain_order in ('submitted_date', 'deadline_date'):
# Reverse order for date fields, humans find it more natural
if reverse_order:
order = plain_order
else:
order = '-%s' % plain_order
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
public_liaisons = LiaisonDetail.objects.exclude(
approved=None).order_by(order)
else:
public_liaisons = LiaisonDetail.objects.filter(
Q(approval__isnull=True)
| Q(approval__approved=True)).order_by(order)
return object_list(
request,
public_liaisons,
allow_empty=True,
template_name='liaisons/liaisondetail_list.html',
extra_context={
'can_manage': can_approve or can_send_incoming
or can_send_outgoing,
'can_approve': can_approve,
'can_edit': can_edit,
'can_send_incoming': can_send_incoming,
'can_send_outgoing': can_send_outgoing,
plain_order: not reverse_order and '-' or None
},
)
def post_only(self, person, user):
if is_secretariat(user) or self.obj.role_set.filter(person=person,
name="auth"):
return False
return True
def can_manage_shepherds_in_group(user, group):
person = get_person_for_user(user)
if not person:
return False
return (is_secretariat(user) or is_group_chair(person, group))
def get_post_only(self):
from_entity = self.get_from_entity()
if is_secretariat(self.user) or Role.objects.filter(
person=self.person, group=from_entity.obj, name="auth"):
return False
return True
def is_delegate_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_delegate(person)
def is_delegate_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
return user.is_authenticated() and bool(
Role.objects.filter(
group__acronym=stream.slug, name="delegate", person__user=user))
def get_post_only(self):
from_entity = self.get_from_entity()
if is_secretariat(self.user) or Role.objects.filter(person=self.person, group=from_entity.obj, name="auth"):
return False
return True
def get_post_only(self):
from_entity = self.get_from_entity()
if is_secretariat(self.user) or self.person.sdoauthorizedindividual_set.filter(sdo=from_entity.obj):
return False
return True
def can_manage_shepherds_in_group(user, group):
person = get_person_for_user(user)
if not person:
return False
return (is_secretariat(user) or is_group_chair(person, group))
def is_chair_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_chair(person)
def post_only(self, person, user):
if is_secretariat(user) or self.obj.role_set.filter(person=person, name="auth"):
return False
return True
def is_delegate_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_delegate(person)
def can_do_wg_workflow_in_document(user, document):
person = get_person_for_user(user)
if not person or not document.group:
return False
return (is_secretariat(user)
or can_do_wg_workflow_in_group(document.group.ietfwg))
def can_edit_state(user, draft):
return (is_secretariat(user) or is_authorized_in_draft_stream(user, draft))
def post_only(self, person, user):
if is_secretariat(user) or person.sdoauthorizedindividual_set.filter(sdo=self.obj):
return False
return True
