def test_provision_spam(self):
with self.make_context(data={'X-Mailgun-Sscore': message.SSCORE_MAX_VALUE + 1}):
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_false(self.node.is_public)
assert_in(self.conference.admins.first(), self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_in('spam', self.node.system_tags)
def test_provision_spam(self):
with self.make_context(data={'X-Mailgun-Sscore': message.SSCORE_MAX_VALUE + 1}):
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_false(self.node.is_public)
assert_in(self.conference.admins.first(), self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_in('spam', self.node.system_tags)
def test_provision_private(self):
self.conference.public_projects = False
self.conference.save()
with self.make_context():
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_false(self.node.is_public)
assert_in(self.conference.admins.first(), self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_not_in('spam', self.node.system_tags)
def test_provision(self):
with self.make_context():
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_true(self.node.is_public)
assert_in(self.conference.admins.first(), self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_in(self.conference.endpoint, self.node.system_tags)
assert_true(self.node.tags.filter(name=self.conference.endpoint).exists())
assert_not_in('spam', self.node.system_tags)
def test_provision_private(self):
self.conference.public_projects = False
self.conference.save()
with self.make_context():
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_false(self.node.is_public)
assert_in(self.conference.admins[0], self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_not_in('spam', self.node.system_tags)
def test_provision(self):
with self.make_context():
msg = message.ConferenceMessage()
utils.provision_node(self.conference, msg, self.node, self.user)
assert_true(self.node.is_public)
assert_in(self.conference.admins[0], self.node.contributors)
assert_in('emailed', self.node.system_tags)
assert_in(self.conference.endpoint, self.node.system_tags)
assert_in(self.conference.endpoint, self.node.tags)
assert_not_in('spam', self.node.system_tags)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(message.sender_email, CONFERENCE_FAILED, fullname=message.sender_display)
created = []
with TokuTransaction():
user, user_created = utils.get_or_create_user(message.sender_display, message.sender_email, message.is_spam)
if user_created:
created.append(user)
set_password_url = web_url_for("reset_password", verification_key=user.verification_key, _absolute=True)
else:
set_password_url = None
node, node_created = utils.get_or_create_node(message.subject, user)
if node_created:
created.append(node)
utils.provision_node(conference, message, node, user)
utils.record_message(message, created)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
"addon_view_or_download_file",
path=message.attachments[0].filename,
provider="osfstorage",
action="download",
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for("conference_results", meeting=message.conference_name, _absolute=True),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
can_change_preferences=False,
logo=settings.OSF_MEETINGS_LOGO
)
with transaction.atomic():
user, user_created = get_or_create_user(
message.sender_display,
message.sender_email,
is_spam=message.is_spam,
)
if user_created:
if utils.is_valid_email(user.fullname):
user.fullname = user._id # Users cannot use an email as their full name
user.save() # need to save in order to access m2m fields (e.g. tags)
user.add_system_tag('osf4m')
user.update_date_last_login()
user.save()
# must save the user first before accessing user._id
set_password_url = web_url_for(
'reset_password_get',
uid=user._id,
token=user.verification_key_v2['token'],
_absolute=True,
)
else:
set_password_url = None
# Always create a new meeting node
node = Node.objects.create(
title=message.subject,
creator=user
)
node.add_system_tag('osf4m')
node.save()
utils.provision_node(conference, message, node, user)
created_user = user if user_created else None
utils.record_message(message, node, created_user)
# Prevent circular import error
from framework.auth import signals as auth_signals
if user_created:
auth_signals.user_confirmed.send(user)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
can_change_preferences=False,
logo=settings.OSF_MEETINGS_LOGO
)
if user_created:
signals.osf4m_user_created.send(user, conference=conference, node=node)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
)
created = []
with TokuTransaction():
user, user_created = get_or_create_user(
message.sender_display,
message.sender_email,
message.is_spam,
)
if user_created:
created.append(user)
user.system_tags.append('osf4m')
set_password_url = web_url_for(
'reset_password_get',
verification_key=user.verification_key,
_absolute=True,
)
user.date_last_login = datetime.utcnow()
user.save()
else:
set_password_url = None
node, node_created = utils.get_or_create_node(message.subject, user)
if node_created:
created.append(node)
node.system_tags.append('osf4m')
node.save()
utils.provision_node(conference, message, node, user)
utils.record_message(message, created)
# Prevent circular import error
from framework.auth import signals as auth_signals
if user_created:
auth_signals.user_confirmed.send(user)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
if node_created and user_created:
signals.osf4m_user_created.send(user, conference=conference, node=node)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
)
created = []
with TokuTransaction():
user, user_created = get_or_create_user(
message.sender_display,
message.sender_email,
message.is_spam,
)
if user_created:
created.append(user)
user.system_tags.append('osf4m')
set_password_url = web_url_for(
'reset_password',
verification_key=user.verification_key,
_absolute=True,
)
user.date_last_login = datetime.utcnow()
user.save()
else:
set_password_url = None
node, node_created = utils.get_or_create_node(message.subject, user)
if node_created:
created.append(node)
node.system_tags.append('osf4m')
node.save()
utils.provision_node(conference, message, node, user)
utils.record_message(message, created)
# Prevent circular import error
from framework.auth import signals as auth_signals
if user_created:
auth_signals.user_confirmed.send(user)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
if node_created and user_created:
signals.osf4m_user_created.send(user, conference=conference, node=node)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
)
nodes_created = []
users_created = []
with transaction.atomic():
user, user_created = get_or_create_user(
message.sender_display,
message.sender_email,
is_spam=message.is_spam,
)
if user_created:
user.save(
) # need to save in order to access m2m fields (e.g. tags)
users_created.append(user)
user.add_system_tag('osf4m')
user.update_date_last_login()
user.save()
# must save the user first before accessing user._id
set_password_url = web_url_for(
'reset_password_get',
uid=user._id,
token=user.verification_key_v2['token'],
_absolute=True,
)
else:
set_password_url = None
node, node_created = Node.objects.get_or_create(
title__iexact=message.subject,
is_deleted=False,
_contributors__guids___id=user._id,
defaults={
'title': message.subject,
'creator': user
})
if node_created:
nodes_created.append(node)
node.add_system_tag('osf4m')
node.save()
utils.provision_node(conference, message, node, user)
utils.record_message(message, nodes_created, users_created)
# Prevent circular import error
from framework.auth import signals as auth_signals
if user_created:
auth_signals.user_confirmed.send(user)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
if node_created and user_created:
signals.osf4m_user_created.send(user, conference=conference, node=node)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
)
created = []
with TokuTransaction():
user, user_created = utils.get_or_create_user(
message.sender_display,
message.sender_email,
message.is_spam,
)
if user_created:
created.append(user)
set_password_url = web_url_for(
'reset_password',
verification_key=user.verification_key,
_absolute=True,
)
else:
set_password_url = None
node, node_created = utils.get_or_create_node(message.subject, user)
if node_created:
created.append(node)
utils.provision_node(conference, message, node, user)
utils.record_message(message, created)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
def add_poster_by_email(conference, message):
"""
:param Conference conference:
:param ConferenceMessage message:
"""
# Fail if no attachments
if not message.attachments:
return send_mail(
message.sender_email,
CONFERENCE_FAILED,
fullname=message.sender_display,
)
nodes_created = []
users_created = []
with transaction.atomic():
user, user_created = get_or_create_user(
message.sender_display,
message.sender_email,
is_spam=message.is_spam,
)
if user_created:
user.save() # need to save in order to access m2m fields (e.g. tags)
users_created.append(user)
user.add_system_tag('osf4m')
user.update_date_last_login()
user.save()
# must save the user first before accessing user._id
set_password_url = web_url_for(
'reset_password_get',
uid=user._id,
token=user.verification_key_v2['token'],
_absolute=True,
)
else:
set_password_url = None
node, node_created = Node.objects.get_or_create(
title__iexact=message.subject,
is_deleted=False,
_contributors__guids___id=user._id,
defaults={
'title': message.subject,
'creator': user
}
)
if node_created:
nodes_created.append(node)
node.add_system_tag('osf4m')
node.save()
utils.provision_node(conference, message, node, user)
utils.record_message(message, nodes_created, users_created)
# Prevent circular import error
from framework.auth import signals as auth_signals
if user_created:
auth_signals.user_confirmed.send(user)
utils.upload_attachments(user, node, message.attachments)
download_url = node.web_url_for(
'addon_view_or_download_file',
path=message.attachments[0].filename,
provider='osfstorage',
action='download',
_absolute=True,
)
# Send confirmation email
send_mail(
message.sender_email,
CONFERENCE_SUBMITTED,
conf_full_name=conference.name,
conf_view_url=web_url_for(
'conference_results',
meeting=message.conference_name,
_absolute=True,
),
fullname=message.sender_display,
user_created=user_created,
set_password_url=set_password_url,
profile_url=user.absolute_url,
node_url=node.absolute_url,
file_url=download_url,
presentation_type=message.conference_category.lower(),
is_spam=message.is_spam,
)
if node_created and user_created:
signals.osf4m_user_created.send(user, conference=conference, node=node)
