def get_reviewing_parties(sf, active=None):
parties = PartyList()
anonymous = get_current_user(
) and not get_current_user().profile.is_internal
with sudo():
tasks = Task.objects.for_submission(sf.submission).filter(
assigned_to__isnull=False,
deleted_at=None).exclude(task_type__workflow_node__uid__in=(
'resubmission', 'b2_resubmission'
)).order_by('created_at').select_related('task_type').distinct()
if active:
tasks = tasks.open()
tasks = list(tasks)
for task in tasks:
if task.task_type.workflow_node.uid == 'external_review':
parties.add(user=task.assigned_to,
involvement=task.task_type.trans_name,
anonymous=anonymous)
else:
party = Party(user=task.assigned_to,
involvement=task.task_type.trans_name)
if party not in parties:
parties.append(party)
for temp_auth in sf.submission.temp_auth.filter(end__gt=timezone.now()):
parties.add(user=temp_auth.user,
involvement=_('Temporary Authorization'))
return parties
def __init__(self, submission, *args, **kwargs):
self.to_user = kwargs.pop('to', None)
super().__init__(*args, **kwargs)
self.submission = submission
receiver_type_choices = [
('ec',
'{0} ({1})'.format(ugettext('Ethics Commission'),
get_office_user(submission=self.submission))),
]
receiver_type_initial = 'ec'
if submission and get_current_user(
) not in submission.current_submission_form.get_presenting_parties():
receiver_type_choices += [
('involved', _('Involved Party')),
]
receiver_type_initial = 'involved'
self.fields['receiver_involved'].set_submission(submission)
user = get_current_user()
if user.profile.is_internal:
receiver_type_choices += [('person', _('Person'))]
self.fields['receiver_person'].queryset = User.objects.filter(
is_active=True).exclude(pk=user.pk)
self.fields['receiver'].queryset = User.objects.filter(
is_active=True).exclude(pk=user.pk)
self.fields['receiver_type'].choices = receiver_type_choices
self.fields['receiver_type'].initial = receiver_type_initial
if self.to_user:
self.fields['receiver_type'].required = False
def publish(self):
assert self.published_at is None
self.published_at = timezone.now()
self.published_by = get_current_user()
if self.result == '1':
self.valid_until = self.published_at + timedelta(days=365)
self.save()
if not self.needs_signature:
pdf_data = self.render_pdf()
Document.objects.create_from_buffer(
pdf_data,
doctype='votes',
parent_object=self,
original_file_name=self.pdf_filename,
name=str(self))
submission = self.get_submission()
assert submission.current_pending_vote_id == self.id
submission.current_pending_vote = None
submission.current_published_vote = self
submission.save(update_fields=('current_pending_vote',
'current_published_vote'))
on_vote_publication.send(sender=Vote, vote=self)
def get_query_set(self):
qs = self.get_base_query_set()
user = get_current_user()
if not user:
return qs
q_factory = self.get_q_factory()
return qs.filter(q_factory(user)).distinct()
def post_save_handler(**kwargs):
""" This creates an AuditTrail entry for every db change """
if not settings.ENABLE_AUDIT_TRAIL: # this is set when syncdb or migrate is being run
return
sender = kwargs['sender']
instance = kwargs['instance']
user = get_current_user()
if not user or not user.is_authenticated():
user = User.objects.get(username='******')
sender_path = '.'.join([sender.__module__, sender.__name__])
if _ignored_models_rex.match(sender_path):
return
description = '%s %s instance of %s' % (
user,
'created' if kwargs['created'] else 'modified',
sender.__name__,
)
a = AuditTrail()
a.description = description
a.user = user
a.instance = instance
a.content_type = ContentType.objects.get_for_model(sender)
a.data = serialize('json', sender.objects.filter(pk=instance.pk))
a.object_created = kwargs['created']
a.save()
def get_queryset(self):
qs = self.get_base_queryset()
user = get_current_user()
if not user:
return qs
q_factory = self.get_q_factory()
return qs.filter(q_factory(user)).distinct()
def save(self, **kwargs):
if not self.presenter_id:
self.presenter = get_current_user()
if not self.submission.is_transient:
for x, org in (('submitter', 'submitter_organisation'),
('sponsor', 'sponsor_name')):
email = getattr(self, '{0}_email'.format(x))
if email:
try:
user = get_user(email)
except User.DoesNotExist:
user = create_phantom_user(email, role=x)
user.first_name = getattr(
self, '{0}_contact_first_name'.format(x))
user.last_name = getattr(
self, '{0}_contact_last_name'.format(x))
user.save()
profile = user.profile
profile.title = getattr(self,
'{0}_contact_title'.format(x))
profile.gender = getattr(
self, '{0}_contact_gender'.format(x)) or 'f'
profile.organisation = getattr(self, org)
profile.save()
setattr(self, x, user)
return super().save(**kwargs)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
queryset = get_usable_submission_forms().filter(
submission__susar_presenter=get_current_user())
self.fields['submission_forms'].queryset = queryset
if queryset.count() == 1:
self.fields['submission_forms'].initial = queryset
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
queryset = get_usable_submission_forms().filter(
submission__presenter=get_current_user(),
submission__is_finished=False)
self.fields['submission_form'].queryset = queryset
if queryset.count() == 1:
self.fields['submission_form'].empty_label = None
def get_checklist_answer_instance(submission, blueprint_slug, number):
blueprint = ChecklistBlueprint.objects.get(slug=blueprint_slug)
q = ChecklistAnswer.objects.filter(checklist__submission=submission,
question__blueprint__pk=blueprint.pk,
question__number=str(number))
if blueprint.multiple:
q.filter(checklist__user=get_current_user())
return q.get()
def _render(plainhtml=False):
data = {
'doc': doc,
'plainhtml': plainhtml,
'submission_form': self.submission_form,
'user': get_current_user(),
}
return render_html(HttpRequest(), 'submissions/diff/document.html',
data)
def get_involved_parties(self):
current_user = get_current_user()
if current_user and not current_user.profile.is_internal and Task.objects.for_submission(
self.submission).filter(
task_type__workflow_node__uid='external_review',
assigned_to=current_user,
deleted_at=None).exists():
return get_reviewing_parties(self)
return get_involved_parties(self)
def is_locked(self):
blueprint = self.node.data
lookup_kwargs = {'blueprint': blueprint}
if blueprint.multiple:
lookup_kwargs['user'] = get_current_user()
try:
checklist = self.workflow.data.checklists.get(**lookup_kwargs)
except Checklist.DoesNotExist:
return True
return not checklist.is_complete
def is_locked(self):
blueprint = self.node.data
lookup_kwargs = {'blueprint': blueprint}
if blueprint.multiple:
lookup_kwargs['user'] = get_current_user()
try:
checklist = self.workflow.data.checklists.get(**lookup_kwargs)
except Checklist.DoesNotExist:
return False
return not checklist.is_complete
def save(self, **kwargs):
if not self.presenter_id:
self.presenter = get_current_user()
if not self.susar_presenter_id:
self.susar_presenter = get_current_user()
if not self.ec_number:
with sudo():
year = timezone.now().year
max_num = Submission.objects.filter(ec_number__range=(
year * 10000, (year + 1) * 10000 - 1)).aggregate(
models.Max('ec_number'))['ec_number__max']
if max_num is None:
max_num = 10000 * year + MIN_EC_NUMBER
else:
year, num = divmod(max_num, 10000)
max_num = year * 10000 + max(num, MIN_EC_NUMBER)
# XXX: this breaks if there are more than 9999 studies per year (FMD2)
self.ec_number = max_num + 1
return super().save(**kwargs)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
user = get_current_user()
if not self.readonly and user.profile.is_executive:
self.fields['result'] = Vote._meta.get_field('result').formfield(
initial=self.instance.result)
# reorder fields
self.fields['text'] = self.fields.pop('text')
self.fields['is_final_version'] = self.fields.pop(
'is_final_version')
def pre_perform(self, choice):
blueprint = self.node.data
lookup_kwargs = {'blueprint': blueprint}
if blueprint.multiple:
lookup_kwargs['user'] = get_current_user()
try:
checklist = self.workflow.data.checklists.get(**lookup_kwargs)
except Checklist.DoesNotExist:
pass
else:
checklist.status = 'completed'
checklist.save()
checklist.render_pdf_document()
def set_submission(self, submission):
involved_parties = submission.current_submission_form.get_involved_parties(
)
self.queryset = User.objects.filter(
is_active=True,
pk__in=[
u.pk for u in involved_parties.get_users().difference(
[get_current_user()])
],
)
self.choices = [(self.prepare_value(p.user),
'{} [{}]'.format(p.user, p.involvement))
for p in involved_parties]
def save(self, **kwargs):
if not self.presenter_id:
from ecs.users.utils import get_current_user
user = get_current_user()
if user:
self.presenter = user
for x in ('submitter', 'sponsor'):
if getattr(self, '%s_email' % x):
try:
user = User.objects.filter(email=getattr(self, '%s_email' % x))[0]
except IndexError:
pass
else:
setattr(self, x, user)
return super(SubmissionForm, self).save(**kwargs)
def short_name(self):
if self.blueprint.multiple:
u = get_current_user()
s = self.submission
sf = self.submission.current_submission_form
presenting_parties = [
s.presenter_id, s.susar_presenter_id, sf.submitter_id,
sf.sponsor_id, *(inv.user_id for inv in sf.investigators.all())
]
name = _(
'Anonymous') if self.blueprint.reviewer_is_anonymous else str(
self.last_edited_by)
if u.id == self.user_id or (u is not None and u.profile.is_internal
and not u.id in presenting_parties):
name = str(self.last_edited_by)
return "%s (%s)" % (self.blueprint, name)
return str(self.blueprint)
def on_initial_review(sender, **kwargs):
submission, submission_form = kwargs['submission'], kwargs['form']
if submission_form.is_acknowledged:
send_submission_message(submission, submission.presenter,
_('Acknowledgement of Receipt'),
'submissions/acknowledge_message.txt')
if not submission.current_submission_form == submission_form:
pending_vote = submission.current_pending_vote
if pending_vote and pending_vote.is_draft:
pending_vote.submission_form = submission_form
pending_vote.save()
submission_form.mark_current()
vote = submission.current_published_vote
if vote and vote.is_recessed:
receivers = submission_form.get_presenting_parties().get_users(
)
with sudo():
for task in Task.objects.for_submission(submission).filter(
task_type__workflow_node__uid__in=[
'categorization', 'internal_vote_review'
],
assigned_to__isnull=False):
receivers.add(task.assigned_to)
for task in Task.objects.for_submission(submission).filter(
task_type__workflow_node__uid='specialist_review',
assigned_to__isnull=False).open():
receivers.add(task.assigned_to)
else:
receivers = submission_form.get_involved_parties().get_users()
receivers = receivers.difference(
[submission_form.presenter,
get_current_user()])
for u in receivers:
send_submission_message(
submission,
u,
_('Changes to study EC-Nr. {ec_number}'),
'submissions/change_message.txt',
reply_receiver=get_office_user(submission=submission))
else:
send_submission_message(submission, submission.presenter,
_('Submission not accepted'),
'submissions/decline_message.txt')
def decrypt_pdf(src):
decrypted = TemporaryFile()
popen = subprocess.Popen(['qpdf', '--decrypt', '/dev/stdin', '-'],
stdin=src,
stdout=decrypted,
stderr=subprocess.PIPE)
stdout, stderr = popen.communicate()
if popen.returncode in (0, 3): # 0 == ok, 3 == warning
if popen.returncode == 3:
logger.warn('qpdf warning:\n%s',
smart_bytes(stderr, errors='backslashreplace'))
else:
from ecs.users.utils import get_current_user
user = get_current_user()
logger.warn('qpdf error (returncode=%s):\nUser: %s (%s)\n%s',
popen.returncode, user,
user.email if user else 'anonymous',
smart_bytes(stderr, errors='backslashreplace'))
raise ValueError('pdf broken')
decrypted.seek(0)
return decrypted
def send_system_message_template(*args, **kwargs):
kwargs.setdefault('reply_receiver', get_current_user())
return send_message_template(get_user('*****@*****.**'), *args, **kwargs)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if get_current_user().profile.is_internal:
self.fields['susar_presenter'] = AutocompleteModelChoiceField(
'users', User.objects.filter(is_active=True),
label=_('Susar Presenter'))
