def email(request, id):
"""Send an email regarding this disclosure"""
ipr = get_object_or_404(IprDisclosureBase, id=id).get_child()
if request.method == 'POST':
button_text = request.POST.get('submit', '')
if button_text == 'Cancel':
return redirect("ipr_show", id=ipr.id)
form = MessageModelForm(request.POST)
if form.is_valid():
# create Message
msg = Message.objects.create(
by = request.user.person,
subject = form.cleaned_data['subject'],
frm = form.cleaned_data['frm'],
to = form.cleaned_data['to'],
cc = form.cleaned_data['cc'],
bcc = form.cleaned_data['bcc'],
reply_to = form.cleaned_data['reply_to'],
body = form.cleaned_data['body']
)
# create IprEvent
IprEvent.objects.create(
type_id = 'msgout',
by = request.user.person,
disclosure = ipr,
response_due = form.cleaned_data['response_due'],
message = msg,
)
# send email
send_mail_message(None,msg)
messages.success(request, 'Email sent.')
return redirect('ipr_show', id=ipr.id)
else:
reply_to = get_reply_to()
addrs = gather_address_lists('ipr_disclosure_followup',ipr=ipr).as_strings(compact=False)
initial = {
'to': addrs.to,
'cc': addrs.cc,
'frm': settings.IPR_EMAIL_FROM,
'subject': 'Regarding {}'.format(ipr.title),
'reply_to': reply_to,
}
form = MessageModelForm(initial=initial)
return render(request, "ipr/email.html", {
'ipr': ipr,
'form':form
})
def announce_to_lists(request, submission):
authors = []
for i in submission.tempidauthors_set.order_by('author_order'):
if not i.author_order:
continue
authors.append(i.get_full_name())
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
m = Message()
m.by = Person.objects.get(name="(System)")
if request.user.is_authenticated():
try:
m.by = request.user.get_profile()
except Person.DoesNotExist:
pass
m.subject = 'I-D Action: %s-%s.txt' % (submission.filename,
submission.revision)
m.frm = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
m.to = settings.IDSUBMIT_ANNOUNCE_LIST_EMAIL
if submission.group_acronym:
m.cc = submission.group_acronym.email_address
m.body = render_to_string(
'submit/announce_to_lists.txt',
dict(
submission=submission,
authors=authors,
settings=settings,
))
m.save()
m.related_docs.add(Document.objects.get(name=submission.filename))
send_mail_message(request, m)
else:
subject = 'I-D Action: %s-%s.txt' % (submission.filename,
submission.revision)
from_email = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
to_email = [settings.IDSUBMIT_ANNOUNCE_LIST_EMAIL]
if submission.group_acronym:
cc = [submission.group_acronym.email_address]
else:
cc = None
send_mail(request,
to_email,
from_email,
subject,
'submit/announce_to_lists.txt', {
'submission': submission,
'authors': authors
},
cc=cc,
save_message=True)
def email(request, id):
"""Send an email regarding this disclosure"""
ipr = get_object_or_404(IprDisclosureBase, id=id).get_child()
if request.method == 'POST':
button_text = request.POST.get('submit', '')
if button_text == 'Cancel':
return redirect("ietf.ipr.views.show", id=ipr.id)
form = MessageModelForm(request.POST)
if form.is_valid():
# create Message
msg = Message.objects.create(
by=request.user.person,
subject=form.cleaned_data['subject'],
frm=form.cleaned_data['frm'],
to=form.cleaned_data['to'],
cc=form.cleaned_data['cc'],
bcc=form.cleaned_data['bcc'],
reply_to=form.cleaned_data['reply_to'],
body=form.cleaned_data['body'])
# create IprEvent
IprEvent.objects.create(
type_id='msgout',
by=request.user.person,
disclosure=ipr,
response_due=form.cleaned_data['response_due'],
message=msg,
)
# send email
send_mail_message(None, msg)
messages.success(request, 'Email sent.')
return redirect('ietf.ipr.views.show', id=ipr.id)
else:
reply_to = get_reply_to()
addrs = gather_address_lists('ipr_disclosure_followup',
ipr=ipr).as_strings(compact=False)
initial = {
'to': addrs.to,
'cc': addrs.cc,
'frm': settings.IPR_EMAIL_FROM,
'subject': u'Regarding {}'.format(ipr.title),
'reply_to': reply_to,
}
form = MessageModelForm(initial=initial)
return render(request, "ipr/email.html", {'ipr': ipr, 'form': form})
def announce_to_lists(request, submission):
m = Message()
m.by = Person.objects.get(name="(System)")
if request.user.is_authenticated:
try:
m.by = request.user.person
except Person.DoesNotExist:
pass
m.subject = 'I-D Action: %s-%s.txt' % (submission.name, submission.rev)
m.frm = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
(m.to, m.cc) = gather_address_lists('sub_announced', submission=submission)
m.body = render_to_string('submit/announce_to_lists.txt',
dict(submission=submission, settings=settings))
m.save()
m.related_docs.add(Document.objects.get(name=submission.name))
send_mail_message(request, m)
def announce_to_lists(request, submission):
m = Message()
m.by = Person.objects.get(name="(System)")
if request.user.is_authenticated():
try:
m.by = request.user.person
except Person.DoesNotExist:
pass
m.subject = 'I-D Action: %s-%s.txt' % (submission.name, submission.rev)
m.frm = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
(m.to, m.cc) = gather_address_lists('sub_announced',submission=submission)
m.body = render_to_string('submit/announce_to_lists.txt',
dict(submission=submission,
settings=settings))
m.save()
m.related_docs.add(Document.objects.get(name=submission.name))
send_mail_message(request, m)
def notify(request, id, type):
"""Send email notifications.
type = update: send notice to old ipr submitter(s)
type = posted: send notice to submitter, etc. that new IPR was posted
"""
ipr = get_object_or_404(IprDisclosureBase, id=id).get_child()
NotifyFormset = formset_factory(NotifyForm, extra=0)
if request.method == 'POST':
formset = NotifyFormset(request.POST)
if formset.is_valid():
for form in formset.forms:
message = infer_message(form.cleaned_data['text'])
message.by = request.user.person
message.save()
send_mail_message(None, message)
IprEvent.objects.create(
type_id=form.cleaned_data['type'],
by=request.user.person,
disclosure=ipr,
response_due=datetime.datetime.now().date() +
datetime.timedelta(days=30),
message=message,
)
messages.success(request, 'Notifications sent')
return redirect("ietf.ipr.views.show", id=ipr.id)
else:
if type == 'update':
initial = [{
'type': 'update_notify',
'text': m
} for m in get_update_submitter_emails(ipr)]
else:
initial = [{
'type': 'msgout',
'text': m
} for m in get_posted_emails(ipr)]
formset = NotifyFormset(initial=initial)
return render(request, "ipr/notify.html", {
'formset': formset,
'ipr': ipr,
})
def announce_to_lists(request, submission):
authors = []
for i in submission.tempidauthors_set.order_by('author_order'):
if not i.author_order:
continue
authors.append(i.get_full_name())
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
m = Message()
m.by = Person.objects.get(name="(System)")
if request.user.is_authenticated():
try:
m.by = request.user.get_profile()
except Person.DoesNotExist:
pass
m.subject = 'I-D Action: %s-%s.txt' % (submission.filename, submission.revision)
m.frm = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
m.to = settings.IDSUBMIT_ANNOUNCE_LIST_EMAIL
if submission.group_acronym:
m.cc = submission.group_acronym.email_address
m.body = render_to_string('submit/announce_to_lists.txt', dict(submission=submission,
authors=authors,
settings=settings,))
m.save()
m.related_docs.add(Document.objects.get(name=submission.filename))
send_mail_message(request, m)
else:
subject = 'I-D Action: %s-%s.txt' % (submission.filename, submission.revision)
from_email = settings.IDSUBMIT_ANNOUNCE_FROM_EMAIL
to_email = [settings.IDSUBMIT_ANNOUNCE_LIST_EMAIL]
if submission.group_acronym:
cc = [submission.group_acronym.email_address]
else:
cc = None
send_mail(request, to_email, from_email, subject, 'submit/announce_to_lists.txt',
{'submission': submission,
'authors': authors}, cc=cc, save_message=True)
def notify(request, id, type):
"""Send email notifications.
type = update: send notice to old ipr submitter(s)
type = posted: send notice to submitter, etc. that new IPR was posted
"""
ipr = get_object_or_404(IprDisclosureBase, id=id).get_child()
NotifyFormset = formset_factory(NotifyForm,extra=0)
if request.method == 'POST':
formset = NotifyFormset(request.POST)
if formset.is_valid():
for form in formset.forms:
message = infer_message(form.cleaned_data['text'])
message.by = request.user.person
message.save()
send_mail_message(None,message)
IprEvent.objects.create(
type_id = form.cleaned_data['type'],
by = request.user.person,
disclosure = ipr,
response_due = datetime.datetime.now().date() + datetime.timedelta(days=30),
message = message,
)
messages.success(request,'Notifications sent')
return redirect("ipr_show", id=ipr.id)
else:
if type == 'update':
initial = [ {'type':'update_notify','text':m} for m in get_update_submitter_emails(ipr) ]
else:
initial = [ {'type':'msgout','text':m} for m in get_posted_emails(ipr) ]
formset = NotifyFormset(initial=initial)
return render(request, "ipr/notify.html", {
'formset': formset,
'ipr': ipr,
})
def send_submission_email(request, submission_id, message_id=None):
"""Send an email related to a submission"""
submission = get_submission_or_404(submission_id, access_token = None)
if request.method == 'POST':
button_text = request.POST.get('submit', '')
if button_text == 'Cancel':
return redirect('ietf.submit.views.submission_status',
submission_id=submission.id,
access_token=submission.access_token())
form = MessageModelForm(request.POST)
if form.is_valid():
# create Message
msg = Message.objects.create(
by = request.user.person,
subject = form.cleaned_data['subject'],
frm = form.cleaned_data['frm'],
to = form.cleaned_data['to'],
cc = form.cleaned_data['cc'],
bcc = form.cleaned_data['bcc'],
reply_to = form.cleaned_data['reply_to'],
body = form.cleaned_data['body']
)
in_reply_to_id = form.cleaned_data['in_reply_to_id']
in_reply_to = None
rp = ""
if in_reply_to_id:
rp = " reply"
try:
in_reply_to = Message.objects.get(id=in_reply_to_id)
except Message.DoesNotExist:
log("Unable to retrieve in_reply_to message: %s" % in_reply_to_id)
desc = "Sent message {} - manual post - {}-{}".format(rp,
submission.name,
submission.rev)
SubmissionEmailEvent.objects.create(
submission = submission,
desc = desc,
msgtype = 'msgout',
by = request.user.person,
message = msg,
in_reply_to = in_reply_to)
# send email
send_mail_message(None,msg)
messages.success(request, 'Email sent.')
return redirect('ietf.submit.views.submission_status',
submission_id=submission.id,
access_token=submission.access_token())
else:
reply_to = get_reply_to()
msg = None
if not message_id:
addrs = gather_address_lists('sub_confirmation_requested',submission=submission).as_strings(compact=False)
to_email = addrs.to
cc = addrs.cc
subject = 'Regarding {}'.format(submission.name)
else:
try:
submitEmail = SubmissionEmailEvent.objects.get(id=message_id)
msg = submitEmail.message
if msg:
to_email = msg.frm
cc = msg.cc
subject = 'Re:{}'.format(msg.subject)
else:
to_email = None
cc = None
subject = 'Regarding {}'.format(submission.name)
except Message.DoesNotExist:
to_email = None
cc = None
subject = 'Regarding {}'.format(submission.name)
initial = {
'to': to_email,
'cc': cc,
'frm': settings.IDSUBMIT_FROM_EMAIL,
'subject': subject,
'reply_to': reply_to,
}
if msg:
initial['in_reply_to_id'] = msg.id
form = MessageModelForm(initial=initial)
return render(request, "submit/email.html", {
'submission': submission,
'access_token': submission.access_token(),
'form':form})
def request_publication(request, name):
"""Request publication by RFC Editor for a document which hasn't
been through the IESG ballot process."""
doc = get_object_or_404(Document, type="draft", name=name, stream__in=("iab", "ise", "irtf"))
if not can_edit_state(request.user, doc):
return HttpResponseForbidden("You do not have the necessary permissions to view this page")
m = Message()
m.frm = request.user.get_profile().formatted_email()
m.to = "RFC Editor <*****@*****.**>"
m.by = request.user.get_profile()
next_state = State.objects.get(used=True, type="draft-stream-%s" % doc.stream.slug, slug="rfc-edit")
if request.method == 'POST' and not request.POST.get("reset"):
form = PublicationForm(request.POST)
if form.is_valid():
if not request.REQUEST.get("skiprfceditorpost"):
# start by notifying the RFC Editor
import ietf.sync.rfceditor
response, error = ietf.sync.rfceditor.post_approved_draft(settings.RFC_EDITOR_SYNC_NOTIFICATION_URL, doc.name)
if error:
return render_to_response('doc/rfceditor_post_approved_draft_failed.html',
dict(name=doc.name,
response=response,
error=error),
context_instance=RequestContext(request))
m.subject = form.cleaned_data["subject"]
m.body = form.cleaned_data["body"]
m.save()
if doc.group.acronym != "none":
m.related_groups = [doc.group]
m.related_docs = [doc]
send_mail_message(request, m)
# IANA copy
m.to = "IANA <*****@*****.**>"
send_mail_message(request, m, extra=extra_automation_headers(doc))
e = DocEvent(doc=doc, type="requested_publication", by=request.user.get_profile())
e.desc = "Sent request for publication to the RFC Editor"
e.save()
# change state
prev_state = doc.get_state(next_state.type)
if next_state != prev_state:
doc.set_state(next_state)
e = add_state_change_event(doc, request.user.get_profile(), prev_state, next_state)
doc.time = e.time
doc.save()
return HttpResponseRedirect(urlreverse('doc_view', kwargs={'name': doc.name}))
else:
if doc.intended_std_level_id in ("std", "ds", "ps", "bcp"):
action = "Protocol Action"
else:
action = "Document Action"
from ietf.idrfc.templatetags.mail_filters import std_level_prompt
subject = "%s: '%s' to %s (%s-%s.txt)" % (action, doc.title, std_level_prompt(doc), doc.name, doc.rev)
body = generate_publication_request(request, doc)
form = PublicationForm(initial=dict(subject=subject,
body=body))
return render_to_response('idrfc/request_publication.html',
dict(form=form,
doc=doc,
message=m,
next_state=next_state,
),
context_instance = RequestContext(request))
def request_publication(request, name):
"""Request publication by RFC Editor for a document which hasn't
been through the IESG ballot process."""
doc = get_object_or_404(Document,
type="draft",
name=name,
stream__in=("iab", "ise", "irtf"))
if not can_edit_state(request.user, doc):
return HttpResponseForbidden(
"You do not have the necessary permissions to view this page")
m = Message()
m.frm = request.user.get_profile().formatted_email()
m.to = "RFC Editor <*****@*****.**>"
m.by = request.user.get_profile()
next_state = State.objects.get(used=True,
type="draft-stream-%s" % doc.stream.slug,
slug="rfc-edit")
if request.method == 'POST' and not request.POST.get("reset"):
form = PublicationForm(request.POST)
if form.is_valid():
if not request.REQUEST.get("skiprfceditorpost"):
# start by notifying the RFC Editor
import ietf.sync.rfceditor
response, error = ietf.sync.rfceditor.post_approved_draft(
settings.RFC_EDITOR_SYNC_NOTIFICATION_URL, doc.name)
if error:
return render_to_response(
'doc/rfceditor_post_approved_draft_failed.html',
dict(name=doc.name, response=response, error=error),
context_instance=RequestContext(request))
m.subject = form.cleaned_data["subject"]
m.body = form.cleaned_data["body"]
m.save()
if doc.group.acronym != "none":
m.related_groups = [doc.group]
m.related_docs = [doc]
send_mail_message(request, m)
# IANA copy
m.to = "IANA <*****@*****.**>"
send_mail_message(request, m, extra=extra_automation_headers(doc))
e = DocEvent(doc=doc,
type="requested_publication",
by=request.user.get_profile())
e.desc = "Sent request for publication to the RFC Editor"
e.save()
# change state
prev_state = doc.get_state(next_state.type)
if next_state != prev_state:
doc.set_state(next_state)
e = add_state_change_event(doc, request.user.get_profile(),
prev_state, next_state)
doc.time = e.time
doc.save()
return HttpResponseRedirect(
urlreverse('doc_view', kwargs={'name': doc.name}))
else:
if doc.intended_std_level_id in ("std", "ds", "ps", "bcp"):
action = "Protocol Action"
else:
action = "Document Action"
from ietf.idrfc.templatetags.mail_filters import std_level_prompt
subject = "%s: '%s' to %s (%s-%s.txt)" % (
action, doc.title, std_level_prompt(doc), doc.name, doc.rev)
body = generate_publication_request(request, doc)
form = PublicationForm(initial=dict(subject=subject, body=body))
return render_to_response('idrfc/request_publication.html',
dict(
form=form,
doc=doc,
message=m,
next_state=next_state,
),
context_instance=RequestContext(request))
def complete_review(request, name, request_id):
doc = get_object_or_404(Document, name=name)
review_req = get_object_or_404(ReviewRequest, pk=request_id)
revising_review = review_req.state_id not in ["requested", "accepted"]
if not review_req.reviewer:
return redirect(review_request,
name=review_req.doc.name,
request_id=review_req.pk)
is_reviewer = user_is_person(request.user, review_req.reviewer.person)
can_manage_request = can_manage_review_requests_for_team(
request.user, review_req.team)
if not (is_reviewer or can_manage_request):
return HttpResponseForbidden(
"You do not have permission to perform this action")
(to, cc) = gather_address_lists('review_completed', review_req=review_req)
if request.method == "POST":
form = CompleteReviewForm(review_req, request.POST, request.FILES)
if form.is_valid():
review_submission = form.cleaned_data['review_submission']
review = review_req.review
if not review:
# create review doc
for i in range(1, 100):
name_components = [
"review",
strip_prefix(review_req.doc.name, "draft-"),
form.cleaned_data["reviewed_rev"],
review_req.team.acronym,
review_req.type.slug,
xslugify(review_req.reviewer.person.ascii_parts()[3]),
datetime.date.today().isoformat(),
]
if i > 1:
name_components.append(str(i))
name = "-".join(c for c in name_components if c).lower()
if not Document.objects.filter(name=name).exists():
review = Document.objects.create(name=name)
DocAlias.objects.create(document=review,
name=review.name)
break
review.type = DocTypeName.objects.get(slug="review")
review.group = review_req.team
review.rev = "00" if not review.rev else "{:02}".format(
int(review.rev) + 1)
review.title = "{} Review of {}-{}".format(
review_req.type.name, review_req.doc.name,
form.cleaned_data["reviewed_rev"])
review.time = datetime.datetime.now()
if review_submission == "link":
review.external_url = form.cleaned_data['review_url']
e = NewRevisionDocEvent.objects.create(
type="new_revision",
doc=review,
by=request.user.person,
rev=review.rev,
desc='New revision available',
time=review.time,
)
review.set_state(State.objects.get(type="review", slug="active"))
review.save_with_history([e])
# save file on disk
if review_submission == "upload":
encoded_content = form.cleaned_data['review_file']
else:
encoded_content = form.cleaned_data['review_content'].encode(
"utf-8")
filename = os.path.join(review.get_file_path(),
'{}.txt'.format(review.name, review.rev))
with open(filename, 'wb') as destination:
destination.write(encoded_content)
# close review request
review_req.state = form.cleaned_data["state"]
review_req.reviewed_rev = form.cleaned_data["reviewed_rev"]
review_req.result = form.cleaned_data["result"]
review_req.review = review
review_req.save()
need_to_email_review = review_submission != "link" and review_req.team.list_email and not revising_review
desc = "Request for {} review by {} {}: {}. Reviewer: {}.".format(
review_req.type.name,
review_req.team.acronym.upper(),
review_req.state.name,
review_req.result.name,
review_req.reviewer.person,
)
if need_to_email_review:
desc += " " + "Sent review to list."
completion_datetime = datetime.datetime.now()
if "completion_date" in form.cleaned_data:
completion_datetime = datetime.datetime.combine(
form.cleaned_data["completion_date"],
form.cleaned_data.get("completion_time")
or datetime.time.min)
close_event = ReviewRequestDocEvent.objects.filter(
type="closed_review_request",
review_request=review_req).first()
if not close_event:
close_event = ReviewRequestDocEvent(
type="closed_review_request", review_request=review_req)
close_event.doc = review_req.doc
close_event.rev = review_req.doc.rev
close_event.by = request.user.person
close_event.desc = desc
close_event.state = review_req.state
close_event.time = completion_datetime
close_event.save()
if review_req.state_id == "part-completed" and not revising_review:
existing_open_reqs = ReviewRequest.objects.filter(
doc=review_req.doc,
team=review_req.team,
state__in=("requested", "accepted"))
new_review_req_url = new_review_req = None
if not existing_open_reqs:
new_review_req = make_new_review_request_from_existing(
review_req)
new_review_req.save()
new_review_req_url = urlreverse(
"ietf.doc.views_review.review_request",
kwargs={
"name": new_review_req.doc.name,
"request_id": new_review_req.pk
})
new_review_req_url = request.build_absolute_uri(
new_review_req_url)
subject = "Review of {}-{} completed partially".format(
review_req.doc.name, review_req.reviewed_rev)
msg = render_to_string(
"review/partially_completed_review.txt", {
"new_review_req_url": new_review_req_url,
"existing_open_reqs": existing_open_reqs,
"by": request.user.person,
})
email_review_request_change(request,
review_req,
subject,
msg,
request.user.person,
notify_secretary=True,
notify_reviewer=False,
notify_requested_by=False)
role = request.user.person.role_set.filter(
group=review_req.team, name='reviewer').first()
if role and role.email.active:
author_email = role.email
frm = role.formatted_email()
else:
author_email = request.user.person.email()
frm = request.user.person.formatted_email()
author, created = DocumentAuthor.objects.get_or_create(
document=review,
email=author_email,
person=request.user.person)
if need_to_email_review:
# email the review
subject = "{} {} {} of {}-{}".format(
review_req.team.acronym.capitalize(),
review_req.type.name.lower(), "partial review"
if review_req.state_id == "part-completed" else "review",
review_req.doc.name, review_req.reviewed_rev)
related_groups = [
review_req.team,
]
if review_req.doc.group:
related_groups.append(review_req.doc.group)
msg = Message.objects.create(
by=request.user.person,
subject=subject,
frm=frm,
to=", ".join(to),
cc=form.cleaned_data["cc"],
body=render_to_string(
"review/completed_review.txt", {
"review_req": review_req,
"content": encoded_content.decode("utf-8"),
}),
)
msg.related_groups.add(*related_groups)
msg.related_docs.add(review_req.doc)
msg = send_mail_message(request, msg)
list_name = mailarch.list_name_from_email(
review_req.team.list_email)
if list_name:
review.external_url = mailarch.construct_message_url(
list_name, email.utils.unquote(msg["Message-ID"]))
review.save_with_history([close_event])
return redirect("ietf.doc.views_doc.document_main",
name=review_req.review.name)
else:
initial = {
"reviewed_rev": review_req.reviewed_rev,
"result": review_req.result_id,
"cc": ", ".join(cc),
}
try:
initial['review_content'] = render_to_string(
'/group/%s/review/content_templates/%s.txt' %
(review_req.team.acronym, review_req.type.slug), {
'review_req': review_req,
'today': datetime.date.today()
})
except TemplateDoesNotExist:
pass
form = CompleteReviewForm(review_req, initial=initial)
mail_archive_query_urls = mailarch.construct_query_urls(review_req)
return render(
request, 'doc/review/complete_review.html', {
'doc': doc,
'review_req': review_req,
'form': form,
'mail_archive_query_urls': mail_archive_query_urls,
'revising_review': revising_review,
})