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