def _set_up_registration_with_comment(self): self.registration = RegistrationFactory(creator=self.user, comment_level='private') self.registration_wiki = NodeWikiFactory(node=self.registration, user=self.user) self.registration_comment = CommentFactory(node=self.registration, target=Guid.load(self.registration_wiki._id), user=self.user) self.comment_url = '/{}comments/{}/'.format(API_BASE, self.registration_comment._id) reply_target = Guid.load(self.registration_comment._id) self.registration_comment_reply = CommentFactory(node=self.registration, target=reply_target, user=self.user)
class TestFindGuidsWithoutReferents(OsfTestCase): def setUp(self): super(TestFindGuidsWithoutReferents, self).setUp() self.node = NodeFactory() self.nontarget_guid= Guid(referent=self.node) self.nontarget_guid.save() def test_get_targets_referent_is_none(self): bad_guid = Guid(referent=None) bad_guid.save() targets = list(get_targets()) assert_in(bad_guid, targets) assert_not_in(self.nontarget_guid, targets) def test_get_targets_referent_points_to_nothing(self): node = NodeFactory() bad_guid = Guid(referent=node) bad_guid.save() Node.remove(Q('_id', 'eq', node._id)) targets = list(get_targets()) assert_in(bad_guid, targets) assert_not_in(self.nontarget_guid, targets)
def test_get_targets_referent_is_none(self): bad_guid = Guid(referent=None) bad_guid.save() targets = list(get_targets()) assert_in(bad_guid, targets) assert_not_in(self.nontarget_guid, targets)
def test_migrate_project_root_comment(self): comment = self._set_up_comment_with_target(root_target=self.project, target=self.project) update_comment_targets_to_guids() comment.reload() assert_equal(comment.root_target, Guid.load(self.project._id)) assert_equal(comment.target, Guid.load(self.project._id))
def test_migrate_project_comment_reply(self): comment = self._set_up_comment_with_target(root_target=self.project, target=self.project) reply = self._set_up_comment_with_target(root_target=self.project, target=comment) update_comment_targets_to_guids() reply.reload() assert_equal(reply.root_target, Guid.load(self.project._id)) assert_equal(reply.target, Guid.load(comment._id))
def _set_up_public_project_with_comment(self): self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private') self.public_project.add_contributor(self.contributor, save=True) self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user) self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user) reply_target = Guid.load(self.public_comment._id) self.public_comment_reply = CommentFactory(node=self.public_project, target=reply_target, user=self.user) self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id) self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def test_get_targets_referent_points_to_nothing(self): node = NodeFactory() bad_guid = Guid(referent=node) bad_guid.save() Node.remove(Q('_id', 'eq', node._id)) targets = list(get_targets()) assert_in(bad_guid, targets) assert_not_in(self.nontarget_guid, targets)
def get_metadata_files(draft): data = draft.registration_metadata for q, question in get_file_questions('prereg-prize.json'): if not isinstance(data[q]['value'], dict): for i, file_info in enumerate(data[q]['extra']): provider = file_info['data']['provider'] if provider != 'osfstorage': raise Http404( 'File does not exist in OSFStorage ({}: {})'.format( q, question)) file_guid = file_info.get('fileId') if not file_guid: node = Node.load(file_info.get('nodeId')) path = file_info['data'].get('path') item = FileNode.resolve_class(provider, FileNode.FILE).get_or_create( node, path) file_guid = item.get_guid(create=True)._id data[q]['extra'][i]['fileId'] = file_guid draft.update_metadata(data) draft.save() else: guid = Guid.load(file_guid) item = guid.referent if item is None: raise Http404( 'File with guid "{}" in "{}" does not exist'.format( file_guid, question)) yield item continue for i, file_info in enumerate(data[q]['value']['uploader']['extra']): provider = file_info['data']['provider'] if provider != 'osfstorage': raise Http404( 'File does not exist in OSFStorage ({}: {})'.format( q, question)) file_guid = file_info.get('fileId') if not file_guid: node = Node.load(file_info.get('nodeId')) path = file_info['data'].get('path') item = FileNode.resolve_class(provider, FileNode.FILE).get_or_create( node, path) file_guid = item.get_guid(create=True)._id data[q]['value']['uploader']['extra'][i]['fileId'] = file_guid draft.update_metadata(data) draft.save() else: guid = Guid.load(file_guid) item = guid.referent if item is None: raise Http404( 'File with guid "{}" in "{}" does not exist'.format( file_guid, question)) yield item
def get_guid(self, create=False): """Attempt to find a Guid that points to this object. One will be created if requested. :rtype: Guid """ try: # Note sometimes multiple GUIDs can exist for # a single object. Just go with the first one return Guid.find(Q('referent', 'eq', self))[0] except IndexError: if not create: return None return Guid.generate(self)
def _set_up_registration_with_comment(self): self.registration = RegistrationFactory(creator=self.user, comment_level='private') self.registration_wiki = NodeWikiFactory(node=self.registration, user=self.user) self.registration_comment = CommentFactory( node=self.registration, target=Guid.load(self.registration_wiki._id), user=self.user) self.comment_url = '/{}comments/{}/'.format( API_BASE, self.registration_comment._id) reply_target = Guid.load(self.registration_comment._id) self.registration_comment_reply = CommentFactory( node=self.registration, target=reply_target, user=self.user)
def get_guid(self, create=False): """Attempt to find a Guid that points to this object. One will be created if requested. :param Boolean create: Should we generate a GUID if there isn't one? Default: False :rtype: Guid or None """ try: # Note sometimes multiple GUIDs can exist for # a single object. Just go with the first one return Guid.find(Q("referent", "eq", self))[0] except IndexError: if not create: return None return Guid.generate(self)
def test_public_node_non_contributor_commenter_can_delete_wiki_comment(self): project = ProjectFactory(is_public=True, comment_level='public') test_wiki = NodeWikiFactory(node=project, user=self.user) comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor) url = '/{}comments/{}/'.format(API_BASE, comment._id) res = self.app.delete_json_api(url, auth=self.non_contributor.auth) assert_equal(res.status_code, 204)
def _set_up_public_project_with_comment(self): self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private') self.public_project.add_contributor(self.contributor, save=True) self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user) self.public_comment = CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user) self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id) self.public_comment_payload = self._set_up_payload(self.public_comment._id)
def main(): modm_guids = MODMGuid.find() print 'MODM Guids: {}'.format(len(modm_guids)) guids = Guid.objects.filter(guid__in=modm_guids.get_keys()) filtered_count = len(guids) total_count = Guid.objects.count() if len(modm_guids) == filtered_count == total_count: print 'Guids verified!' else: print 'Guids not verified!' print 'Postgres Guids: {}'.format(Guid.objects.count()) guids = modm_guids = filtered_count = total_count = None gc.collect() modm_blacklist_guids = MODMBlacklistGuid.find() print 'MODM BlacklistGuids: {}'.format(len(modm_blacklist_guids)) blacklist_guids = BlackListGuid.objects.filter(guid__in=modm_blacklist_guids.get_keys()) filtered_count = len(blacklist_guids) total_count = BlackListGuid.objects.count() if len(modm_blacklist_guids) == filtered_count == total_count: print 'Blacklist Guids Verified!' else: print 'Blacklist Guids Not Verified!' print 'Postgres Blacklist Guids: {}'.format(BlackListGuid.objects.count()) blacklist_guids = modm_blacklist_guids = filtered_count = total_count = None gc.collect()
def _update_comments_timestamp(auth, node, page=Comment.OVERVIEW, root_id=None): if node.is_contributor(auth.user): enqueue_postcommit_task(ban_url, (node, ), {}, celery=False, once_per_request=True) if root_id is not None: guid_obj = Guid.load(root_id) if guid_obj is not None: enqueue_postcommit_task(ban_url, (guid_obj.referent, ), {}, celery=False, once_per_request=True) # update node timestamp if page == Comment.OVERVIEW: root_id = node._id auth.user.comments_viewed_timestamp[root_id] = datetime.utcnow() auth.user.save() return { root_id: auth.user.comments_viewed_timestamp[root_id].isoformat() } else: return {}
def migrate_guids(guid_type, provider): cls = models.FileNode.resolve_class(provider, models.FileNode.FILE) for guid in paginated(guid_type): # Note: No metadata is populated here # It will be populated whenever this guid is next viewed if guid.node is None: logger.warning('{}({})\'s node is None; skipping'.format(guid_type, guid._id)) continue if guid.waterbutler_path in ('/{{ revision.osfDownloadUrl }}', '/{{ currentVersion().osfDownloadUrl }}', '/{{ currentVersion().osfDownloadUrl }}', '/{{ node.urls.files }}', '/{{ revision.extra.user.url }}'): logger.warning('{}({})\'s is a googlebot path; skipping'.format(guid_type, guid._id)) continue logger.debug('Migrating guid {} ({})'.format(guid._id, guid.waterbutler_path)) try: file_node = cls( node=guid.node, path=guid.waterbutler_path, name=guid.waterbutler_path, materialized_path=guid.waterbutler_path, ) file_node.save() except exceptions.KeyExistsException: file_node = cls.find_one( Q('node', 'eq', guid.node) & Q('path', 'eq', guid.waterbutler_path) ) logger.warning('{!r}({}) has multiple guids'.format(file_node.wrapped(), guid._id)) actual_guid = Guid.load(guid._id) actual_guid.referent = file_node actual_guid.save()
def get_file_guids(cls, materialized_path, provider, node=None): guids = [] path = materialized_path.strip('/') file_obj = cls.load(path) if not file_obj: file_obj = TrashedFileNode.load(path) # At this point, file_obj may be an OsfStorageFile, an OsfStorageFolder, or a # TrashedFileNode. TrashedFileNodes do not have *File and *Folder subclasses, since # only osfstorage trashes folders. To search for children of TrashFileNodes # representing ex-OsfStorageFolders, we will reimplement the `children` method of the # Folder class here. if not file_obj.is_file: children = [] if isinstance(file_obj, TrashedFileNode): children = TrashedFileNode.find(Q('parent', 'eq', file_obj._id)) else: children = file_obj.children for item in children: guids.extend(cls.get_file_guids(item.path, provider, node=node)) else: try: guid = Guid.find(Q('referent', 'eq', file_obj))[0] except IndexError: guid = None if guid: guids.append(guid._id) return guids
def update_file_guid_referent(self, node, event_type, payload, user=None): if event_type == 'addon_file_moved' or event_type == 'addon_file_renamed': source = payload['source'] destination = payload['destination'] source_node = Node.load(source['node']['_id']) destination_node = node file_guids = FileNode.resolve_class(source['provider'], FileNode.ANY).get_file_guids( materialized_path=source['materialized'] if source['provider'] != 'osfstorage' else source['path'], provider=source['provider'], node=source_node) if event_type == 'addon_file_renamed' and source['provider'] in settings.ADDONS_BASED_ON_IDS: return if event_type == 'addon_file_moved' and (source['provider'] == destination['provider'] and source['provider'] in settings.ADDONS_BASED_ON_IDS) and source_node == destination_node: return for guid in file_guids: obj = Guid.load(guid) if source_node != destination_node and Comment.find(Q('root_target', 'eq', guid)).count() != 0: update_comment_node(guid, source_node, destination_node) if source['provider'] != destination['provider'] or source['provider'] != 'osfstorage': old_file = FileNode.load(obj.referent._id) obj.referent = create_new_file(obj, source, destination, destination_node) obj.save() if old_file and not TrashedFileNode.load(old_file._id): old_file.delete()
def test_private_node_only_logged_in_contributor_commenter_can_delete_own_reply(self): self._set_up_private_project_with_comment() reply_target = Guid.load(self.comment._id) reply = CommentFactory(node=self.private_project, target=reply_target, user=self.user) reply_url = '/{}comments/{}/'.format(API_BASE, reply) res = self.app.delete_json_api(reply_url, auth=self.user.auth) assert_equal(res.status_code, 204)
def restore(self, recursive=True, parent=None): """Recreate a StoredFileNode from the data in this object Will re-point all guids and finally remove itself :raises KeyExistsException: """ data = self.to_storage() data.pop('deleted_on') data.pop('deleted_by') data.pop('suspended') if parent: data['parent'] = parent._id elif data['parent']: # parent is an AbstractForeignField, so it gets stored as tuple data['parent'] = data['parent'][0] restored = FileNode.resolve_class(self.provider, int(self.is_file))(**data) if not restored.parent: raise ValueError('No parent to restore to') restored.save() # repoint guid for guid in Guid.find(Q('referent', 'eq', self)): guid.referent = restored guid.save() if recursive: for child in TrashedFileNode.find(Q('parent', 'eq', self)): child.restore(recursive=recursive, parent=restored) TrashedFileNode.remove_one(self) return restored
def get_target(self, node_id, target_id): target = Guid.load(target_id) if not target: raise ValueError('Invalid comment target.') referent = target.referent if isinstance(referent, Node): if node_id != target_id: raise ValueError('Cannot post comment to another node.') elif isinstance(referent, Comment): if referent.node._id != node_id: raise ValueError( 'Cannot post reply to comment on another node.') elif isinstance(referent, StoredFileNode): if referent.provider not in osf_settings.ADDONS_COMMENTABLE: raise ValueError( 'Comments are not supported for this file provider.') elif referent.node._id != node_id: raise ValueError( 'Cannot post comment to file on another node.') else: raise ValueError('Invalid comment target.') return target
def main(): modm_guids = MODMGuid.find() print 'MODM Guids: {}'.format(len(modm_guids)) guids = Guid.objects.filter(guid__in=modm_guids.get_keys()) filtered_count = len(guids) total_count = Guid.objects.count() if len(modm_guids) == filtered_count == total_count: print 'Guids verified!' else: print 'Guids not verified!' print 'Postgres Guids: {}'.format(Guid.objects.count()) guids = modm_guids = filtered_count = total_count = None gc.collect() modm_blacklist_guids = MODMBlacklistGuid.find() print 'MODM BlacklistGuids: {}'.format(len(modm_blacklist_guids)) blacklist_guids = BlackListGuid.objects.filter( guid__in=modm_blacklist_guids.get_keys()) filtered_count = len(blacklist_guids) total_count = BlackListGuid.objects.count() if len(modm_blacklist_guids) == filtered_count == total_count: print 'Blacklist Guids Verified!' else: print 'Blacklist Guids Not Verified!' print 'Postgres Blacklist Guids: {}'.format(BlackListGuid.objects.count()) blacklist_guids = modm_blacklist_guids = filtered_count = total_count = None gc.collect()
def get_paginated_response(self, data): """Add number of unread comments to links.meta when viewing list of comments filtered by a target node, file or wiki page.""" response = super(CommentPagination, self).get_paginated_response(data) response_dict = response.data kwargs = self.request.parser_context['kwargs'].copy() if self.request.query_params.get('related_counts', False): target_id = self.request.query_params.get('filter[target]', None) node_id = kwargs.get('node_id', None) node = Node.load(node_id) user = self.request.user if target_id and not user.is_anonymous() and node.is_contributor(user): root_target = Guid.load(target_id) if root_target: page = getattr(root_target.referent, 'root_target_page', None) if page: if not len(data): unread = 0 else: unread = Comment.find_n_unread(user=user, node=node, page=page, root_id=target_id) if self.request.version < '2.1': response_dict['links']['meta']['unread'] = unread else: response_dict['meta']['unread'] = unread return Response(response_dict)
def _set_up_registration_with_comment(self): self.registration = RegistrationFactory(creator=self.user, comment_level='private') self.registration_file = test_utils.create_test_file(self.registration, self.user) self.registration_comment = CommentFactory(node=self.registration, target=self.registration_file.get_guid(), user=self.user) self.comment_url = '/{}comments/{}/'.format(API_BASE, self.registration_comment._id) reply_target = Guid.load(self.registration_comment._id) self.registration_comment_reply = CommentFactory(node=self.registration, target=reply_target, user=self.user)
def get_paginated_response(self, data): """Add number of unread comments to links.meta when viewing list of comments filtered by a target node, file or wiki page.""" response = super(CommentPagination, self).get_paginated_response(data) response_dict = response.data kwargs = self.request.parser_context['kwargs'].copy() if self.request.query_params.get('related_counts', False): target_id = self.request.query_params.get('filter[target]', None) node_id = kwargs.get('node_id', None) node = Node.load(node_id) user = self.request.user if target_id and not user.is_anonymous() and node.is_contributor( user): root_target = Guid.load(target_id) if root_target: page = getattr(root_target.referent, 'root_target_page', None) if page: if not len(data): unread = 0 else: unread = Comment.find_n_unread(user=user, node=node, page=page, root_id=target_id) response_dict['links']['meta']['unread'] = unread return Response(response_dict)
def _set_up_registration_with_comment(self): self.registration = RegistrationFactory(creator=self.user) self.registration_url = '/{}registrations/{}/'.format(API_BASE, self.registration._id) self.registration_comment = CommentFactory(node=self.registration, user=self.user) self.comment_url = '/{}comments/{}/'.format(API_BASE, self.registration_comment._id) reply_target = Guid.load(self.registration_comment._id) self.registration_comment_reply = CommentFactory(node=self.registration, target=reply_target, user=self.user) self.replies_url = '/{}registrations/{}/comments/?filter[target]={}'.format(API_BASE, self.registration._id, self.registration_comment._id)
def get_guid(filenode): try: guid = Guid.find_one(Q('referent', 'eq', filenode)) except ModularOdmException: logger.error('No Guid found for filenode {}'.format(filenode._id)) return None else: return guid
def test_migrate_file_comment_reply(self): test_file = create_test_file(node=self.project, user=self.project.creator) comment = self._set_up_comment_with_target(root_target=test_file, target=test_file) reply = self._set_up_comment_with_target(root_target=test_file, target=comment) update_comment_targets_to_guids() reply.reload() assert_equal(reply.root_target, test_file.get_guid()) assert_equal(reply.target, Guid.load(comment._id))
def update_comment_targets_to_guids(): comments = Comment.find() for comment in comments: # Skip comments on deleted files if not comment.target: continue if isinstance(comment.root_target, StoredFileNode): comment.root_target = comment.root_target.get_guid() elif comment.root_target: comment.root_target = Guid.load(comment.root_target._id) if isinstance(comment.target, StoredFileNode): comment.target = comment.target.get_guid() else: comment.target = Guid.load(comment.target._id) comment.save() logger.info("Migrated root_target and target for comment {0}".format(comment._id))
def test_public_node_non_contributor_commenter_can_update_wiki_comment(self): project = ProjectFactory(is_public=True) test_wiki = NodeWikiFactory(node=project, user=self.user) comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor) url = '/{}comments/{}/'.format(API_BASE, comment._id) payload = self._set_up_payload(comment._id) res = self.app.put_json_api(url, payload, auth=self.non_contributor.auth) assert_equal(res.status_code, 200) assert_equal(payload['data']['attributes']['content'], res.json['data']['attributes']['content'])
def test_wiki_has_comments_link(self): self._set_up_public_project_with_wiki_page() res = self.app.get(self.public_url) assert_equal(res.status_code, 200) url = res.json['data']['relationships']['comments']['links']['related']['href'] CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user) res = self.app.get(url) assert_equal(res.status_code, 200) assert_equal(res.json['data'][0]['type'], 'comments')
def get_redirect_url(self, **kwargs): guid = Guid.load(kwargs['guids']) if guid: referent = guid.referent if getattr(referent, 'absolute_api_v2_url', None): return referent.absolute_api_v2_url else: raise EndpointNotImplementedError() return None
def get_target(self, node_id, target_id): target = Guid.load(target_id) if not target or not getattr(target.referent, 'belongs_to_node', None): raise ValueError('Invalid comment target.') elif not target.referent.belongs_to_node(node_id): raise ValueError('Cannot post to comment target on another node.') elif isinstance(target.referent, StoredFileNode) and target.referent.provider not in osf_settings.ADDONS_COMMENTABLE: raise ValueError('Comments are not supported for this file provider.') return target
def test_find_unread_includes_comment_replies(self): project = ProjectFactory() user = UserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=user) reply = CommentFactory(node=project, target=Guid.load(comment._id), user=project.creator) n_unread = Comment.find_n_unread(user=user, node=project, page='node') assert_equal(n_unread, 1)
class TestMigrateLegacyTagGUIDObjects(OsfTestCase): def setUp(self): OsfTestCase.setUp(self) tag = TagFactory() self.target_guid = Guid(referent=tag) self.target_guid.save() self.nontarget_guid = Guid(referent=NodeFactory()) def test_get_targets(self): result = list(get_targets()) assert_in(self.target_guid, result) assert_not_in(self.nontarget_guid, result) def test_do_migration(self): # sanity check assert_equal(len(list(get_targets())), 1) do_migration() assert_equal(len(list(get_targets())), 0)
def update_comment_targets_to_guids(): comments = Comment.find() for comment in comments: # Skip comments on deleted files if not comment.target: continue if isinstance(comment.root_target, StoredFileNode): comment.root_target = comment.root_target.get_guid() elif comment.root_target: comment.root_target = Guid.load(comment.root_target._id) if isinstance(comment.target, StoredFileNode): comment.target = comment.target.get_guid() else: comment.target = Guid.load(comment.target._id) comment.save() logger.info('Migrated root_target and target for comment {0}'.format( comment._id))
def test_private_node_only_logged_in_contributor_commenter_can_delete_own_reply( self): self._set_up_private_project_with_comment() reply_target = Guid.load(self.comment._id) reply = CommentFactory(node=self.private_project, target=reply_target, user=self.user) reply_url = '/{}comments/{}/'.format(API_BASE, reply) res = self.app.delete_json_api(reply_url, auth=self.user.auth) assert_equal(res.status_code, 204)
def _set_up_public_project_with_comment(self): self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level='private') self.public_project.add_contributor(self.contributor, save=True) with mock.patch('osf.models.AbstractNode.update_search'): self.public_wiki = NodeWikiFactory(node=self.public_project, user=self.user) self.public_comment = CommentFactory(node=self.public_project, target=Guid.load( self.public_wiki._id), user=self.user) reply_target = Guid.load(self.public_comment._id) self.public_comment_reply = CommentFactory(node=self.public_project, target=reply_target, user=self.user) self.public_url = '/{}comments/{}/'.format(API_BASE, self.public_comment._id) self.public_comment_payload = self._set_up_payload( self.public_comment._id)
def _build(cls, target_class, *args, **kwargs): node = kwargs.pop("node", None) or NodeFactory() user = kwargs.pop("user", None) or node.creator target = kwargs.pop("target", None) or Guid.load(node._id) content = kwargs.pop("content", None) or "Test comment." instance = target_class(node=node, user=user, target=target, content=content, *args, **kwargs) if isinstance(target.referent, target_class): instance.root_target = target.referent.root_target else: instance.root_target = target return instance
def test_public_node_non_contributor_commenter_cannot_update_own_wiki_comment_if_comment_level_private(self): project = ProjectFactory(is_public=True) test_wiki = NodeWikiFactory(node=project, user=self.user) comment = CommentFactory(node=project, target=Guid.load(test_wiki), user=self.non_contributor) project.comment_level = 'private' project.save() url = '/{}comments/{}/'.format(API_BASE, comment._id) payload = self._set_up_payload(comment._id) res = self.app.put_json_api(url, payload, auth=self.non_contributor.auth, expect_errors=True) assert_equal(res.status_code, 403) assert_equal(res.json['errors'][0]['detail'], 'You do not have permission to perform this action.')
def get_guid(self): """Attempt to find a Guid that points to this object. :rtype: Guid or None """ try: # Note sometimes multiple GUIDs can exist for # a single object. Just go with the first one return Guid.find(Q('referent', 'eq', self))[0] except IndexError: return None
def test_wiki_has_comments_link(self): self._set_up_public_project_with_wiki_page() res = self.app.get(self.public_url) assert_equal(res.status_code, 200) url = res.json['data']['relationships']['comments']['links'][ 'related']['href'] CommentFactory(node=self.public_project, target=Guid.load(self.public_wiki._id), user=self.user) res = self.app.get(url) assert_equal(res.status_code, 200) assert_equal(res.json['data'][0]['type'], 'comments')
def get_target(self, node_id, target_id): target = Guid.load(target_id) if not target or not getattr(target.referent, 'belongs_to_node', None): raise ValueError('Invalid comment target.') elif not target.referent.belongs_to_node(node_id): raise ValueError('Cannot post to comment target on another node.') elif isinstance( target.referent, StoredFileNode ) and target.referent.provider not in osf_settings.ADDONS_COMMENTABLE: raise ValueError( 'Comments are not supported for this file provider.') return target
def _set_up_registration_with_comment(self): self.registration = RegistrationFactory(creator=self.user) self.registration_url = '/{}registrations/{}/'.format( API_BASE, self.registration._id) self.registration_comment = CommentFactory(node=self.registration, user=self.user) self.comment_url = '/{}comments/{}/'.format( API_BASE, self.registration_comment._id) reply_target = Guid.load(self.registration_comment._id) self.registration_comment_reply = CommentFactory( node=self.registration, target=reply_target, user=self.user) self.replies_url = '/{}registrations/{}/comments/?filter[target]={}'.format( API_BASE, self.registration._id, self.registration_comment._id)