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'))