Python model.MetaSchema类代码示例

def get_metaschemas(*args, **kwargs):
    """
    List metaschemas with which a draft registration may be created. Only fetch the newest version for each schema.

    :return: serialized metaschemas
    :rtype: dict
    """
    count = request.args.get('count', 100)
    include = request.args.get('include', 'latest')

    meta_schema_collection = database['metaschema']

    meta_schemas = []
    if include == 'latest':
        schema_names = meta_schema_collection.distinct('name')
        for name in schema_names:
            meta_schema_set = MetaSchema.find(
                Q('name', 'eq', name) &
                Q('schema_version', 'eq', 2)
            )
            meta_schemas = meta_schemas + [s for s in meta_schema_set]
    else:
        meta_schemas = MetaSchema.find()
    meta_schemas = [
        schema
        for schema in meta_schemas
        if schema.name in ACTIVE_META_SCHEMAS
    ]
    meta_schemas.sort(key=lambda a: ACTIVE_META_SCHEMAS.index(a.name))
    return {
        'meta_schemas': [
            serialize_meta_schema(ms) for ms in meta_schemas[:count]
        ]
    }, http.OK

def generate_schema_from_data(data):
    def from_property(id, prop):
        if isinstance(prop.get('value'), dict):
            return {
                'id': id,
                'type': 'object',
                'properties': [
                    from_property(pid, sp)
                    for pid, sp in prop['value'].items()
                ]
            }
        else:
            return {
                'id': id,
                'type': 'osf-upload' if prop.get('extra') else 'string'
            }
    def from_question(qid, question):
        if q.get('extra'):
            return {
                'qid': qid,
                'type': 'osf-upload'
            }
        elif isinstance(q.get('value'), dict):
            return {
                'qid': qid,
                'type': 'object',
                'properties': [
                    from_property(id, value)
                    for id, value in question.get('value').items()
                ]
            }
        else:
            return {
                'qid': qid,
                'type': 'string'
            }                
    schema = MetaSchema(
        name='Test',
        schema={
            'name': "Test",
            'version': 2,
            'config': {
                'hasFiles': True
            },
            'pages':  [{
                'id': 'page1',
                'questions': [
                    from_question(qid, q)
                    for qid, q in data.items()
                ]
            }]
        },
    )
    schema.save()
    return schema

    def test_ensure_schemas(self):

        # Should be zero MetaSchema records to begin with
        assert_equal(
            MetaSchema.find().count(),
            0
        )

        ensure_schemas()
        assert_equal(
            MetaSchema.find().count(),
            len(OSF_META_SCHEMAS)
        )

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

    def test_archive_success_different_name_same_sha(self):
        ensure_schemas()
        file_tree = file_tree_factory(0, 0, 0)
        fake_file = file_factory()
        fake_file2 = file_factory(sha256=fake_file['extra']['hashes']['sha256'])
        file_tree['children'] = [fake_file, fake_file2]

        node = factories.NodeFactory(creator=self.user)
        prereg_schema = MetaSchema.find_one(
            Q('name', 'eq', 'Prereg Challenge') &
            Q('schema_version', 'eq', 2)
        )
        data = {
            ('q_' + fake_file['name']): {
                'value': fake.word(),
                'extra': {
                    'sha256': fake_file['extra']['hashes']['sha256'],
                    'viewUrl': '/project/{0}/files/osfstorage{1}'.format(
                        node._id,
                        fake_file['path']
                    ),
                    'selectedFileName': fake_file['name'],
                    'nodeId': node._id
                }
            }
        }

        with test_utils.mock_archive(node, schema=prereg_schema, data=data, autocomplete=True, autoapprove=True) as registration:
            with mock.patch.object(StorageAddonBase, '_get_file_tree', mock.Mock(return_value=file_tree)):
                job = factories.ArchiveJobFactory()
                archive_success(registration._id, job._id)
                for key, question in registration.registered_meta[prereg_schema._id].items():
                    assert_equal(question['extra']['selectedFileName'], fake_file['name'])

 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 test_migrate_registration_schemas(self):
        target_nodes = self.db['node'].find({'is_registration': True})
        do_migration(_db=self.db)

        for node in target_nodes:
            for meta_schema_id in node['registered_schema']:
                meta_schema = MetaSchema.load(meta_schema_id)
                old_data = OLD_META[meta_schema.name]
                for key, value in old_data.iteritems():
                    assert_equal(
                        node['registered_meta'][meta_schema._id][key]['value'],
                        value
                    )

 def setUpPrereg(self):
     ensure_schemas()
     self.prereg_challenge_admin_user = AuthUserFactory()
     self.prereg_challenge_admin_user.system_tags.append(settings.PREREG_ADMIN_TAG)
     self.prereg_challenge_admin_user.save()
     prereg_schema = MetaSchema.find_one(
             Q('name', 'eq', 'Prereg Challenge') &
             Q('schema_version', 'eq', 2)
     )
     # import ipdb; ipdb.set_trace()
     self.draft_registration = factories.DraftRegistrationFactory(
             initiator=self.user,
             registration_schema=prereg_schema
     )

    def test_has_project_and_draft_registration(self):
        prereg_schema = MetaSchema.find_one(
            Q('name', 'eq', 'Prereg Challenge')
        )
        factories.DraftRegistrationFactory(
            initiator=self.user,
            registration_schema=prereg_schema
        )

        assert_equal(
            landing_page(user=self.user),
            {
                'has_projects': True,
                'has_draft_registrations': True,
            }
        )

    def setUp(self):
        super(TestCheckPreregAuth, self).setUp()

        ensure_schemas()
        self.prereg_challenge_admin_user = AuthUserFactory()
        self.prereg_challenge_admin_user.system_tags.append(settings.PREREG_ADMIN_TAG)
        self.prereg_challenge_admin_user.save()
        prereg_schema = MetaSchema.find_one(Q("name", "eq", "Prereg Challenge") & Q("schema_version", "eq", 2))

        self.user = AuthUserFactory()
        self.node = factories.ProjectFactory(creator=self.user)

        self.parent = factories.ProjectFactory()
        self.child = factories.NodeFactory(parent=self.parent)

        self.draft_registration = factories.DraftRegistrationFactory(
            initiator=self.user, registration_schema=prereg_schema, branched_from=self.parent
        )

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

 def _create(cls, *args, **kwargs):
     branched_from = kwargs.get("branched_from")
     initiator = kwargs.get("initiator")
     registration_schema = kwargs.get("registration_schema")
     registration_metadata = kwargs.get("registration_metadata")
     if not branched_from:
         project_params = {}
         if initiator:
             project_params["creator"] = initiator
         branched_from = ProjectFactory(**project_params)
     initiator = branched_from.creator
     try:
         registration_schema = registration_schema or MetaSchema.find()[0]
     except IndexError:
         ensure_schemas()
     registration_metadata = registration_metadata or {}
     draft = DraftRegistration.create_from_node(
         branched_from, user=initiator, schema=registration_schema, data=registration_metadata
     )
     return draft

    def setUp(self):
        super(TestMigrateSchemas, self).setUp()

        MetaSchema.remove()
        ensure_schemas()

        self.regular_old_node = factories.NodeFactory()

        self.open_ended_schema = MetaSchema.find_one(
            Q('name', 'eq', SCHEMA_NAMES[0]) &
            Q('schema_version', 'eq', 1)
        )
        self.open_ended = self._make_registration(self.open_ended_schema)

        self.standard_schema = MetaSchema.find_one(
            Q('name', 'eq', SCHEMA_NAMES[1]) &
            Q('schema_version', 'eq', 1)
        )
        self.standard = self._make_registration(self.standard_schema)

        self.brandt_pre_schema = MetaSchema.find_one(
            Q('name', 'eq', SCHEMA_NAMES[2]) &
            Q('schema_version', 'eq', 1)
        )
        self.brandt_pre = self._make_registration(self.brandt_pre_schema)

        self.brandt_post_schema = MetaSchema.find_one(
            Q('name', 'eq', SCHEMA_NAMES[3]) &
            Q('schema_version', 'eq', 1)
        )
        self.brandt_post = self._make_registration(self.brandt_post_schema)

        self.multiple = self._make_registration([
            self.brandt_pre_schema,
            self.brandt_post_schema
        ])

        self.confirmatory_schema = MetaSchema.find_one(
            Q('name', 'eq', 'Confirmatory - General')
        )
        self.confirmatory = self._make_registration(self.confirmatory_schema)

        self.db['node'].update({}, {'$set': {'registered_schema': None}}, multi=True)

    def test_archive_success_same_file_in_component(self):
        ensure_schemas()
        file_tree = file_tree_factory(3, 3, 3)
        selected = select_files_from_tree(file_tree).values()[0]

        child_file_tree = file_tree_factory(0, 0, 0)
        child_file_tree['children'] = [selected]

        node = factories.NodeFactory(creator=self.user)
        child = factories.NodeFactory(creator=self.user, parent=node)

        prereg_schema = MetaSchema.find_one(
            Q('name', 'eq', 'Prereg Challenge') &
            Q('schema_version', 'eq', 2)
        )
        data = {
            ('q_' + selected['name']): {
                'value': fake.word(),
                'extra': {
                    'sha256': selected['extra']['hashes']['sha256'],
                    'viewUrl': '/project/{0}/files/osfstorage{1}'.format(
                        child._id,
                        selected['path']
                    ),
                    'selectedFileName': selected['name'],
                    'nodeId': child._id
                }
            }
        }

        with test_utils.mock_archive(node, schema=prereg_schema, data=data, autocomplete=True, autoapprove=True) as registration:
            with mock.patch.object(StorageAddonBase, '_get_file_tree', mock.Mock(return_value=file_tree)):
                job = factories.ArchiveJobFactory()
                archive_success(registration._id, job._id)
                child_reg = registration.nodes[0]
                for key, question in registration.registered_meta[prereg_schema._id].items():
                    assert_in(child_reg._id, question['extra']['viewUrl'])

    def test_drafts_for_user_omits_registered(self):
        prereg_schema = MetaSchema.find_one(
            Q('name', 'eq', 'Prereg Challenge') &
            Q('schema_version', 'eq', 2)
        )

        d1 = factories.DraftRegistrationFactory(
            initiator=self.user,
            registration_schema=prereg_schema
        )
        d2 = factories.DraftRegistrationFactory(
            initiator=self.user,
            registration_schema=prereg_schema
        )
        d3 = factories.DraftRegistrationFactory(
            initiator=self.user,
            registration_schema=prereg_schema
        )
        d1.registered_node = factories.ProjectFactory()
        d1.save()
        drafts = drafts_for_user(self.user, 'prereg')
        for d in drafts:
            assert_in(d._id, (d2._id, d3._id))
            assert_not_equal(d._id, d1._id)