Python model.DraftRegistration类代码示例

def draft_reg_util():
    DraftRegistration.remove()
    ensure_schemas()
    return MetaSchema.find_one(
        Q('name', 'eq', 'Prereg Challenge') &
        Q('schema_version', 'eq', 2)
    )

 def get_queryset(self):
     query = (
         Q('registration_schema', 'eq', get_prereg_schema()) &
         Q('approval', 'ne', None)
     )
     ordering = self.get_ordering()
     if 'initiator' in ordering:
         return DraftRegistration.find(query).sort(ordering)
     if ordering == SORT_BY['title']:
         return DraftRegistration.find(query).sort(
             'registration_metadata.q1.value')
     if ordering == SORT_BY['n_title']:
         return DraftRegistration.find(query).sort(
             '-registration_metadata.q1.value')
     return sort_drafts(DraftRegistration.find(query), ordering)

def delete_draft_registration(auth, node, draft, *args, **kwargs):
    """Permanently delete a draft registration

    :return: None
    :rtype: NoneType
    """
    if draft.registered_node:
        raise HTTPError(
            http.FORBIDDEN,
            data={
                'message_short': 'Can\'t delete draft',
                'message_long': 'This draft has already been registered and cannot be deleted.'
            }
        )
    DraftRegistration.remove_one(draft)
    return None, http.NO_CONTENT

    def __init__(self, registration, missing_files, *args, **kwargs):
        super(ArchivedFileNotFound, self).__init__(*args, **kwargs)

        self.draft_registration = DraftRegistration.find_one(
            Q('registered_node', 'eq', registration)
        )
        self.missing_files = missing_files

 def post(self, request, *args, **kwargs):
     try:
         data = json.loads(request.body).get('schema_data', {})
         draft = DraftRegistration.load(self.kwargs.get('draft_pk'))
         draft.update_metadata(data)
         draft.save()
         log_message = list()
         for key, value in data.iteritems():
             comments = data.get(key, {}).get('comments', [])
             for comment in comments:
                 log_message.append('{}: {}'.format(key, comment['value']))
         update_admin_log(
             user_id=request.user.id,
             object_id=draft._id,
             object_repr='Draft Registration',
             message='Comments: <p>{}</p>'.format('</p><p>'.join(log_message)),
             action_flag=COMMENT_PREREG
         )
         return JsonResponse(serializers.serialize_draft_registration(draft))
     except AttributeError:
         raise Http404('{} with id "{}" not found.'.format(
             self.context_object_name.title(),
             self.kwargs.get('draft_pk')
         ))
     except NodeStateError as e:
         return bad_request(request, e)

def get_draft(draft_pk):
	auth = Auth(adminUser)
	
	draft = DraftRegistration.find(
        Q('_id', 'eq', draft_pk)
    )

	return utils.serialize_draft_registration(draft[0], auth), http.OK

 def dispatch(self, request, *args, **kwargs):
     self.draft = DraftRegistration.load(self.kwargs.get('draft_pk'))
     if self.draft is None:
         raise Http404('{} with id "{}" not found.'.format(
             self.context_object_name.title(),
             self.kwargs.get('draft_pk')
         ))
     return super(DraftFormView, self).dispatch(request, *args, **kwargs)

def get_draft_obj(draft_pk):
	auth = Auth(adminUser)
	
	draft = DraftRegistration.find(
        Q('_id', 'eq', draft_pk)
    )

	return draft[0], auth

    def _on_reject(self, user, *args, **kwargs):
        from website.project.model import DraftRegistration

        # clear out previous registration options
        self.meta = {}
        self.save()

        draft = DraftRegistration.find_one(Q("approval", "eq", self))
        self._send_rejection_email(draft.initiator, draft)

 def get_object(self, queryset=None):
     try:
         return serializers.serialize_draft_registration(
             DraftRegistration.load(self.kwargs.get('draft_pk'))
         )
     except AttributeError:
         raise Http404('{} with id "{}" not found.'.format(
             self.context_object_name.title(),
             self.kwargs.get('draft_pk')
         ))

def get_all_drafts():
	# TODO[lauren]: add query parameters to only retrieve submitted drafts, they will have an approval associated with them
	all_drafts = DraftRegistration.find()

	auth = Auth(adminUser)

	serialized_drafts = {
		'drafts': [utils.serialize_draft_registration(d, auth) for d in all_drafts]
	}
	return serialized_drafts

 def get_queryset(self):
     prereg_schema = MetaSchema.find_one(
         Q('name', 'eq', 'Prereg Challenge') &
         Q('schema_version', 'eq', 2)
     )
     query = (
         Q('registration_schema', 'eq', prereg_schema) &
         Q('approval', 'ne', None)
     )
     return DraftRegistration.find(query).sort(self.ordering)

    def _notify_initiator(self):
        from website.project.model import DraftRegistration

        registration = self._get_registration()
        prereg_schema = prereg_utils.get_prereg_schema()

        draft = DraftRegistration.find_one(Q("registered_node", "eq", registration))

        if prereg_schema in registration.registered_schema:
            mails.send_mail(
                draft.initiator.username,
                mails.PREREG_CHALLENGE_ACCEPTED,
                user=draft.initiator,
                registration_url=registration.absolute_url,
                mimetype="html",
            )

def main(dry_run=True):
    if dry_run:
        logger.warn('DRY RUN mode')
    pending_approval_drafts = DraftRegistration.find()
    need_approval_drafts = [draft for draft in pending_approval_drafts
                            if draft.approval and draft.requires_approval and draft.approval.state == Sanction.UNAPPROVED]

    for draft in need_approval_drafts:
        sanction = draft.approval
        try:
            if not dry_run:
                sanction.state = Sanction.APPROVED
                sanction._on_complete(None)
                sanction.save()
            logger.warn('Approved {0}'.format(draft._id))
        except Exception as e:
            logger.error(e)

def get_prereg_drafts(user=None, filters=tuple()):
    prereg_schema = MetaSchema.find_one(
        Q('name', 'eq', 'Prereg Challenge') &
        Q('schema_version', 'eq', 2)
    )
    query = (
        Q('registration_schema', 'eq', prereg_schema) &
        Q('approval', 'ne', None)
    )
    if user:
        pass
        # TODO: filter by assignee; this requires multiple levels of Prereg admins-
        # one level that can see all drafts, and another than can see only the ones they're assigned.
        # As a followup to this, we need to make sure this applies to approval/rejection/commenting endpoints
        # query = query & Q('_metaschema_flags.assignee', 'eq', user._id)
    return sorted(
        DraftRegistration.find(query),
        key=operator.attrgetter('approval.initiation_date')
    )