def send_signoff_request(self, request: WSGIRequest):
if self.is_signed_off or self.sent_for_signoff:
return None
contrib_sign_off_group_users = Group.objects.get(name="Contributions Sign Off").user_set.all()
url_to_preview_pdf = request.build_absolute_uri(reverse("users:certificate_pdf", kwargs={"id": self.id}))
url_to_cert_signoff_list = request.build_absolute_uri(
reverse("admin:users_contributioncertificate_changelist") + "?is_signed_off__exact=0"
)
requesting_user: User = request.user
subject = f"[INTERNAL] Contribution Certificate request from {requesting_user.name} - {requesting_user.email}"
message = (
f"Hi there, \n"
f"{requesting_user.name} (member id {requesting_user.member_id}) has requested one of us to sign "
f"off on the Contribution Certificate for {self.user.name} ({self.user.email}).\n\n"
f"You can view the un-signed preview here: {url_to_preview_pdf}\n\n"
f"You can view all pending Contribution Certificate Requests here: {url_to_cert_signoff_list}\n\n"
f"You do not need to notify the user or reply to this email, they will receive an email when the signoff completes."
)
recipients = [u.email for u in contrib_sign_off_group_users]
msg = EmailMultiAlternatives(
subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=recipients,
cc=[request.user.email],
reply_to=[request.user.email],
)
if not settings.DEBUG:
msg.send()
else:
logger.warning(f"DID NOT SEND MESSAGE AS DEBUG MODE IS ACTIVE. Message below\n: \n{message}")
self.sent_for_signoff = True
self.date_sent_for_signoff = datetime.today().date()
self.save()
def fake_request(path='/', method='GET', user=True, extra={}):
params = {
'REQUEST_METHOD': method,
'PATH_INFO': path,
'wsgi.input': StringIO()
}
params.update(extra)
req = WSGIRequest(params)
if user:
req.user = UserFactory.create(groups=(GroupFactory(), GroupFactory()))
else:
req.user = AnonymousUser()
req.build_absolute_uri = lambda x=None: '/'
# for sessions middleware
req.session = build_fake_session()
# for messages middleware
req._messages = default_storage(req)
req.get_host = lambda x=None: 'localhost'
return req
def fake_request(path='/', method='GET', user=None, extra={}):
params = {
'REQUEST_METHOD': method,
'PATH_INFO': path,
'wsgi.input': StringIO()
}
params.update(extra)
req = WSGIRequest(params)
req.user = user or AnonymousUser()
req.user.id = ''
req.user.username = '******'
req.user.first_name = 'mock_user'
req.user.is_superuser = True
req.user.groups.all = lambda: [GroupFactory(id=1)]
req.build_absolute_uri = lambda x=None: '/'
# for sessions middleware
req.session = build_fake_session()
# for messages middleware
req._messages = default_storage(req)
req.get_host = lambda x=None: 'localhost'
return req
def render_xml(request: WSGIRequest, context: dict):
"""Returns the page context as XML."""
xml = Element('page')
SubElement(xml, 'link', href=request.build_absolute_uri(request.path))
for name in context:
if name == 'title':
SubElement(xml, name).text = context[name]
elif isinstance(context[name], Iterable):
if any(isinstance(i, Feed) for i in context[name]):
feeds = SubElement(xml, 'feeds', name=name)
feeds.extend(
[feed_xml(request, feed, False) for feed in context[name]])
elif any(isinstance(i, Item) for i in context[name]):
items = SubElement(xml, 'items', {'name': name})
items.extend(
[item_xml(request, item, False) for item in context[name]])
elif any(isinstance(i, User) for i in context[name]):
xml.extend(
[user_xml(request, user, False) for user in context[name]])
elif isinstance(context[name], Feed):
xml.append(feed_xml(request, context[name], True))
elif isinstance(context[name], Item):
xml.append(item_xml(request, context[name], True))
elif isinstance(context[name], User):
xml.append(user_xml(request, context[name], True))
return HttpResponse(prettify(xml), content_type='text/xml')
def fake_request(path='/', method='GET', user=None, extra={}):
params = {
'REQUEST_METHOD': method,
'PATH_INFO': path,
'wsgi.input': StringIO()
}
params.update(extra)
req = WSGIRequest(params)
req.user = user or AnonymousUser()
req.user.id = ''
req.user.username = '******'
req.user.first_name = 'mock_user'
req.user.is_superuser = True
req.user.groups.all = lambda: [GroupFactory(id=1)]
req.build_absolute_uri = lambda x=None: '/'
# for sessions middleware
req.session = build_fake_session()
# for messages middleware
req._messages = default_storage(req)
req.get_host = lambda x=None: 'localhost'
return req
def sign_with_user(self, request: WSGIRequest, signing_user: User, email_user: True):
assert signing_user.has_contrib_sign_off_permission()
self.signed_off_by = signing_user
self.signed_off_date = datetime.today().date()
self.is_signed_off = True
self.save()
if email_user:
url_to_signed_pdf = request.build_absolute_uri(
reverse("users:certificate_pdf_signed", kwargs={"id": self.id})
)
cert_user = self.user
subject = f"Contribution Certificate has been signed off"
message = (
f"Dear {cert_user.name}, \n"
f"Your contribution certificate has been signed by {signing_user.name} ({signing_user.email}).\n\n"
f"You can view the signed certificate here: {url_to_signed_pdf}\n\n"
f"Kind regards,\n\n The MeDUSA team"
)
recipients = [self.user.email]
msg = EmailMultiAlternatives(
subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=recipients,
cc=[signing_user.email],
reply_to=[signing_user.email],
)
if not settings.DEBUG:
msg.send()
else:
logger.warning(f"DID NOT SEND MESSAGE AS DEBUG MODE IS ACTIVE. Message below\n: \n{message}")
def user_xml(request: WSGIRequest, user: User, detailed: bool):
"""Returns a User model as XML."""
element = Element('user')
SubElement(element, 'name').text = user.username
if not detailed:
SubElement(element,
'link',
href=request.build_absolute_uri('/user/' + user.username))
return element
def application(environ, start_response):
from apps.core.helpers import import_class
# Get and initialize if needed defined offload handler
offload_handler = environ.get('OFFLOAD_HANDLER')
if offload_handler not in HANDLERS:
handler = import_class(offload_handler)()
HANDLERS[offload_handler] = handler
else:
handler = HANDLERS[offload_handler]
propagator = get_tracer_propagator()
tracer = create_tracer(propagator.from_headers(environ))
request = WSGIRequest(environ)
with tracer.span(name='Async.' + str(request.path)) as span:
response = handler.application(request)
span.span_kind = span_module.SpanKind.SERVER
span.add_attribute(attribute_key=HTTP_HOST,
attribute_value=request.get_host())
span.add_attribute(attribute_key=HTTP_METHOD,
attribute_value=request.method)
span.add_attribute(attribute_key=HTTP_PATH,
attribute_value=str(request.path))
span.add_attribute(attribute_key=HTTP_ROUTE,
attribute_value=str(request.path))
span.add_attribute(attribute_key=HTTP_URL,
attribute_value=str(request.build_absolute_uri()))
span.add_attribute(attribute_key='async.offload_handler',
attribute_value=offload_handler)
if response:
span.add_attribute(attribute_key=HTTP_STATUS_CODE,
attribute_value=response.status_code)
if not isinstance(response, HttpResponseBase):
return response
for k, v in DEFAULT_HEADERS:
response[k] = v
# If we're dealing with cross origin request, add necessary headers
if environ.get('HTTP_ORIGIN'):
for k, v in CORS_HEADER:
response[k] = v
http_status = '%s %s' % (response.status_code, response.reason_phrase)
start_response(http_status, list(response.items()))
return response
def feed_xml(request: WSGIRequest, feed: Feed, detailed: bool):
"""Returns a Feed model as XML."""
element = Element('feed')
SubElement(element, 'title').text = feed.title
SubElement(element, 'source').text = feed.source_pretty
if detailed:
SubElement(element, 'link', href=feed.link)
SubElement(element, 'chosen').text = str(feed.chosen)
else:
SubElement(element,
'link',
href=request.build_absolute_uri('/feed/' + str(feed.pk)))
return element
def gen_pdf(self, request: WSGIRequest, signed: bool):
headers = dict(request.headers)
if signed:
assert self.is_signed_off is True, "Attempted to generate signed pdf but it is not signed off"
cert_url = request.build_absolute_uri(reverse("users:certificate_detail_signed", kwargs={"id": self.id}))
else:
cert_url = request.build_absolute_uri(reverse("users:certificate_detail", kwargs={"id": self.id}))
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.set_extra_http_headers({"Cookie": headers["Cookie"]})
page.goto(cert_url)
# https://playwright.dev/python/docs/api/class-page#page-pdf
# Image size is 1754 x 1240
pdf = page.pdf(prefer_css_page_size=True, print_background=True, width="1754px", height="1240px")
browser.close()
if signed:
self.signed_pdf = ContentFile(content=pdf, name=f"{self.user.member_id}_certificate.pdf")
else:
self.preview_pdf = ContentFile(content=pdf, name=f"{self.user.member_id}_PREVIEW_certificate.pdf")
self.save()
def session_set_pages(request: WSGIRequest):
if not isinstance(request, WSGIRequest):
raise TypeError("Parameter 1 invalid type")
if not ("pages" in request.session): request.session['pages'] = []
FULL_URL_WITH_QUERY_STRING = request.build_absolute_uri()
FULL_URL = request.build_absolute_uri('?')
ABSOLUTE_ROOT = request.build_absolute_uri('/')[:-1].strip("/")
ABSOLUTE_ROOT_URL = request.build_absolute_uri('/').strip("/")
REQUEST_PATH = request.get_full_path()
if len(request.session['pages']) > 0 \
and (request.session['pages'][0] == REQUEST_PATH):
return
request.session['pages'].append(REQUEST_PATH)
request.session['pages'].reverse()
# request.session['pages'] = list(set(request.session['pages']));
pass
def __call__(self, request: WSGIRequest) -> HttpResponseBase:
# if settings.DEBUG:
# return self.get_response(request)
request_uri = request.build_absolute_uri(request.get_full_path())
if '/users/' in request.path_info:
if not request.is_secure():
new_url = request_uri.replace('http:', 'https:')
return redirect(new_url, permanent=False)
return self.get_response(request)
elif request.is_secure():
new_url = request_uri.replace('https:', 'http:')
return redirect(new_url, permanent=False)
return self.get_response(request)
def get_context(self, request: WSGIRequest, team_ID) -> dict:
context = get_discord_context(request)
if not context["is_verified"]:
return context
team = get_object_or_404(Team,
ID=team_ID) # Team.objects.get(ID=team_ID)
members = team.members.all()
discord_members = []
for member in members:
new_member = {}
try:
user = SocialAccount.objects.get(user_id=member.id)
except SocialAccount.DoesNotExist:
pass
else:
new_member["user_id"] = user.uid
avatar_url = user.get_avatar_url()
if avatar_url.endswith("None.png"):
random = randint(0, 4)
avatar_url = (
f"https://cdn.discordapp.com/embed/avatars/{random}.png"
)
new_member["avatar_url"] = avatar_url
new_member["username"] = user.extra_data["username"]
new_member["discriminator"] = user.extra_data["discriminator"]
discord_members.append(new_member)
team.discord_members = discord_members
print(team)
context["team"] = team
context["challenge"] = team.challenge
if team.submitted:
try:
context["submission"] = Submission.objects.get(
team=team, challenge=team.challenge)
except:
pass
print(context["challenge"].submissions_status)
context["invite"] = request.build_absolute_uri(
location=f"/timathon/member/{team.invite}")
return context
def item_xml(request: WSGIRequest, item: Item, detailed: bool):
"""Returns an Item model as XML."""
element = Element('item')
SubElement(element, 'title').text = item.title
if detailed:
SubElement(element, 'link', href=item.link)
SubElement(element, 'description').text = item.description
SubElement(element, 'image', src=item.picture)
element.extend([
comment_xml(comment)
for comment in item.comments.all().order_by('-date')[:20]
])
else:
SubElement(element,
'link',
href=request.build_absolute_uri('/item/' + str(item.pk)))
SubElement(element, 'upvotes').text = str(item.upvote_count)
SubElement(element, 'downvotes').text = str(item.downvote_count)
element.append(feed_xml(request, item.feed, False))
return element
def tutor_signup(request: WSGIRequest) -> HttpResponse:
semester: Semester = get_object_or_404(Semester, pk=get_semester(request))
settings = get_object_or_404(Settings, semester=semester)
if not settings.registration_open:
return render(
request,
"tutors/standalone/tutor_signup/registration_closed.html",
{
"start": settings.open_registration,
"end": settings.close_registration,
},
)
answer_formset, questions_exist = generate_answer_formset(
request, semester)
form = TutorForm(request.POST or None, semester=semester)
if form.is_valid() and (not questions_exist or answer_formset.is_valid()):
if settings.mail_registration is None:
messages.error(
request,
_(
"We did not configure a mail to send to you in case you registered. Please Contact {mail} and "
"tell us about this error. We are very sorry about this inconvenience. To make up for it cute "
"cat-images: https://imgur.com/gallery/3OMii", ).format(
mail=TutorMail.SET_TUTOR),
)
return redirect("tutors:tutor_signup")
try:
tutor: Tutor = form.save()
except IntegrityError:
messages.error(
request,
_(
"The email {tutor_mail_address} does already exist for the {semester}. "
"Did you already sign up, or is the email invalid? "
"Please write us a mail at {set_mail_address} instead of trying again.",
).format(
semester=str(semester),
tutor_mail_address=form.cleaned_data["email"],
set_mail_address=TutorMail.SET_TUTOR,
),
)
return redirect("tutors:tutor_signup")
tutor.log(None, "Signed up")
save_answer_formset(answer_formset, tutor.id)
activation_url = request.build_absolute_uri(
reverse(
"tutors:tutor_signup_confirm",
kwargs={
"uidb64": urlsafe_base64_encode(force_bytes(tutor.pk)),
"token":
account_activation_token.make_token(tutor), # type: ignore
},
), )
if not settings.mail_registration.send_mail_registration(
tutor, activation_url):
messages.error(
request,
_("Could not send email. If this error persists send a mail to {mail}"
).format(mail=TutorMail.SET),
)
return redirect("tutors:tutor_signup")
MailTutorTask.objects.create(tutor=tutor,
mail=settings.mail_registration,
task=None)
return redirect("tutors:tutor_signup_confirmation_required")
context = {
"semester": semester,
"answer_formset": answer_formset,
"questions_exist": questions_exist,
"form": form,
}
return render(request, "tutors/standalone/tutor_signup/signup.html",
context)
def process_response(self, request: WSGIRequest,
response: HttpResponse) -> HttpResponse:
if not wagtailcache_settings.WAGTAIL_CACHE:
return response
if getattr(request, "_wagtailcache_skip", False):
# If we should skip this response, add header and return.
_patch_header(response, Status.SKIP)
return response
if not getattr(request, "_wagtailcache_update", False):
# We don't need to update the cache, just return.
return response
# Check if the response is cacheable
# Don't cache private or no-cache responses.
# Do cache 200, 301, 302, 304, and 404 codes so that wagtail doesn't
# have to repeatedly look up these URLs in the database.
# Don't cache streaming responses.
is_cacheable = (CacheControl.NOCACHE.value not in response.get(
"Cache-Control", "")
and CacheControl.PRIVATE.value not in response.get(
"Cache-Control", "")
and response.status_code in (200, 301, 302, 304, 404)
and not response.streaming)
# Don't cache 200 responses that set a user-specific cookie in response
# to a cookie-less request (e.g. CSRF tokens).
if is_cacheable and response.status_code == 200:
is_cacheable = not (not request.COOKIES and response.cookies
and has_vary_header(response, "Cookie"))
# Allow the user to override our caching decision.
for fn in hooks.get_hooks("is_response_cacheable"):
result = fn(response, is_cacheable)
if isinstance(result, bool):
is_cacheable = result
# If we are not allowed to cache the response, just return.
if not is_cacheable:
# Add response header to indicate this was intentionally not cached.
_patch_header(response, Status.SKIP)
return response
# Try to get the timeout from the ``max-age`` section of the
# ``Cache-Control`` header before reverting to using the cache's
# default.
timeout = get_max_age(response)
if timeout is None:
timeout = self._wagcache.default_timeout
patch_response_headers(response, timeout)
if timeout:
cache_key = learn_cache_key(request,
response,
timeout,
None,
cache=self._wagcache)
# Track cache keys
uri = unquote(request.build_absolute_uri())
keyring = self._wagcache.get("keyring", {})
if not re.findall("robots.txt|favicon.ico", uri) and is_cacheable:
keyring[uri] = keyring.get(uri, []) + [cache_key]
self._wagcache.set("keyring", keyring)
if isinstance(response, SimpleTemplateResponse):
response.add_post_render_callback(
lambda r: self._wagcache.set(cache_key, r, timeout))
else:
self._wagcache.set(cache_key, response, timeout)
# Add a response header to indicate this was a cache miss.
_patch_header(response, Status.MISS)
return response
def gen_absolute_link(request: WSGIRequest, slug):
return request.build_absolute_uri(reverse('shortlink', args=(slug, )))
