def project_accept_submission_requirements(request, project_uuid):
try:
project = limsfm_get_project(project_uuid)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
if request.method == 'POST':
form = ProjectAcceptTermsForm(request.POST)
if form.is_valid():
try:
limsfm_update_project(project_uuid, form.cleaned_data)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
else:
slack_message('portal/slack/limsfm_project_accepted_submission_requirements.slack',
{'uuid': project_uuid, 'form': form})
gmo_flag_to_file(
project['reference'],
form.cleaned_data['submission_requirements_name'],
form.cleaned_data['gmo_samples']
)
return HttpResponseRedirect(reverse(project_detail, args=[project_uuid]))
else:
form = ProjectAcceptTermsForm()
# GET request, or invalid/failed POST
return render(
request, 'portal/accept_submission_requirements.html',
{
'project': project,
'terms_form': form,
})
def confirm_order(order, charge_id, charge_created):
logger.info('confirm_order', order=order.order_id, charge_id=charge_id)
with transaction.atomic():
order.confirm(charge_id, charge_created)
send_receipt(order)
send_ticket_invitations(order)
slack_message('tickets/order_created.slack', {'order': order})
def post_create(request):
author = get_object_or_404(RedditAccount, owner_id=request.user.id)
if request.method == "POST":
form = PostForm(request.POST, user=request.user, initial={'author': author.id})
if form.is_valid():
post = form.save(commit=False)
post.modified_time = datetime.datetime.now()
if not request.user.is_staff:
post.author_id = author.id
slack_message('slack/postCreateRich.slack', {
'author': author,
'post': post,
},
[{
'title': post.title,
'text': post.body,
},])
post = form.save()
return redirect('post_list')
else:
form = PostForm(user=request.user, initial={'author': author})
template = loader.get_template('postEdit.html')
context = {
'title': "New Post",
'form': form,
}
return HttpResponse(template.render(context, request))
def process_response(self, request, response):
"""
Send broken link emails for relevant 404 NOT FOUND responses.
"""
if response.status_code == 404 and not settings.DEBUG:
domain = request.get_host()
path = request.get_full_path()
referer = force_text(request.META.get('HTTP_REFERER', ''),
errors='replace')
if not self.is_ignorable_request(request, path, domain, referer):
ua = request.META.get('HTTP_USER_AGENT', '<none>')
ip = request.META.get('REMOTE_ADDR', '<none>')
subject = "Broken %slink on %s" % (
('INTERNAL ' if self.is_internal_request(domain, referer)
else ''), domain)
message = ("Referrer: %s\nRequested URL: %s\nUser agent: %s\n"
"IP address: %s\n" % (referer, path, ua, ip))
attachments = {
'subject': subject,
'text': message,
'color': 'warning',
}
template = 'django_slack/exception.slack'
slack_message(template, {'text': subject}, [attachments])
return response
def test_backend_override(self):
"""
Ensure the backend can be overridden.
"""
with override_settings(SLACK_BACKEND='tests.backends.RaisingBackend'):
with self.assertRaises(RaisingBackend.RaisedException):
slack_message('test.slack', {'text': 'test'})
def project_accept_submission_requirements(request, project_uuid):
if request.method == 'POST':
form = ProjectAcceptTermsForm(request.POST)
if form.is_valid():
try:
limsfm_update_project(project_uuid, form.cleaned_data)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
else:
slack_message('portal/slack/limsfm_project_accepted_submission_requirements.slack',
{'uuid': project_uuid, 'form': form})
return HttpResponseRedirect(reverse(project_detail, args=[project_uuid]))
else:
form = ProjectAcceptTermsForm()
# GET request, or invalid/failed POST
try:
project = limsfm_get_project(project_uuid)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
return render(
request, 'portal/accept_submission_requirements.html',
{
'project': project,
'terms_form': form,
})
def new_nomination(request):
if request.user.is_authenticated and request.user.get_nomination():
messages.warning(request, 'You have already submitted a nomination')
return redirect(request.user.get_nomination())
if request.method == 'POST':
if not request.user.is_authenticated:
return redirect(settings.LOGIN_URL)
form = NominationForm(request.POST)
if form.is_valid():
nomination = form.save(commit=False)
nomination.nominee = request.user
nomination.save()
messages.success(request,
'Thank you for submitting your nomination')
slack_message('ukpa/nomination_created.slack',
{'nomination': nomination})
return redirect(nomination)
else:
form = NominationForm()
context = {
'form': form,
}
return render(request, 'ukpa/new_nomination.html', context)
def test_backend_override(self):
"""
Ensure the backend can be overridden.
"""
with override_settings(SLACK_BACKEND='tests.backends.RaisingBackend'):
with self.assertRaises(RaisingBackend.RaisedException):
slack_message('test.slack', {'text': 'test'})
def update_previous_day_reports(day=None):
"""
Complete all report data for the previous day.
:arg day: An optional datetime object representing a day.
"""
start_date, _ = _get_day(day)
if not day:
# If not specified,
# do the previous day now that the day is complete
start_date -= datetime.timedelta(days=1)
# Do all reports
daily_update_geos(start_date)
daily_update_placements(start_date)
daily_update_impressions(start_date)
daily_update_keywords(start_date)
daily_update_uplift(start_date)
daily_update_regiontopic(start_date)
if not day:
# Send notification to Slack about previous day's reports
# Don't send this notification if run manually
slack_message(
"adserver/slack/generic-message.slack",
{
"text": f"Completed aggregating report data for yesterday ({start_date:%Y-%m-%d}). :page_with_curl:"
},
)
def new_application(request):
if not _can_submit(request):
return _new_application_after_cfp_closes(request)
if request.user.is_authenticated and request.user.get_grant_application():
messages.warning(request, 'You have already submitted an application')
return redirect(request.user.get_grant_application())
if request.method == 'POST':
if not request.user.is_authenticated:
return redirect(settings.LOGIN_URL)
form = ApplicationForm(request.POST)
if form.is_valid():
application = form.save(commit=False)
for day in DAYS:
if day in form.cleaned_data['days']:
setattr(application, day, True)
else:
setattr(application, day, False)
application.applicant = request.user
application.save()
messages.success(request,
'Thank you for submitting your application')
slack_message('grants/application_created.slack',
{'application': application})
return redirect(application)
else:
form = ApplicationForm()
context = {
'form': form,
'js_paths': ['grants/application_form.js'],
}
return render(request, 'grants/new_application.html', context)
def send_messages(self, email_messages):
for message in email_messages:
attachments = [
{
'fallback':
'メール',
'fields': [
{
'title': 'From',
'value': message.from_email
},
{
'title': 'To',
'value': ','.join(message.to)
},
{
'title': '件名',
'value': message.subject,
},
{
'title': '本文',
'value': message.body,
},
],
},
]
slack_message('slacks/slack_email.slack',
{'slack': settings.SLACK_EMAIL_CHANNEL}, attachments)
def register(request):
if request.method == 'POST':
form = UserRegisterForm(request.POST)
if form.is_valid():
user = form.save()
user.refresh_from_db()
team_name = form.cleaned_data.get('team_name')
user.team.name = team_name
captain = form.cleaned_data.get('team_captain')
user.team.captain = captain
user.save()
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=user.username, password=raw_password)
login(request, user)
messages.success(request, f'{team_name} successfully registered!')
slack_message('users/reg.slack', {
'captain': captain,
'team': team_name,
'emoji': 'squirrel',
})
return redirect('hunt20-home')
else:
form = UserRegisterForm()
return render(request, 'users/register.html', {'form': form})
def new_user_manager_notification(request, user, **kwargs):
"""
Sends an email notification and a slack message upon successful user signup.
The Email is sent to the site managers.
The slack message is sent to the default slack channel from the project settings.
:param request:
:param user:
:param kwargs:
:return:
"""
# manager_group, created_group = Group.objects.get_or_create(name="managers")
# managers = [user.email for user in manager_group.user_set.all()]
# TODO: Switch to managers group as soon as it is stable
managers = ['*****@*****.**']
username = str(user.username)
reply_email = user.email
subject = "New user: {}".format(username)
message = "Hurray! {} has joined the circle of legends.".format(username)
email = EmailMessage(subject=subject,
body=message,
to=managers,
reply_to=reply_email)
email.send(fail_silently=True)
slack_message('slack/message.slack', {
'message': '@channel: {}'.format(message),
},
fail_silently=False)
def send_message(self, message, recipient, source, **kwargs):
target_rooms = self.slack_channels(source, **kwargs)
if not any(target_rooms) or not settings.SLACK_TOKEN:
errors = list()
if not target_rooms:
errors.append('Room ID')
if not settings.SLACK_TOKEN:
errors.append('Slack Token')
return 'Missing configuration: {}'.format(', '.join(errors))
message = ' '.join([recipient, message]).strip()
data = {
"message": message,
}
for room in target_rooms:
try:
slack_message('messages/slack_message.html',
data,
channel=room)
except Exception as e:
logger.exception(e)
return '400: Bad Request'
return '200: OK'
def publish(request):
try:
pk = int(request.GET.get('pk'))
page_type = request.GET.get('type')
if request.GET.get('lessons') == 'true':
children = True
else:
children = False
klass = globals()[page_type]
obj = klass.objects.get(pk=pk)
if request.GET.get('pdf') == 'true':
as_pdf = True
pub_func = obj.publish_pdfs
else:
as_pdf = False
pub_func = obj.publish
slack_message('slack/message.slack', {
'message': 'kicked off a publish of %s %s \n With children: %s\n As pdf: %s'
% (page_type, obj.title, children, as_pdf),
'user': request.user,
})
except Exception, e:
logger.exception('Publishing failed')
return HttpResponse(e.message, content_type='application/json', status=500)
def notify_of_completed_flights():
"""Send a note and close flights which completed in the last day."""
cutoff = get_ad_day() - datetime.timedelta(days=1)
for flight in Flight.objects.filter(live=True):
if (
flight.clicks_remaining() == 0
and flight.views_remaining() == 0
and AdImpression.objects.filter(
date__gte=cutoff, advertisement__flight=flight
).exists()
):
log.info("Flight %s finished in the last day.", flight)
# Send notification about this flight
slack_message(
"adserver/slack/flight-complete.slack",
{
"flight": flight,
"flight_url": generate_absolute_url(flight.get_absolute_url()),
},
)
# Mark the flight as no longer live. It is complete
flight.live = False
flight.save()
def new_user_notification(request, user, **kwargs):
"""
Sends an email notification and a chat message upon successful user signup.
The Email is sent to the site managers.
The chat message is sent to the default slack channel from the project settings.
:param request:
:param user:
:param kwargs:
:return:
"""
# manager_group, created_group = Group.objects.get_or_create(name="managers")
# managers = [user.email for user in manager_group.user_set.all()]
# TODO: Switch to managers group as soon as it is stable
managers = ['*****@*****.**']
reply_emails = [user.email]
subject = f"New user: {user.username}"
message = f"Hurray! {user.name} has joined the circle of legends."
email = EmailMessage(subject=subject, body=message, to=managers, reply_to=reply_emails)
email.send()
embed = {
'author': {
'name': user.name,
'icon_url': user.get_avatar()
},
'description': f'I want us to make {user.name} feel welcome here. ;)'
}
send_chat_message.delay(message, embeds=[embed], channel=Channel.COMMUNITY.value)
slack_message('slack/message.slack', {'message': '@channel: {}'.format(message), }, fail_silently=False)
def unit_pjspdf(request, slug, unit_slug):
output = PdfFileWriter()
unit = get_object_or_404(Unit, curriculum__slug=slug, slug=unit_slug)
data = {
"url": get_url_for_pdf(request, unit.get_absolute_url(), True),
"renderType": "pdf"
}
url = 'http://PhantomJScloud.com/api/browser/v2/%s/' % settings.PHANTOMJS_KEY
headers = {'content-type': 'application/json'}
req = Request(url, json.dumps(data), headers)
response = urlopen(req)
results = response.read()
print '\nresponse status code'
print response.code
print '\nresponse headers (pay attention to pjsc-* headers)'
print response.headers
memoryPDF = StringIO(results)
localPDF = PdfFileReader(memoryPDF)
output.appendPagesFromReader(localPDF)
pdfresponse = HttpResponse(content_type='application/pdf')
output.write(pdfresponse)
pdfresponse['Content-Disposition'] = 'inline;filename=unit%s.pdf' % unit.number
slack_message('slack/message.slack', {
'message': 'created a PDF from %s %s' % (slug, unit_slug),
'user': request.user,
})
return pdfresponse
def task_postrun_slack(signal=None,
sender=None,
task_id=None,
task=None,
args=None,
retval=None,
state=None,
**kwargs):
if settings.SLACK_CHANNEL:
ttask = models.TatlTask.objects.get(celery_uuid=task_id)
slack_message('slack/blank', {}, [{
"mrkdwn_in": ["text", "pretext", "fields"],
"title":
"Task ended",
"title_link":
"",
"text":
"Task %s (`%s`) for `%s` finished with state *%s*" %
(task.name, task_id,
ttask.user.username if ttask.user else 'unknown', state),
"footer":
"Task end spotted by Majora",
"footer_icon":
"https://avatars.slack-edge.com/2019-05-03/627972616934_a621b7d3a28c2b6a7bd1_512.jpg",
"ts":
int(timezone.now().timestamp()),
}])
def gong(request):
user = "******" % request.POST.get("user_name", "somebody")
reason = request.POST.get("text", "Gonged stuff!")
slack_message('slack/gonged.slack', {
'user': user,
'reason': reason
})
attachments = [
{
'author_name': user,
'title': reason,
'image_url': 'https://curriculum.code.org/images/gong.gif',
'color': '#00adbc'
}
]
payload = {
"response_type": "in_channel",
"attachments": attachments,
}
record = Record(user=user, reason=reason)
record.save()
return Response(payload, content_type='application/json')
def announce_perm_flex(sender, instance, **kwargs):
if settings.SLACK_CHANNEL_TATL:
ext = ''
if instance.extra_context:
try:
ext = "\n```%s```" % json.dumps(json.loads(
instance.extra_context),
indent=4,
sort_keys=True)
except Exception as e:
pass
try:
slack_message('slack/permflex', {
"channel": settings.SLACK_CHANNEL_TATL,
}, [{
"text":
"User `%s` flexed their `%s` permission on `%s` at %s %s" % (
instance.user,
instance.used_permission,
str(instance.content_object),
str(instance.timestamp),
ext,
),
}])
except:
pass
def send_message(self,
message,
request,
recipients=None,
related=None,
**kwargs):
if not self.destination or not self.target_room or not settings.SLACK_TOKEN:
errors = list()
if not self.destination:
errors.append('Destination URL')
if not self.target_room:
errors.append('Room ID')
if not settings.SLACK_TOKEN:
errors.append('Slack Token')
return 'Missing configuration: {}'.format(', '.join(errors))
slack_users = self.slack_users(recipients) if recipients else ''
slack_link = self.slack_link(request, related, **
kwargs) if related else ''
message = ' '.join([slack_users, message, slack_link]).strip()
data = {
"message": message,
}
try:
slack_message('messages/slack_message.html',
data,
channel=self.target_room)
return '200: OK'
except Exception as e:
logger.exception(e)
return '400: Bad Request'
def form_valid(self, form):
# 作成者を登録
form.instance.create_user = self.request.user
# Contact のインスタンスを作成
response = super().form_valid(form)
# 初期閲覧部署を登録
form.instance.department_list.set(
form.instance.contact_kind.department_list.all())
# お問い合わせ作成者にメールを送信
penguin_send_mail('お問い合わせを送信しました', [self.request.user],
'communication/mails/contact_create.txt',
{'contact': form.instance})
# 事務局員に slack を送信
slack_message('communication/slacks/contact_create.slack',
{'slack': form.instance.contact_kind.slack},
form.instance.get_slack_attachments)
# メッセージを追加
messages.success(self.request, 'お問い合わせを事務局員に送信しました！')
return response
def handle_limsfm_request_exception(request, e):
ERROR_MESSAGE = ("The MicrobesNG customer portal is temporarily "
"unavailable. Please try again later.")
messages.error(request, ERROR_MESSAGE)
slack_message('portal/slack/limsfm_request_exception.slack',
{'e': e, 'path': request.path})
print(e)
return 503 # http status
def send_slack_message(template, context=None, attachments=None):
try:
slack_message(template, context, attachments)
except Exception as err:
logging.getLogger('common').error(
"Slack message failed, raised exception: {0}, with stack trace: {1}"
.format(err, traceback.format_exc()))
def test_escape_chars(self):
"""
Test the characters Slack wants escaped.
See <https://api.slack.com/docs/formatting#how_to_escape_characters>
"""
slack_message('escape.slack', {'text': '< > &'})
self.assertMessage(text='< > &')
def test_escape_chars(self):
"""
Test the characters Slack wants escaped.
See <https://api.slack.com/docs/formatting#how_to_escape_characters>
"""
slack_message('escape.slack', {'text': '< > &'})
self.assertMessage(text='< > &')
def test_escaped(self):
"""
Simple test of the Django escaping to illustrate problem.
"""
slack_message('test.slack', {'text': '< > & " \''})
if django.VERSION[0] >= 3:
self.assertMessage(text='< > & " '')
else:
self.assertMessage(text='< > & " '')
def activity_save_receiver(sender, instance, *args, **kwargs):
if instance.type == DEBIT:
instance.user.bank_balance -= instance.value
elif instance.type == CREDIT:
instance.user.bank_balance += instance.value
slack_message('slack/gain_credit.slack', {
'obj': instance,
})
instance.user.save()
def orderitem_save_receiver(sender, instance, created, *args, **kwargs):
if created:
total = instance.cost()
instance.order.value += total
instance.order.save()
Activity.objects.create(user=instance.order.user, type=DEBIT, value=total)
slack_message('slack/buy_item.slack', {
'obj': instance,
})
def project_detail(request, project_uuid):
# Fetch project from lims
project = None
try:
project = limsfm_get_project(project_uuid)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
if not project:
# Template will report error messages
return render(request, 'portal/project.html', {'project': project})
# Check whether user needs to accept submission requirements
if not (project['submission_requirements_name']
or project['meta_data_status'] == 'Accepted'
or project['all_content_received_date']
): # Redirect to accept submission requirements
return HttpResponseRedirect(
reverse(project_accept_submission_requirements,
args=[project_uuid]))
context = {
'project': project,
'project_add_collaborator_form': ProjectAddCollaboratorForm(),
'project_ena_form': ProjectEnaForm(initial=project),
'upload_sample_sheet_form': UploadSampleSheetForm()
}
if project['is_confidential'] or project['ena_title']:
# Render full project portal
if request_should_post_to_slack(request):
slack_message('portal/slack/limsfm_project_detail_access.slack', {
'request': request,
'project': project
})
return render(request, 'portal/project.html', context)
else:
# Collect ena title/abstract before proceeding to portal
if project['meta_data_status'] == 'Accepted':
messages.warning(
request,
"We did not previously collect your project title & description as part of our initial setup process, "
"so we need to request this data retrospectively. We appreciate your cooperation."
)
else:
messages.warning(
request,
"Please complete your project title & description in order to proceed to your portal."
)
if request_should_post_to_slack(request):
slack_message('portal/slack/limsfm_project_setup_access.slack', {
'request': request,
'project': project
})
return HttpResponseRedirect(
reverse(project_ena_details, args=[project_uuid]))
def form_valid(self, form):
slack_message('my_message.slack', {
'message': form.cleaned_data.get('contacter_message'),
'name': form.cleaned_data.get('contacter_name'),
'mail': form.cleaned_data.get('contacter_mail')
})
return super(ContactMe, self).form_valid(form)
def send_chat_notification(file, text, data):
from django_slack import slack_message
text = ("{text}\n{data}\n-- {file}").format(file=file, text=text, data=data)
if getattr(settings, 'SLACK_BACKEND', None) in (None, 'django_slack.backends.DisabledBackend'):
print "-- SLACK MESSAGE"
print text
print "----"
else:
slack_message('django-slack/text.slack', {"text": text})
def home(request):
region = request.user.userprofile.current_region
invite = InvitationForm(request.user)
teams = Team.objects.filter(teammember__user=request.user)
regionform = RegionSelectForm()
regionform.initial['region'] = region
for t in teams:
team_member = TeamMember.objects.get(team=t, user=request.user)
if request.user == t.creator or team_member.is_admin:
t.is_admin = True
t.active = True
## check if region is available
if region.disabled:
messages.error(request, 'The %s region is currently unavailable. Check the community forum for service status.' % (region.name))
t.active = False
continue
tenant = get_tenant_for_team(t, region)
if not tenant:
t.active = False
slack_message(
'home/slack/no_tenant_for_region.slack',
{'team': t, 'region': region, 'user': request.user})
continue
if region.name == 'bham':
t.horizon_endpoint = 'https://birmingham.climb.ac.uk'
elif region.name == 'cardiff':
t.horizon_endpoint = 'https://cardiff.climb.ac.uk'
elif region.name == 'warwick':
t.horizon_endpoint = 'http://stack.warwick.climb.ac.uk'
elif region.name == 'swansea':
t.horizon_endpoint = 'https://swansea.climb.ac.uk'
try:
t.launch_form = LaunchServerForm(tenant.get_flavors())
available_keys = [key for key in tenant.get_keys() if key[0] != "cloudman"]
t.launch_custom_form = LaunchImageServerForm(tenant.get_images(),tenant.get_flavors(), available_keys)
t.tenant_access = tenant
t.instances = list_instances(tenant)
except Exception, e:
messages.error(
request,
'The %s region is currently unavailable. Check the community '
'forum for service status.' % (region.name))
slack_message(
'home/slack/region_api_exception.slack',
{
'team': t,
'region': region,
'user': request.user,
'e': e
})
def test_fail_silently(self):
"""
Ensure fail silently can be overridden.
"""
# Note that this will fail if test_backend_override ever fails.
with override_settings(
SLACK_FAIL_SILENTLY=True,
SLACK_BACKEND='tests.backends.RaisingBackend',
):
slack_message('test.slack', {'text': 'test'})
def test_fail_silently(self):
"""
Ensure fail silently can be overridden.
"""
# Note that this will fail if test_backend_override ever fails.
with override_settings(
SLACK_FAIL_SILENTLY=True,
SLACK_BACKEND='tests.backends.RaisingBackend',
):
slack_message('test.slack', {'text': 'test'})
def log(message):
"""
Generic helper for logging information from the sync process. Message is
logged to the console mostly for debugging purposes, and is logged to slack
for actual use.
"""
print(message) # pylint: disable=superfluous-parens
slack_message('slack/message.slack', {
'message': message
})
def handle_limsfm_request_exception(request, e):
ERROR_MESSAGE = ("The MicrobesNG customer portal is temporarily "
"unavailable. Please try again later.")
messages.error(request, ERROR_MESSAGE)
slack_message('portal/slack/limsfm_request_exception.slack', {
'e': e,
'path': request.path
})
print(e)
return 503 # http status
def todo_add(request):
if request.method == "POST":
form = TodoForm(request.POST)
if form.is_valid():
todo = form.save(commit=False)
slack_message('blog/message.slack', {"message": todo.content})
todo.save()
return redirect('list')
else:
form = TodoForm()
return render(request, "blog/forms.html", {"form": form})
def handle_limsfm_http_exception(request, e):
ERROR_MESSAGE = ("An unexpected error has occured. "
"Please contact [email protected]")
if e.response.status_code == 404:
raise Http404
else:
messages.error(request, ERROR_MESSAGE)
slack_message('portal/slack/limsfm_http_exception.slack',
{'e': e, 'path': request.path})
print(e)
return 500 # http status
def recv_new_sample(sender, sample_id, submitter, **kwargs):
if settings.SLACK_CHANNEL:
slack_message(
'slack/blank',
{},
[{
"text": "Sample %s uploaded from %s" % (sample_id, submitter),
#"footer": "New sample spotted by Majora",
#"footer_icon": "https://avatars.slack-edge.com/2019-05-03/627972616934_a621b7d3a28c2b6a7bd1_512.jpg",
#"ts": int(time.time()),
}])
def start_guiding_process(request, user, **kwargs):
# Create a new guide relation
relation = user.guiderelation
# Notify potential guides
username = user.username
location = reverse('guides:list')
url = request.build_absolute_uri(location)
message = "{} is looking for a guide: {}".format(username, url)
# TODO: Fix backend isse: https://app.getsentry.com/eraldo/colegend-staging/issues/102969964/
# Then remove fail_silently
slack_message('slack/message.slack', {'message': '@channel: {}'.format(message), 'channel': 'cloudguide'},
fail_silently=True)
def send_chat_notification(file, text, data):
from django_slack import slack_message
text = ("{text}\n{data}\n-- {file}").format(file=file,
text=text,
data=data)
if getattr(settings, 'SLACK_BACKEND',
None) in (None, 'django_slack.backends.DisabledBackend'):
print "-- SLACK MESSAGE"
print text
print "----"
else:
slack_message('django-slack/text.slack', {"text": text})
def unit_resources_pdf(request, slug, unit_slug):
merger = PdfFileMerger()
unit = get_object_or_404(Unit, curriculum__slug=slug, slug=unit_slug)
for lesson in unit.lessons.exclude(keywords__keyword__slug="optional"):
lesson_string = render_to_string("curricula/lesson_title.html", {'unit': unit, 'lesson': lesson},
request=request)
lesson_page = pdfkit.from_string(lesson_string, False, options=settings.WKHTMLTOPDF_CMD_OPTIONS, configuration=pdfkit_config)
lesson_page_pdf = StringIO(lesson_page)
merger.append(PdfFileReader(lesson_page_pdf))
for resource in lesson.resources.all():
if resource.gd:
try:
remotePDF = urlopen(Request(resource.gd_pdf())).read()
memoryPDF = StringIO(remotePDF)
localPDF = PdfFileReader(memoryPDF)
merger.append(localPDF)
except Exception:
attachments = [
{
'color': 'danger',
'title': 'URL',
'text': resource.url,
},
{
'color': 'danger',
'title': 'Related Lesson',
'text': lesson.get_absolute_url(),
},
]
ip = get_real_ip(request)
slack_message('slack/message.slack', {
'message': "tried and failed to publish resource %s - %s (pk %s). "
"Check to ensure that it's a publicly accessible Google Doc"
% (resource.name, resource.type, resource.pk),
'user': request.user.get_username() or ip,
}, attachments)
return HttpResponse('PDF Generation Failed', status=500)
response = HttpResponse(content_type='application/pdf')
merger.write(response)
response['Content-Disposition'] = 'inline;filename=unit%s_resources.pdf' % unit.number
ip = get_real_ip(request)
slack_message('slack/message.slack', {
'message': 'created a resource PDF from %s %s' % (slug, unit_slug),
'user': request.user.get_username() or ip,
})
return response
def send_feeback(sender, subject='', message=''):
# TODO: Getting managers via dynamic role filtering.
managers = ['*****@*****.**']
if subject:
message = '{subject}\n{message}'.format(subject=subject, message=message)
subject = 'Feedback from {name} ({username})'.format(name=sender.name, username=sender.username)
email = EmailMessage(subject=subject, body=message, to=managers, reply_to=[sender.email])
email.send()
slack_message('slack/message.slack', {'message': '@channel: {}'.format(message), }, fail_silently=True)
def handle_limsfm_http_exception(request, e):
ERROR_MESSAGE = ("An unexpected error has occured. "
"Please contact [email protected]")
if e.response.status_code == 404:
raise Http404
else:
messages.error(request, ERROR_MESSAGE)
slack_message('portal/slack/limsfm_http_exception.slack', {
'e': e,
'path': request.path
})
print(e)
return 500 # http status
def publish_pdfs(self, *args, **kwargs):
if self.jackfrost_can_build():
try:
read, written = build_single(self.get_pdf_url())
slack_message('slack/message.slack', {
'message': 'published %s %s' % (self.content_model, self.title),
'color': '#00adbc'
})
yield json.dumps(written)
yield '\n'
except Exception, e:
yield json.dumps(e.message)
yield '\n'
logger.exception('Failed to publish PDF for %s' % self)
def send_slack_message(request, menu):
"""
Utility function that send a notification message via the Slack channel specified in the
settings file through a Celery backend (which means is done asynchronously).
The message contains the link to the new menu.
Arguments:
**menu**
A Menu model object which will be used to form the message's menu link
"""
slack_message('slack/new_menu_notification.slack', {
'menu': menu,
'host': Site.objects.get_current().domain
})
def perform_create(self, serializer):
ride = Ride.objects.get(id=self.kwargs.get('id'))
user = self.request.user
registration = serializer.save(
user=user,
ride=ride,
paid=False,
status=RideRiders.PENDING)
slack_message('slack/new_registration.slack', {
'user': user,
'ride': ride,
'reg': registration
})
def perform_update(self, serializer):
"""
Charge the user for the ride fee and then update the status of
their RideRider entry. The current status must be 'accepted'
and the logged in user must be the owner of the record.
"""
request = self.request
ride = Ride.objects.get(id=self.kwargs.get('id'))
amount = request.data.get('amount')
# Check that there is actually space left on the ride
# People shouldn't get here if there isn't but let's make sure we don't
# charge anyone if there isn't enough space on the ride
if ride.spaces_left == 0:
raise ValidationError("This ride is already at full capacity")
# Determine how much we are charging this user (either the minimum
# contribution or more if they have explicitely specified more)
if amount is None:
amount = ride.price
else:
amount = float(amount)
if amount < ride.price:
raise ValidationError("The amount can't be less than the price of the ride.")
# Go ahead and charge them!
if ride.price > 0:
try:
sale = Sale.charge(
request.data.get('token'),
ride.chapter.private_key,
int(amount * 100),
ride.currency,
"Techbikers {0}: {1}".format(ride.name, request.user.email),
request.user.email)
except stripe.error.CardError, e:
raise ValidationError(e.json_body['error'])
sale.rider_id = request.user.id
sale.save()
slack_message('slack/completed_registration.slack', {
'user': request.user,
'ride': ride,
'amount': amount
})
serializer.save(status=RideRiders.REGISTERED, paid=True, sale=sale)
def publish(self, children=False, silent=False):
if self.jackfrost_can_build():
for url in self.jackfrost_urls():
try:
read, written = build_single(url)
if not silent:
slack_message('slack/message.slack', {
'message': 'published %s %s' % (self.content_model, self.title),
'color': '#00adbc'
})
yield json.dumps(written)
yield '\n'
except Exception, e:
yield json.dumps(e.message)
yield '\n'
logger.exception('Failed to publish %s' % url)
def project_detail(request, project_uuid):
# Fetch project from lims
project = None
try:
project = limsfm_get_project(project_uuid)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
if not project:
# Template will report error messages
return render(request, 'portal/project.html', {'project': project})
# Check whether user needs to accept submission requirements
if not (project['submission_requirements_name'] or
project['meta_data_status'] == 'Accepted' or
project['all_content_received_date']): # Redirect to accept submission requirements
return HttpResponseRedirect(reverse(project_accept_submission_requirements, args=[project_uuid]))
context = {
'project': project,
'project_add_collaborator_form': ProjectAddCollaboratorForm(),
'project_ena_form': ProjectEnaForm(initial=project),
'upload_sample_sheet_form': UploadSampleSheetForm()
}
if project['is_confidential'] or project['ena_title']:
# Render full project portal
if request_should_post_to_slack(request):
slack_message('portal/slack/limsfm_project_detail_access.slack',
{'request': request, 'project': project})
return render(request, 'portal/project.html', context)
else:
# Collect ena title/abstract before proceeding to portal
if project['meta_data_status'] == 'Accepted':
messages.warning(request, "We did not previously collect your project title & description as part of our initial setup process, "
"so we need to request this data retrospectively. We appreciate your cooperation.")
else:
messages.warning(request, "Please complete your project title & description in order to proceed to your portal.")
if request_should_post_to_slack(request):
slack_message('portal/slack/limsfm_project_setup_access.slack',
{'request': request, 'project': project})
return HttpResponseRedirect(reverse(project_ena_details, args=[project_uuid]))
def clone(request):
try:
pk = int(request.POST.get('pk'))
page_type = request.POST.get('type')
if request.POST.get('children') == 'true':
children = True
else:
children = False
klass = globals()[page_type]
obj = klass.objects.get(pk=pk)
cloneable = getattr(obj, "clone", None)
if not callable(cloneable):
logger.exception('%s is not cloneable' % obj.title)
return HttpResponse("Not cloneable", content_type='application/json', status=500)
attrs = request.POST.get('attrs', {})
exclude = request.POST.get('exclude', [])
duplicate = obj.clone(attrs=attrs, exclude=exclude, children=children)
slack_message('slack/message.slack', {
'message': 'cloned the %s %s'
% (page_type, obj.title),
'user': request.user,
})
redirect_url = duplicate.get_absolute_url()
if page_type in ['Block', 'Map', 'IDE']:
redirect_url = "/documentation%s" % redirect_url
payload = {'message': 'cloned to %s' % duplicate.title, 'redirect_url': redirect_url, 'status': 200}
return HttpResponse(json.dumps(payload), content_type='application/json', status=payload.get('status', 200))
except Exception, e:
logger.exception('Cloning failed')
return HttpResponse(e.message, content_type='application/json', status=500)
def old_publish(request):
try:
pk = int(request.POST.get('pk'))
page_type = request.POST.get('type')
if request.POST.get('lessons') == 'true':
children = True
else:
children = False
klass = globals()[page_type]
obj = klass.objects.get(pk=pk)
if request.POST.get('pdf') == 'true':
payload = obj.publish_pdfs()
else:
payload = obj.publish(children=children)
attachments = [
{
'color': '#00adbc',
'title': 'URL',
'text': obj.get_absolute_url(),
},
{
'color': '#00adbc',
'title': 'Publishing Details',
'text': json.dumps(payload),
},
]
slack_message('slack/message.slack', {
'message': 'published %s %s' % (page_type, obj.title),
'user': request.user,
}, attachments)
except Exception, e:
payload = {'status': 500, 'error': 'failed', 'exception': e.message}
logger.exception('Publishing failed')
def projectline_update(request, project_uuid, projectline_uuid):
form = ProjectLineForm(request.POST)
if form.is_valid():
try:
limsfm_update_projectline(project_uuid, projectline_uuid,
form.cleaned_data)
except requests.HTTPError as e:
status = handle_limsfm_http_exception(request, e)
return JsonResponse(str(e))
except requests.RequestException as e:
status = handle_limsfm_request_exception(request, e)
return JsonResponse(str(e))
else:
slack_message('portal/slack/limsfm_projectline_update.slack',
{'form': form})
messages.success(request, "Saved")
status = 200
return JsonResponse(messages_to_json(request), status=status)
else:
json = form_errors_to_json(request, form)
return JsonResponse(json, status=400)
def project_ena_details(request, project_uuid):
# Handle POST
if request.method == 'POST':
form = ProjectEnaForm(request.POST)
if form.is_valid():
try:
limsfm_update_project(project_uuid, form.cleaned_data)
except requests.HTTPError as e:
status = handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
status = handle_limsfm_request_exception(request, e)
else:
slack_message('portal/slack/limsfm_project_ena_update.slack',
{'uuid': project_uuid, 'form': form})
messages.success(request, "Project ENA details saved.")
status = 200
if request.is_ajax():
return JsonResponse(messages_to_json(request), status=status)
else:
return HttpResponseRedirect(reverse(project_detail, args=[project_uuid]))
elif request.is_ajax():
return JsonResponse(form_errors_to_json(request, project_ena_form), status=400)
# GET request, or invalid/failed POST
project = None
try:
project = limsfm_get_project(project_uuid)
except requests.HTTPError as e:
handle_limsfm_http_exception(request, e)
except requests.RequestException as e:
handle_limsfm_request_exception(request, e)
else:
form = ProjectEnaForm(initial=project)
if request_should_post_to_slack(request):
slack_message('portal/slack/limsfm_project_setup_access.slack',
{'request': request, 'project': project})
context = {'project': project, 'project_ena_form': form}
return render(request, 'portal/project_setup.html', context)
def show_me_the_money(cls, sender: PayPalIPN, **kwargs):
from lindy.ticket.models import TicketAddOn
try:
ipn_obj = sender
custom = cls.parse_custom(ipn_obj.custom)
# super important do this first
Ticket.objects.filter(pk=custom.ticket_id).update(is_pending=True, is_checkout_finalized=True)
TicketAddOn.objects.filter(pk__in=custom.addon_ids).update(is_pending=True, is_checkout_finalized=True)
ticket = cls.objects.get(pk=custom.ticket_id)
logger.info(
'show me the money\n\t--> ipn: %s\n\t--> custom: %s\n\t--> ticket_id: %s\n\t--> custom_id: %s',
ipn_obj.id, ipn_obj.custom, ticket.id, custom.ticket_id
)
ticket.paypal_ipn_set.add(ipn_obj)
if ipn_obj.recurring:
ticket.is_subscription = True
with as_robot_user():
ticket.is_paid # NOTE: is_paid property scribbles on t._is_paid database value. Just needs to be saved.
ticket.save()
# Do this last, as it may fail
ipn_obj.admin_url = admin_url(ipn_obj)
slack_message(
'ticket/ipn.slack',
{
'ticket': ticket,
'ipn_obj': ipn_obj,
}
)
except Exception as e:
logger.exception(e)
def unit_pdf(request, slug, unit_slug):
buffer = StringIO()
c = pycurl.Curl()
c.setopt(c.WRITEDATA, buffer)
unit = get_object_or_404(Unit, curriculum__slug=slug, slug=unit_slug)
try:
c.setopt(c.URL, get_url_for_pdf(request, unit.get_compiled_url(), True))
print unit.get_compiled_url()
c.perform()
c.close()
compiled = buffer.getvalue()
except Exception:
logger.exception('PDF Curling Failed')
return HttpResponse('PDF Curling Failed', status=500)
if request.GET.get('html'): # Allows testing the html output
response = HttpResponse(compiled)
else:
try:
pdf = pdfkit.from_string(compiled.decode('utf8'), False, options=settings.WKHTMLTOPDF_CMD_OPTIONS, configuration=pdfkit_config)
except Exception:
logger.exception('PDF Generation Failed')
return HttpResponse('PDF Generation Failed', status=500)
response = HttpResponse(pdf, content_type='application/pdf')
response['Content-Disposition'] = 'inline;filename=unit%s.pdf' % unit.number
ip = get_real_ip(request)
slack_message('slack/message.slack', {
'message': 'created a PDF from %s %s' % (slug, unit_slug),
'user': request.user.get_username() or ip,
})
return response
def daily_slack_update(request):
"""
Posts to the Techbikers Slack with a daily update on the current rides
"""
attachments = []
rides = Ride.objects.filter(end_date__gte=datetime.now().date())
# If we have some current or upcoming rides, bundle together the
# stats for each one ready to send to Slack
if rides.count() > 0:
for ride in rides:
attachment = {
'color': 'good',
'title': ride.name,
'title_link': 'https://techbikers.com/rides/{0}/{1}'.format(ride.id, ride.slug),
'fields': [{
'title': 'Rider Registrations',
'value': ':white_check_mark: {0} registered, :envelope: {1} invited, :clock1: {2} pending'.format(
ride.registered_riders.count(),
ride.invited_riders.count(),
ride.pending_riders.count()
),
'short': False
}, {
'title': 'Fundraising Total',
'value': ':moneybag: {0} {1}'.format(ride.currency.upper(), ride.fundraising_total),
'short': False
}]
}
attachments.append(attachment)
# Post the update to Slack
slack_message('slack/daily_update.slack', { 'number_rides': rides.count() }, attachments)
# Return all good
return Response({'message': 'success'})
