def testAliases(self):
url = urlreverse('old_group_email_aliases', kwargs=dict(acronym="mars"))
r = self.client.get(url)
self.assertEqual(r.status_code, 302)
for testdict in [dict(acronym="mars"),dict(acronym="mars",group_type="wg")]:
url = urlreverse('old_group_email_aliases', kwargs=testdict)
r = self.client.get(url,follow=True)
self.assertTrue(all([x in unicontent(r) for x in ['mars-ads@','mars-chairs@']]))
self.assertFalse(any([x in unicontent(r) for x in ['ames-ads@','ames-chairs@']]))
url = urlreverse('ietf.group.info.email_aliases', kwargs=dict())
login_testing_unauthorized(self, "plain", url)
r = self.client.get(url)
self.assertTrue(r.status_code,200)
self.assertTrue(all([x in unicontent(r) for x in ['mars-ads@','mars-chairs@','ames-ads@','ames-chairs@']]))
url = urlreverse('ietf.group.info.email_aliases', kwargs=dict(group_type="wg"))
r = self.client.get(url)
self.assertEqual(r.status_code,200)
self.assertTrue('mars-ads@' in unicontent(r))
url = urlreverse('ietf.group.info.email_aliases', kwargs=dict(group_type="rg"))
r = self.client.get(url)
self.assertEqual(r.status_code,200)
self.assertFalse('mars-ads@' in unicontent(r))
def get_details_tabs(ipr, selected):
return [
t + (t[0].lower() == selected.lower(),)
for t in [
('Disclosure', urlreverse('ipr_show', kwargs={ 'id': ipr.pk })),
('History', urlreverse('ipr_history', kwargs={ 'id': ipr.pk }))
]]
def render_document_top(request, doc, tab, name):
tabs = []
tabs.append(("Document", "document", urlreverse("doc_view", kwargs=dict(name=name)), True))
ballot = doc.latest_event(BallotDocEvent, type="created_ballot")
if doc.type_id in ("draft","conflrev", "statchg"):
tabs.append(("IESG Evaluation Record", "ballot", urlreverse("doc_ballot", kwargs=dict(name=name)), ballot, None if ballot else "IESG Evaluation Ballot has not been created yet"))
elif doc.type_id == "charter" and doc.group.type_id == "wg":
tabs.append(("IESG Review", "ballot", urlreverse("doc_ballot", kwargs=dict(name=name)), ballot, None if ballot else "IESG Review Ballot has not been created yet"))
if doc.type_id == "draft" or (doc.type_id == "charter" and doc.group.type_id == "wg"):
tabs.append(("IESG Writeups", "writeup", urlreverse("doc_writeup", kwargs=dict(name=name)), True))
tabs.append(("History", "history", urlreverse("doc_history", kwargs=dict(name=name)), True))
if name.startswith("rfc"):
name = "RFC %s" % name[3:]
else:
name += "-" + doc.rev
return render_to_string("doc/document_top.html",
dict(doc=doc,
tabs=tabs,
selected=tab,
name=name))
def test_group_charter(self):
draft = make_test_data()
group = draft.group
with open(os.path.join(self.charter_dir, "%s-%s.txt" % (group.charter.canonical_name(), group.charter.rev)), "w") as f:
f.write("This is a charter.")
milestone = GroupMilestone.objects.create(
group=group,
state_id="active",
desc="Get Work Done",
due=datetime.date.today() + datetime.timedelta(days=100))
milestone.docs.add(draft)
for url in [group.about_url(),
urlreverse('ietf.group.info.group_about',kwargs=dict(acronym=group.acronym)),
urlreverse('ietf.group.info.group_about',kwargs=dict(acronym=group.acronym,group_type=group.type_id)),
]:
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue(group.name in unicontent(r))
self.assertTrue(group.acronym in unicontent(r))
self.assertTrue("This is a charter." in unicontent(r))
self.assertTrue(milestone.desc in unicontent(r))
self.assertTrue(milestone.docs.all()[0].name in unicontent(r))
def edit_actions(context, wrapper):
request = context.get('request', None)
user = request and request.user
if not user:
return {}
idwrapper = None
if isinstance(wrapper, IdRfcWrapper):
idwrapper = wrapper.id
elif isinstance(wrapper, IdWrapper):
idwrapper = wrapper
if not idwrapper:
return None
doc = wrapper
draft = wrapper._draft
actions = []
if can_adopt(user, draft):
actions.append(("Adopt in WG", urlreverse('edit_adopt', kwargs=dict(name=doc.draft_name))))
if can_edit_state(user, draft):
actions.append(("Change stream state", urlreverse('edit_state', kwargs=dict(name=doc.draft_name))))
if draft.stream_id in ("iab", "ise", "irtf"):
actions.append(("Request publication", urlreverse('doc_request_publication', kwargs=dict(name=doc.draft_name))))
return dict(actions=actions)
def get_details_tabs(stmt, selected):
return [
t + (t[0].lower() == selected.lower(),)
for t in [
('Statement', urlreverse('ietf.liaisons.views.liaison_detail', kwargs={ 'object_id': stmt.pk })),
('History', urlreverse('ietf.liaisons.views.liaison_history', kwargs={ 'object_id': stmt.pk }))
]]
def test_document_primary_and_history_views(self):
make_test_data()
# Ensure primary views of both current and historic versions of documents works
for docname in ["draft-imaginary-independent-submission",
"conflict-review-imaginary-irtf-submission",
"status-change-imaginary-mid-review",
"charter-ietf-mars",
"agenda-42-mars",
"minutes-42-mars",
"slides-42-mars-1",
]:
doc = Document.objects.get(name=docname)
# give it some history
save_document_in_history(doc)
doc.rev="01"
doc.save()
r = self.client.get(urlreverse("doc_view", kwargs=dict(name=doc.name)))
self.assertEqual(r.status_code, 200)
self.assertTrue("%s-01"%docname in unicontent(r))
r = self.client.get(urlreverse("doc_view", kwargs=dict(name=doc.name,rev="01")))
self.assertEqual(r.status_code, 302)
r = self.client.get(urlreverse("doc_view", kwargs=dict(name=doc.name,rev="00")))
self.assertEqual(r.status_code, 200)
self.assertTrue("%s-00"%docname in unicontent(r))
def test_document_ballot_needed_positions(self):
make_test_data()
# draft
doc = Document.objects.get(name='draft-ietf-mars-test')
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name)))
self.assertTrue('more YES or NO' in r.content)
Document.objects.filter(pk=doc.pk).update(intended_std_level='inf')
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name)))
self.assertFalse('more YES or NO' in r.content)
# status change
doc = Document.objects.get(name='status-change-imaginary-mid-review')
iesgeval_pk = str(State.objects.get(slug='iesgeval',type__slug='statchg').pk)
self.client.login(username='******', password='******')
r = self.client.post(urlreverse('ietf.doc.views_status_change.change_state',kwargs=dict(name=doc.name)),dict(new_state=iesgeval_pk))
self.assertEqual(r.status_code, 302)
r = self.client.get(r._headers["location"][1])
self.assertTrue(">IESG Evaluation<" in r.content)
doc.relateddocument_set.create(target=DocAlias.objects.get(name='rfc9998'),relationship_id='tohist')
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name)))
self.assertFalse('Needs a YES' in r.content)
self.assertFalse('more YES or NO' in r.content)
doc.relateddocument_set.create(target=DocAlias.objects.get(name='rfc9999'),relationship_id='tois')
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name)))
self.assertTrue('more YES or NO' in r.content)
def test_materials(self):
make_test_data()
group = Group.objects.create(type_id="team", acronym="testteam", name="Test Team", state_id="active")
doc = Document.objects.create(
name="slides-testteam-test-slides",
rev="00",
title="Test Slides",
group=group,
type_id="slides",
)
doc.set_state(State.objects.get(type="slides", slug="active"))
DocAlias.objects.create(name=doc.name, document=doc)
for url in [ urlreverse("group_materials", kwargs={ 'acronym': group.acronym }),
urlreverse("group_materials", kwargs={ 'acronym': group.acronym , 'group_type': group.type_id}),
]:
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue(doc.title in unicontent(r))
self.assertTrue(doc.name in unicontent(r))
url = urlreverse("group_materials", kwargs={ 'acronym': group.acronym })
# try deleting the document and check it's gone
doc.set_state(State.objects.get(type="slides", slug="deleted"))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue(doc.title not in unicontent(r))
def test_materials(self):
meeting = make_meeting_test_data()
session = Session.objects.filter(meeting=meeting, group__acronym="mars").first()
draft = Document.objects.filter(type="draft", group=session.group).first()
self.write_materials_file(meeting, session.materials.get(type="agenda"),
"1. WG status (15 minutes)\n\n2. Status of %s\n\n" % draft.name)
self.write_materials_file(meeting, session.materials.get(type="minutes"),
"1. More work items underway\n\n2. The draft will be finished before next meeting\n\n")
self.write_materials_file(meeting, session.materials.get(type="slides"),
"This is a slideshow")
# session agenda
r = self.client.get(urlreverse("ietf.meeting.views.session_agenda",
kwargs=dict(num=meeting.number, session=session.group.acronym)))
self.assertEqual(r.status_code, 200)
self.assertTrue("1. WG status" in r.content)
# early materials page
r = self.client.get(urlreverse("ietf.meeting.views.current_materials"))
self.assertEqual(r.status_code, 302)
self.assertTrue(meeting.number in r["Location"])
r = self.client.get(urlreverse("ietf.meeting.views.materials", kwargs=dict(meeting_num=meeting.number)))
self.assertEqual(r.status_code, 200)
#debug.show('r.content')
q = PyQuery(r.content)
row = q('.ietf-materials b:contains("%s")' % str(session.group.acronym.upper())).closest("tr")
self.assertTrue(row.find("a:contains(\"Agenda\")"))
self.assertTrue(row.find("a:contains(\"Minutes\")"))
self.assertTrue(row.find("a:contains(\"Slideshow\")"))
def test_materials(self):
meeting = make_meeting_test_data()
session = Session.objects.filter(meeting=meeting, group__acronym="mars").first()
self.write_materials_files(meeting, session)
# session agenda
r = self.client.get(urlreverse("ietf.meeting.views.session_agenda",
kwargs=dict(num=meeting.number, session=session.group.acronym)))
self.assertEqual(r.status_code, 200)
self.assertTrue("1. WG status" in unicontent(r))
# early materials page
r = self.client.get(urlreverse("ietf.meeting.views.current_materials"))
self.assertEqual(r.status_code, 302)
self.assertTrue(meeting.number in r["Location"])
r = self.client.get(urlreverse("ietf.meeting.views.materials", kwargs=dict(meeting_num=meeting.number)))
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
row = q('#content td div:contains("%s")' % str(session.group.acronym)).closest("tr")
self.assertTrue(row.find('a:contains("Agenda")'))
self.assertTrue(row.find('a:contains("Minutes")'))
self.assertTrue(row.find('a:contains("Slideshow")'))
self.assertFalse(row.find("a:contains(\"Bad Slideshow\")"))
def placeOrder(request):
switch = False
#pdb.set_trace()
if request.user.is_anonymous():
#return redirect_to_login('/',login_url="/login")
return HttpResponseRedirect(urlreverse('login'))
else:
#pdb.set_trace()this time switch
d=datetime.date.today()
if datetime.datetime.now()>datetime.datetime(d.year,d.month, d.day, 10, 25, 0,0):
switch=True
# if lunch was already submitted today...
todays_orders = Order.objects.filter(user=request.user,date__year=d.year,date__month=d.month,date__day=d.day)
if todays_orders.exists():
switch = True
if request.method == 'POST' and not switch: # If the form has been submitted...
#request.META['REMOTE_HOST']
#pdb.set_trace()
form = OrderForm(request.POST, instance=Order(user=request.user,pc=request.META['REMOTE_ADDR'],total=request.POST.get('total'))) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
#pdb.set_trace()
form.save()
return HttpResponseRedirect(urlreverse('thanksorder')) # Redirect after POSTthanksorder
else:
form = OrderForm() # An unbound form
return render_to_response('meal/orderform.html',
{'form': form, 'username' : request.user.username, 'switch': switch },
context_instance=RequestContext(request))
def test_ajax_search_docs(self):
draft = make_test_data()
# Document
url = urlreverse("ajax_select2_search_docs", kwargs={
"model_name": "document",
"doc_type": "draft",
})
r = self.client.get(url, dict(q=draft.name))
self.assertEqual(r.status_code, 200)
data = json.loads(r.content)
self.assertEqual(data[0]["id"], draft.pk)
# DocAlias
doc_alias = draft.docalias_set.get()
url = urlreverse("ajax_select2_search_docs", kwargs={
"model_name": "docalias",
"doc_type": "draft",
})
r = self.client.get(url, dict(q=doc_alias.name))
self.assertEqual(r.status_code, 200)
data = json.loads(r.content)
self.assertEqual(data[0]["id"], doc_alias.pk)
def test_material_presentations(self):
doc = self.create_slides()
meeting = make_meeting_test_data()
meeting.session_set.filter(group__acronym='mars').update(group=doc.group)
url = urlreverse(material_presentations,kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
url = urlreverse(material_presentations,kwargs=dict(name=doc.name,seq=1))
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
when = meeting.agenda.assignments.filter(session__group__acronym='testteam').first().timeslot.time
mdw = when.date().isoformat()
dow = ['mon','tue','wed','thu','fri','sat','sun'][when.weekday()]
for kw in [ dict(),
dict(seq=1),
dict(week_day=dow),
dict(week_day=dow,seq=1),
dict(date=mdw),
dict(date=mdw,seq=1),
dict(date=mdw+'-0930'),
dict(date=mdw+'-0930',seq=1),
]:
kw['name'] = doc.name
kw['acronym'] = 'testteam'
url = urlreverse(material_presentations,kwargs=kw)
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
def search(request, keywords=None, sep=' '):
""" Search for `keywords` in `Page` titles and `contents` """
if keywords is None:
keywords = request.GET.get('keywords')
# prefer GET to POST
if keywords is None:
keywords = request.POST.get('keywords')
if not keywords:
# no (NOT EVEN A LITTLE BIT!!!!!!!1111!!1) input
return HttpResponseRedirect(urlreverse(home))
assert(isinstance(keywords, basestring))
if not re.match('[a-zA-Z]', keywords):
return HttpResponseRedirect(urlreverse(home))
keywords = kewwords.strip().strip(',')
if not keywords:
return HttpResponseRedirect(urlreverse(home))
results = SortedDefaultDict(int)
keywords = keywords.split(sep)
for keyword in keywords:
for obj in Page.filter(title__contains=keyword):
results[obj] += 5
for obj in Page.filter(text__contains=keyword):
results[obj] += obj.text.lower().count(keyword.lower())
results.sort_by_values(reverse=True)
return render(settings.TEMPLATE_SEARCH, 'search', parameters={
'keywords': keywords, 'results': results
})
def test_document_ballot(self):
doc = make_test_data()
ballot = doc.active_ballot()
pos = BallotPositionDocEvent.objects.create(
doc=doc,
ballot=ballot,
type="changed_ballot_position",
pos_id="yes",
comment="Looks fine to me",
comment_time=datetime.datetime.now(),
ad=Person.objects.get(user__username="******"),
by=Person.objects.get(name="(System)"))
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name)))
self.assertEqual(r.status_code, 200)
self.assertTrue(pos.comment in r.content)
# test with ballot_id
r = self.client.get(urlreverse("ietf.doc.views_doc.document_ballot", kwargs=dict(name=doc.name, ballot_id=ballot.pk)))
self.assertEqual(r.status_code, 200)
self.assertTrue(pos.comment in r.content)
# test popup too while we're at it
r = self.client.get(urlreverse("ietf.doc.views_doc.ballot_popup", kwargs=dict(name=doc.name, ballot_id=ballot.pk)))
self.assertEqual(r.status_code, 200)
def wg_charter(request, acronym):
wg = get_object_or_404(IETFWG, group_acronym__acronym=acronym, group_type=1)
concluded = wg.status_id in [ 2, 3, ]
proposed = (wg.status_id == 4)
fill_in_charter_info(wg)
actions = []
if wg.state_id != "conclude":
actions.append(("Edit WG", urlreverse("wg_edit", kwargs=dict(acronym=wg.acronym))))
e = wg.latest_event(type__in=("changed_state", "requested_close",))
requested_close = wg.state_id != "conclude" and e and e.type == "requested_close"
if wg.state_id in ("active", "dormant"):
actions.append(("Request closing WG", urlreverse("wg_conclude", kwargs=dict(acronym=wg.acronym))))
context = get_wg_menu_context(wg, "charter")
context.update(dict(
actions=actions,
is_chair=request.user.is_authenticated() and wg.role_set.filter(name="chair", person__user=request.user),
milestones_in_review=wg.groupmilestone_set.filter(state="review"),
requested_close=requested_close,
))
return render_to_response('wginfo/wg_charter.html',
context,
RequestContext(request))
def document_writeup(request, name):
doc = get_object_or_404(Document, docalias__name=name)
top = render_document_top(request, doc, "writeup", name)
def text_from_writeup(event_type):
e = doc.latest_event(WriteupDocEvent, type=event_type)
if e:
return e.text
else:
return ""
sections = []
if doc.type_id == "draft":
writeups = []
sections.append(("Approval Announcement",
"<em>Draft</em> of message to be sent <em>after</em> approval:",
writeups))
writeups.append(("Announcement",
text_from_writeup("changed_ballot_approval_text"),
urlreverse("doc_ballot_approvaltext", kwargs=dict(name=doc.name))))
writeups.append(("Ballot Text",
text_from_writeup("changed_ballot_writeup_text"),
urlreverse("doc_ballot_writeupnotes", kwargs=dict(name=doc.name))))
elif doc.type_id == "charter":
sections.append(("WG Review Announcement",
"",
[("WG Review Announcement",
text_from_writeup("changed_review_announcement"),
urlreverse("ietf.doc.views_charter.announcement_text", kwargs=dict(name=doc.name, ann="review")))]
))
sections.append(("WG Action Announcement",
"",
[("WG Action Announcement",
text_from_writeup("changed_action_announcement"),
urlreverse("ietf.doc.views_charter.announcement_text", kwargs=dict(name=doc.name, ann="action")))]
))
if doc.latest_event(BallotDocEvent, type="created_ballot"):
sections.append(("Ballot Announcement",
"",
[("Ballot Announcement",
text_from_writeup("changed_ballot_writeup_text"),
urlreverse("ietf.doc.views_charter.ballot_writeupnotes", kwargs=dict(name=doc.name)))]
))
if not sections:
raise Http404
return render_to_response("doc/document_writeup.html",
dict(doc=doc,
top=top,
sections=sections,
can_edit=has_role(request.user, ("Area Director", "Secretariat")),
),
context_instance=RequestContext(request))
def test_basic(self):
blogid = 'blog1'
url = urlreverse('goblog-articles-view', kwargs={'blogid': blogid})
blogurl = urlreverse('goblog-blog-main', kwargs={'blogid': blogid})
response = self.client.get(url, follow=True)
chain = response.redirect_chain
self.assertEqual(1, len(chain))
self.assertEqual(('http://testserver'+blogurl, 301), chain[0])
def test_default_blog(self):
blogid = 'blog1'
url = urlreverse('goblog-blog-main', kwargs={'blogid': blogid})
defaulturl = urlreverse('goblog-default-blog-main')
response = self.client.get(url, follow=True)
chain = response.redirect_chain
self.assertEqual(1, len(chain))
self.assertEqual(('http://testserver'+defaulturl, 302), chain[0])
def test_default_blog(self):
blogid = 'blog1'
url = urlreverse('goblog-default-articles-view')
blogurl = urlreverse('goblog-default-blog-main')
response = self.client.get(url, follow=True)
chain = response.redirect_chain
self.assertEqual(1, len(chain))
self.assertEqual(('http://testserver'+blogurl, 301), chain[0])
def __init__(self, option):
TrackNode.__init__(self)
if option=='render':
url = urlreverse('targetview-email-render')
elif option=='acknowledge':
url = urlreverse('targetview-email-acknowledge')
else:
raise RuntimeError('Unknown email option')
self.text = create_trackedurl_tag(url)
def test_subsequent_submission(self):
doc = Document.objects.get(name='status-change-imaginary-mid-review')
url = urlreverse('status_change_submit',kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "ad", url)
# A little additional setup
# doc.rev is u'00' per the test setup - double-checking that here - if it fails, the breakage is in setUp
self.assertEqual(doc.rev,u'00')
path = os.path.join(settings.STATUS_CHANGE_PATH, '%s-%s.txt' % (doc.canonical_name(), doc.rev))
with open(path,'w') as f:
f.write('This is the old proposal.')
f.close()
# Put the old proposal into IESG review (exercises ballot tab when looking at an older revision below)
state_change_url = urlreverse('status_change_change_state',kwargs=dict(name=doc.name))
iesgeval_pk = str(State.objects.get(slug='iesgeval',type__slug='statchg').pk)
r = self.client.post(state_change_url,dict(new_state=iesgeval_pk))
self.assertEqual(r.status_code, 302)
# normal get
r = self.client.get(url)
self.assertEqual(r.status_code,200)
q = PyQuery(r.content)
self.assertTrue(q('textarea')[0].text.strip().startswith("This is the old proposal."))
# faulty posts trying to use file upload
# Copied from wgtracker tests - is this really testing the server code, or is it testing
# how client.post populates Content-Type?
test_file = StringIO("\x10\x11\x12") # post binary file
test_file.name = "unnamed"
r = self.client.post(url, dict(txt=test_file,submit_response="1"))
self.assertEqual(r.status_code, 200)
self.assertTrue("does not appear to be a text file" in unicontent(r))
# sane post uploading a file
test_file = StringIO("This is a new proposal.")
test_file.name = "unnamed"
r = self.client.post(url,dict(txt=test_file,submit_response="1"))
self.assertEqual(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertEqual(doc.rev,u'01')
path = os.path.join(settings.STATUS_CHANGE_PATH, '%s-%s.txt' % (doc.canonical_name(), doc.rev))
with open(path) as f:
self.assertEqual(f.read(),"This is a new proposal.")
f.close()
self.assertTrue( "mid-review-01" in doc.latest_event(NewRevisionDocEvent).desc)
# verify reset text button works
r = self.client.post(url,dict(reset_text="1"))
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(q('textarea')[0].text.strip().startswith("Provide a description"))
# make sure we can see the old revision
url = urlreverse('doc_view',kwargs=dict(name=doc.name,rev='00'))
r = self.client.get(url)
self.assertEqual(r.status_code,200)
self.assertTrue("This is the old proposal." in unicontent(r))
def search_for_name(request, name):
def find_unique(n):
exact = DocAlias.objects.filter(name=n).first()
if exact:
return exact.name
aliases = DocAlias.objects.filter(name__startswith=n)[:2]
if len(aliases) == 1:
return aliases[0].name
aliases = DocAlias.objects.filter(name__contains=n)[:2]
if len(aliases) == 1:
return aliases[0].name
return None
n = name
# chop away extension
extension_split = re.search("^(.+)\.(txt|ps|pdf)$", n)
if extension_split:
n = extension_split.group(1)
redirect_to = find_unique(name)
if redirect_to:
return HttpResponseRedirect(urlreverse("doc_view", kwargs={ "name": redirect_to }))
else:
# check for embedded rev - this may be ambigious, so don't
# chop it off if we don't find a match
rev_split = re.search("^(.+)-([0-9]{2})$", n)
if rev_split:
redirect_to = find_unique(rev_split.group(1))
if redirect_to:
rev = rev_split.group(2)
# check if we can redirect directly to the rev
if DocHistory.objects.filter(doc__docalias__name=redirect_to, rev=rev).exists():
return HttpResponseRedirect(urlreverse("doc_view", kwargs={ "name": redirect_to, "rev": rev }))
else:
return HttpResponseRedirect(urlreverse("doc_view", kwargs={ "name": redirect_to }))
# build appropriate flags based on string prefix
doctypenames = DocTypeName.objects.filter(used=True)
# This would have been more straightforward if document prefixes couldn't
# contain a dash. Probably, document prefixes shouldn't contain a dash ...
search_args = "?name=%s" % n
if n.startswith("draft"):
search_args += "&rfcs=on&activedrafts=on&olddrafts=on"
else:
for t in doctypenames:
if n.startswith(t.prefix):
search_args += "&include-%s=on" % t.slug
break
else:
search_args += "&rfcs=on&activedrafts=on&olddrafts=on"
return HttpResponseRedirect(urlreverse("doc_search") + search_args)
def ballot_icon(context, doc):
user = context.get("user")
if not doc:
return ""
if not showballoticon(doc):
return ""
ballot = doc.active_ballot()
if not ballot:
return ""
def sort_key(t):
_, pos = t
if not pos:
return (2, 0)
elif pos.pos.blocking:
return (0, pos.pos.order)
else:
return (1, pos.pos.order)
positions = list(doc.active_ballot().active_ad_positions().items())
positions.sort(key=sort_key)
edit_position_url = ""
if has_role(user, "Area Director"):
edit_position_url = urlreverse('ietf.doc.views_ballot.edit_position', kwargs=dict(name=doc.name, ballot_id=ballot.pk))
title = "IESG positions (click to show more%s)" % (", right-click to edit position" if edit_position_url else "")
res = ['<a href="%s" data-popup="%s" data-edit="%s" title="%s" class="ballot-icon"><table>' % (
urlreverse("doc_ballot", kwargs=dict(name=doc.name, ballot_id=ballot.pk)),
urlreverse("ietf.doc.views_doc.ballot_popup", kwargs=dict(name=doc.name, ballot_id=ballot.pk)),
edit_position_url,
title
)]
res.append("<tr>")
for i, (ad, pos) in enumerate(positions):
if i > 0 and i % 5 == 0:
res.append("</tr>")
res.append("<tr>")
c = "position-%s" % (pos.pos.slug if pos else "norecord")
if user_is_person(user, ad):
c += " my"
res.append('<td class="%s" />' % c)
res.append("</tr>")
res.append("</table></a>")
return "".join(res)
def send_confirmation_mail(self, request):
subject = 'Confirmation for Auto-Post of I-D %s' % self.draft.filename
from_email = settings.IDSUBMIT_FROM_EMAIL
to_email = self.draft.confirmation_email_list()
confirm_url = settings.IDTRACKER_BASE_URL + urlreverse('draft_confirm', kwargs=dict(submission_id=self.draft.submission_id, auth_key=self.draft.auth_key))
status_url = settings.IDTRACKER_BASE_URL + urlreverse('draft_status_by_hash', kwargs=dict(submission_id=self.draft.submission_id, submission_hash=self.draft.get_hash()))
send_mail(request, to_email, from_email, subject, 'submit/confirm_autopost.txt',
{ 'draft': self.draft, 'confirm_url': confirm_url, 'status_url': status_url })
def test_indexes(self):
draft = make_test_data()
r = self.client.get(urlreverse("index_all_drafts"))
self.assertEqual(r.status_code, 200)
self.assertTrue(draft.name in r.content)
r = self.client.get(urlreverse("index_active_drafts"))
self.assertEqual(r.status_code, 200)
self.assertTrue(draft.title in r.content)
def test_initial_charter(self):
make_test_data()
group = Group.objects.get(acronym="mars")
for url in [ urlreverse('ietf.group.edit.submit_initial_charter', kwargs={'acronym':group.acronym}),
urlreverse('ietf.group.edit.submit_initial_charter', kwargs={'acronym':group.acronym,'group_type':group.type_id}),
]:
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url,follow=True)
self.assertEqual(r.status_code,200)
self.assertTrue(r.redirect_chain[0][0].endswith(urlreverse('charter_submit',kwargs={'name':group.charter.name,'option':'initcharter'})))
self.client.logout()
def testAliases(self):
url = urlreverse('doc_specific_email_aliases', kwargs=dict(name="draft-ietf-mars-test"))
r = self.client.get(url)
self.assertEqual(r.status_code, 302)
url = urlreverse('ietf.doc.views_doc.email_aliases', kwargs=dict())
login_testing_unauthorized(self, "plain", url)
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
self.assertTrue(all([x in unicontent(r) for x in ['mars-test@','mars-test.authors@','mars-test.chairs@']]))
self.assertTrue(all([x in unicontent(r) for x in ['ames-test@','ames-test.authors@','ames-test.chairs@']]))
def test_drafts_pages(self):
draft = make_test_data()
r = self.client.get(urlreverse("drafts_for_ad", kwargs=dict(name=draft.ad.full_name_as_key())))
self.assertEqual(r.status_code, 200)
self.assertTrue(draft.title in r.content)
draft.set_state(State.objects.get(type="draft-iesg", slug="lc"))
r = self.client.get(urlreverse("drafts_in_last_call"))
self.assertEqual(r.status_code, 200)
self.assertTrue(draft.title in r.content)
def render_ballot_icon(user, doc):
if not doc:
return ""
if doc.type_id == "draft":
s = doc.get_state("draft-iesg")
if s and s.name not in BALLOT_ACTIVE_STATES:
return ""
elif doc.type_id == "charter":
if doc.get_state_slug() not in ("intrev", "iesgrev"):
return ""
ballot = doc.latest_event(BallotDocEvent, type="created_ballot")
if not ballot:
return ""
edit_position_url = urlreverse('ietf.idrfc.views_ballot.edit_position',
kwargs=dict(name=doc.name,
ballot_id=ballot.pk))
def sort_key(t):
_, pos = t
if not pos:
return (2, 0)
elif pos.pos.blocking:
return (0, pos.pos.order)
else:
return (1, pos.pos.order)
positions = list(doc.active_ballot().active_ad_positions().items())
positions.sort(key=sort_key)
cm = ""
if has_role(user, "Area Director"):
cm = ' oncontextmenu="editBallot(\'' + str(
edit_position_url) + '\');return false;"'
res = [
'<table class="ballot_icon" title="IESG Evaluation Record (click to show more, right-click to edit position)" onclick="showBallot(\''
+ doc.name + '\',\'' + str(edit_position_url) + '\')"' + cm + '>'
]
res.append("<tr>")
for i, (ad, pos) in enumerate(positions):
if i > 0 and i % 5 == 0:
res.append("</tr>")
res.append("<tr>")
c = "position-%s" % (pos.pos.slug if pos else "norecord")
if ad.user_id == user.id:
c += " my"
res.append('<td class="%s" />' % c)
res.append("</tr>")
res.append("</table>")
return "".join(res)
def test_add_not_existing_delegate(self):
make_test_data()
url = urlreverse('manage_delegates', kwargs=dict(acronym="mars"))
login_testing_unauthorized(self, "secretary", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=email]')), 1)
# add non-existing
r = self.client.post(
url, dict(email="*****@*****.**", form_type="single"))
self.assertEquals(r.status_code, 200)
self.assertTrue("*****@*****.**" in r.content)
q = PyQuery(r.content)
self.assertEquals(
len(q('form input[type=submit][value*="Send email"]')), 1)
# we get back a warning and offer to send email, do that
mailbox_before = len(outbox)
r = self.client.post(
url, dict(email="*****@*****.**", form_type="notexist"))
self.assertEquals(r.status_code, 200)
self.assertTrue("Email sent" in r.content)
self.assertEquals(len(outbox), mailbox_before + 3)
def test_add_delegate(self):
make_test_data()
url = urlreverse('manage_delegates', kwargs=dict(acronym="mars"))
login_testing_unauthorized(self, "secretary", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=email]')), 1)
# add existing person
history_before = GroupHistory.objects.filter(acronym="mars").count()
r = self.client.post(
url, dict(email="*****@*****.**", form_type="single"))
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue("new delegate" in r.content)
self.assertTrue(
Email.objects.get(
address="*****@*****.**").person.plain_name() in r.content)
self.assertEquals(
Role.objects.filter(name="delegate",
group__acronym="mars",
email__address="*****@*****.**").count(), 1)
self.assertEquals(history_before + 1,
GroupHistory.objects.filter(acronym="mars").count())
def send_mail_to_secretariat(self, request):
subject = 'Manual Post Requested for %s' % self.draft.filename
from_email = settings.IDSUBMIT_FROM_EMAIL
to_email = settings.IDSUBMIT_TO_EMAIL
cc = [self.cleaned_data['email']]
cc += [i['email'][1] for i in self.authors]
if self.draft.group_acronym:
cc += [
i.person.email()[1]
for i in self.draft.group_acronym.wgchair_set.all()
]
cc = list(set(cc))
submitter = self.draft.tempidauthors_set.get(author_order=0)
send_mail(request,
to_email,
from_email,
subject,
'submit/manual_post_mail.txt', {
'form':
self,
'draft':
self.draft,
'url':
settings.IDTRACKER_BASE_URL + urlreverse(
'draft_status',
kwargs=dict(submission_id=self.draft.submission_id)),
'submitter':
submitter
},
cc=cc)
def link(self, obj):
if obj is None:
raise FeedDoesNotExist
if not hasattr(self, "cached_link"):
self.cached_link = urlreverse(
"doc_history", kwargs=dict(name=obj.canonical_name()))
return self.cached_link
def serveryadis(request):
res = render_to_response("server/yadis.xrds", {
"server_url":
settings.BASE_URL[:-1] + urlreverse("server.views.endpoint")
})
res["Content-Type"] = "application/xrds+xml; charset=%s" % settings.DEFAULT_CHARSET
return res
def email_milestone_review_reminder(group, grace_period=7):
"""Email reminders about milestones needing review to AD."""
if not group.ad:
return False
to = [group.ad.role_email("ad").formatted_email()]
cc = [r.formatted_email() for r in group.role_set.filter(name="chair")]
now = datetime.datetime.now()
too_early = True
milestones = group.groupmilestone_set.filter(state="review")
for m in milestones:
e = m.milestonegroupevent_set.filter(
type="changed_milestone").order_by("-time")[:1]
m.days_ready = (now - e[0].time).days if e else None
if m.days_ready == None or m.days_ready >= grace_period:
too_early = False
if too_early:
return False
subject = u"Reminder: Milestone%s needing review in %s %s" % (
"s" if len(milestones) > 1 else "", group.acronym, group.type.name)
send_mail(
None, to, None, subject, "wginfo/reminder_milestones_need_review.txt",
dict(group=group,
milestones=milestones,
url=settings.IDTRACKER_BASE_URL + urlreverse(
"wg_edit_milestones", kwargs=dict(acronym=group.acronym))))
return True
def test_conclude(self):
make_test_data()
group = Group.objects.get(acronym="mars")
url = urlreverse('wg_conclude', kwargs=dict(acronym=group.acronym))
login_testing_unauthorized(self, "secretary", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form textarea[name=instructions]')), 1)
# faulty post
r = self.client.post(url, dict(instructions="")) # No instructions
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(len(q('form ul.errorlist')) > 0)
# request conclusion
mailbox_before = len(outbox)
r = self.client.post(url, dict(instructions="Test instructions"))
self.assertEquals(r.status_code, 302)
self.assertEquals(len(outbox), mailbox_before + 1)
# the WG remains active until the Secretariat takes action
group = Group.objects.get(acronym=group.acronym)
self.assertEquals(group.state_id, "active")
def test_reset_charter_milestones(self):
m1, m2, group = self.create_test_milestones()
url = urlreverse('wg_reset_charter_milestones',
kwargs=dict(acronym=group.acronym))
login_testing_unauthorized(self, "secretary", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(q('input[name=milestone]').val(), str(m1.pk))
events_before = group.charter.docevent_set.count()
# reset
r = self.client.post(url, dict(milestone=[str(m1.pk)]))
self.assertEquals(r.status_code, 302)
self.assertEquals(
GroupMilestone.objects.get(pk=m1.pk).state_id, "active")
self.assertEquals(
GroupMilestone.objects.get(pk=m2.pk).state_id, "deleted")
self.assertEquals(
GroupMilestone.objects.filter(due=m1.due,
desc=m1.desc,
state="charter").count(), 1)
self.assertEquals(group.charter.docevent_set.count(),
events_before + 2) # 1 delete, 1 add
def test_edit_wgaction(self):
wga = WGAction.objects.all()[0]
url = urlreverse('iesg_edit_working_group_action', kwargs=dict(wga_id=wga.pk))
login_testing_unauthorized(self, "klm", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form select[name=token_name]')), 1)
self.assertEquals(len(q('form select[name=telechat_date]')), 1)
# change
dates = TelechatDates.objects.all()[0]
token_name = IESGLogin.active_iesg().exclude(first_name=wga.token_name)[0].first_name
old = wga.pk
r = self.client.post(url, dict(status_date=dates.date1.isoformat(),
token_name=token_name,
category="23",
note="Testing.",
telechat_date=dates.date4.isoformat()))
self.assertEquals(r.status_code, 302)
wga = WGAction.objects.get(pk=old)
self.assertEquals(wga.status_date, dates.date1)
self.assertEquals(wga.token_name, token_name)
self.assertEquals(wga.category, 23)
self.assertEquals(wga.note, "Testing.")
self.assertEquals(wga.telechat_date, dates.date4)
def test_approval(self):
make_test_data()
liaison = make_liaison_models()
# has to come from WG to need approval
liaison.from_group = Group.objects.get(acronym="mars")
liaison.approved = None
liaison.save()
url = urlreverse('liaison_approval_detail',
kwargs=dict(object_id=liaison.pk))
# this liaison is for a WG so we need the AD for the area
login_testing_unauthorized(self, "ad", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=do_approval]')), 1)
# approve
mailbox_before = len(outbox)
r = self.client.post(url, dict(do_approval="1"))
self.assertEquals(r.status_code, 302)
liaison = LiaisonStatement.objects.get(id=liaison.id)
self.assertTrue(liaison.approved)
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("Liaison Statement" in outbox[-1]["Subject"])
def test_edit_lc(self):
doc = Document.objects.get(name='status-change-imaginary-mid-review')
url = urlreverse('status_change_last_call', kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "ad", url)
# additional setup
doc.relateddocument_set.create(
target=DocAlias.objects.get(name='rfc9999'),
relationship_id='tois')
doc.relateddocument_set.create(
target=DocAlias.objects.get(name='rfc9998'),
relationship_id='tohist')
doc.ad = Person.objects.get(name='Ad No2')
doc.save()
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form.edit-last-call-text')), 1)
self.assertTrue('RFC9999 from Proposed Standard to Internet Standard'
in ''.join(wrap(r.content, 2**16)))
self.assertTrue('RFC9998 from Informational to Historic' in ''.join(
wrap(r.content, 2**16)))
# save
r = self.client.post(
url,
dict(last_call_text="Bogus last call text",
save_last_call_text="1"))
self.assertEquals(r.status_code, 200)
last_call_event = doc.latest_event(WriteupDocEvent,
type="changed_last_call_text")
self.assertEquals(last_call_event.text, "Bogus last call text")
# reset
r = self.client.post(url, dict(regenerate_last_call_text="1"))
self.assertEquals(r.status_code, 200)
self.assertTrue('RFC9999 from Proposed Standard to Internet Standard'
in ''.join(wrap(r.content, 2**16)))
self.assertTrue('RFC9998 from Informational to Historic' in ''.join(
wrap(r.content, 2**16)))
# request last call
messages_before = len(outbox)
r = self.client.post(
url,
dict(last_call_text='stuff',
send_last_call_request='Save+and+Request+Last+Call'))
self.assertEquals(r.status_code, 200)
self.assertTrue(
'Last Call Requested' in ''.join(wrap(r.content, 2**16)))
self.assertEquals(len(outbox), messages_before + 1)
self.assertTrue('iesg-secretary' in outbox[-1]['To'])
self.assertTrue('Last Call:' in outbox[-1]['Subject'])
self.assertTrue('Last Call Request has been submitted' in ''.join(
wrap(unicode(outbox[-1]), 2**16)))
def test_edit_wgaction(self):
from ietf.utils.test_data import make_test_data
from ietf.person.models import Person
make_test_data()
wga = WGAction.objects.all()[0]
url = urlreverse('iesg_edit_working_group_action', kwargs=dict(wga_id=wga.pk))
login_testing_unauthorized(self, "secretary", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form select[name=token_name]')), 1)
self.assertEquals(len(q('form select[name=telechat_date]')), 1)
# change
dates = TelechatDate.objects.active()
token_name = Person.objects.get(name="Ad No1").plain_name()
old = wga.pk
r = self.client.post(url, dict(status_date=dates[0].date.isoformat(),
token_name=token_name,
category="23",
note="Testing.",
telechat_date=dates[3].date.isoformat()))
self.assertEquals(r.status_code, 302)
wga = WGAction.objects.get(pk=old)
self.assertEquals(wga.status_date, dates[0].date)
self.assertEquals(wga.token_name, token_name)
self.assertEquals(wga.category, 23)
self.assertEquals(wga.note, "Testing.")
self.assertEquals(wga.telechat_date, dates[3].date)
def test_create(self):
make_test_data()
url = urlreverse('wg_create')
login_testing_unauthorized(self, "secretary", url)
num_wgs = len(Group.objects.filter(type="wg"))
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=acronym]')), 1)
# faulty post
r = self.client.post(url, dict(acronym="foobarbaz")) # No name
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue(len(q('form ul.errorlist')) > 0)
self.assertEquals(len(Group.objects.filter(type="wg")), num_wgs)
# creation
state = GroupStateName.objects.get(slug="bof")
r = self.client.post(
url, dict(acronym="testwg", name="Testing WG", state=state.pk))
self.assertEquals(r.status_code, 302)
self.assertEquals(len(Group.objects.filter(type="wg")), num_wgs + 1)
group = Group.objects.get(acronym="testwg")
self.assertEquals(group.name, "Testing WG")
self.assertEquals(group.charter.name, "charter-ietf-testwg")
self.assertEquals(group.charter.rev, "00-00")
def test_delete_milestone(self):
m1, m2, group = self.create_test_milestones()
url = urlreverse('wg_edit_milestones',
kwargs=dict(acronym=group.acronym))
login_testing_unauthorized(self, "secretary", url)
milestones_before = GroupMilestone.objects.count()
events_before = group.groupevent_set.count()
# delete
r = self.client.post(
url, {
'prefix': "m1",
'm1-id': m1.id,
'm1-desc': m1.desc,
'm1-due_month': str(m1.due.month),
'm1-due_year': str(m1.due.year),
'm1-resolved': "",
'm1-docs': ",".join(m1.docs.values_list("name", flat=True)),
'm1-delete': "checked",
'action': "save",
})
self.assertEquals(r.status_code, 302)
self.assertEquals(GroupMilestone.objects.count(), milestones_before)
self.assertEquals(group.groupevent_set.count(), events_before + 1)
m = GroupMilestone.objects.get(pk=m1.pk)
self.assertEquals(m.state_id, "deleted")
self.assertTrue(
"Deleted milestone" in m.milestonegroupevent_set.all()[0].desc)
def test_add_possible_wg(self):
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "klm", url)
r = self.client.post(url, dict(add="1",
filename='sieve-charter.txt'))
self.assertEquals(r.status_code, 302)
add_url = r['Location']
r = self.client.get(add_url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertTrue('(sieve)' in r.content)
self.assertEquals(len(q('form select[name=token_name]')), 1)
self.assertEquals(q('form input[name=status_date]')[0].get("value"), "2010-05-07")
self.assertEquals(len(q('form select[name=telechat_date]')), 1)
wgas_before = WGAction.objects.all().count()
dates = TelechatDates.objects.all()[0]
token_name = IESGLogin.active_iesg()[0].first_name
r = self.client.post(add_url,
dict(status_date=dates.date1.isoformat(),
token_name=token_name,
category="23",
note="Testing.",
telechat_date=dates.date4.isoformat()))
self.assertEquals(r.status_code, 302)
self.assertEquals(wgas_before + 1, WGAction.objects.all().count())
def test_taken_care_of(self):
make_test_data()
liaison = make_liaison_models()
url = urlreverse('liaison_detail', kwargs=dict(object_id=liaison.pk))
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=do_action_taken]')), 0)
# log in and get
self.client.login(remote_user="******")
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=do_action_taken]')), 1)
# mark action taken
r = self.client.post(url, dict(do_action_taken="1"))
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[name=do_action_taken]')), 0)
liaison = LiaisonStatement.objects.get(id=liaison.id)
self.assertTrue(liaison.action_taken)
def get_value(self, document, raw=False):
if raw:
return document.group.acronym
else:
return '<a href="%s">%s</a>' % (urlreverse(
'wg_docs', kwargs={'acronym': document.group.acronym}
), document.group.acronym) if (
document.group and document.group.acronym != 'none') else ''
def test_delete_wgaction(self):
wga = WGAction.objects.all()[0]
url = urlreverse('iesg_edit_working_group_action', kwargs=dict(wga_id=wga.pk))
login_testing_unauthorized(self, "klm", url)
r = self.client.post(url, dict(delete="1"))
self.assertEquals(r.status_code, 302)
self.assertTrue(not WGAction.objects.filter(pk=wga.pk))
def possibly_send_deadline_reminder(liaison):
PREVIOUS_DAYS = {
14: 'in two weeks',
7: 'in one week',
4: 'in four days',
3: 'in three days',
2: 'in two days',
1: 'tomorrow',
0: 'today'
}
days_to_go = (liaison.deadline - datetime.date.today()).days
if not (days_to_go < 0 or days_to_go in PREVIOUS_DAYS.keys()):
return None # no reminder
if days_to_go < 0:
subject = '[Liaison OUT OF DATE] %s' % liaison.title
days_msg = 'is out of date for %s days' % (-days_to_go)
else:
subject = '[Liaison deadline %s] %s' % (PREVIOUS_DAYS[days_to_go],
liaison.title)
days_msg = 'expires %s' % PREVIOUS_DAYS[days_to_go]
from_email = settings.LIAISON_UNIVERSAL_FROM
to_email = liaison.to_contact.split(',')
cc = liaison.cc.split(',')
if liaison.technical_contact:
cc += liaison.technical_contact.split(',')
if liaison.response_contact:
cc += liaison.response_contact.split(',')
bcc = '*****@*****.**'
body = render_to_string(
'liaisons/liaison_deadline_mail.txt',
dict(
liaison=liaison,
days_msg=days_msg,
url=settings.IDTRACKER_BASE_URL + urlreverse(
"liaison_approval_detail", kwargs=dict(object_id=liaison.pk)),
referenced_url=settings.IDTRACKER_BASE_URL + urlreverse(
"liaison_detail", kwargs=dict(object_id=liaison.related_to.pk))
if liaison.related_to else None,
))
send_mail_text(None, to_email, from_email, subject, body, cc=cc, bcc=bcc)
return body
def test_document_conflict_review(self):
make_test_data()
r = self.client.get(
urlreverse(
"doc_view",
kwargs=dict(name='conflict-review-imaginary-irtf-submission')))
self.assertEqual(r.status_code, 200)
def notify_pending_by_email(self, fake):
from ietf.liaisons.utils import IETFHM
from_entity = IETFHM.get_entity_by_key(self.from_raw_code)
if not from_entity:
return None
to_email = []
for person in from_entity.can_approve():
to_email.append('%s <%s>' % person.email())
subject = 'New Liaison Statement, "%s" needs your approval' % (self.title)
from_email = settings.LIAISON_UNIVERSAL_FROM
body = render_to_string('liaisons/pending_liaison_mail.txt', {
'liaison': self,
'url': settings.IDTRACKER_BASE_URL + urlreverse("liaison_approval_detail", kwargs=dict(object_id=self.pk)),
'referenced_url': settings.IDTRACKER_BASE_URL + urlreverse("liaison_detail", kwargs=dict(object_id=self.related_to.pk)) if self.related_to else None,
})
send_mail_text(context=None, to=to_email, frm=from_email, subject=subject, txt = body)
def test_approve(self):
doc = Document.objects.get(name='status-change-imaginary-mid-review')
url = urlreverse('status_change_approve', kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "secretary", url)
# Some additional setup
doc.relateddocument_set.create(
target=DocAlias.objects.get(name='rfc9999'),
relationship_id='tois')
doc.relateddocument_set.create(
target=DocAlias.objects.get(name='rfc9998'),
relationship_id='tohist')
create_ballot_if_not_open(doc, Person.objects.get(name="Sec Retary"),
"statchg")
doc.set_state(State.objects.get(slug='appr-pend', type='statchg'))
doc.save()
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form.approve')), 1)
# There should be two messages to edit
self.assertEquals(q('input#id_form-TOTAL_FORMS').val(), '2')
self.assertTrue('(rfc9999) to Internet Standard' in ''.join(
wrap(r.content, 2**16)))
self.assertTrue(
'(rfc9998) to Historic' in ''.join(wrap(r.content, 2**16)))
# submit
messages_before = len(outbox)
msg0 = default_approval_text(doc, doc.relateddocument_set.all()[0])
msg1 = default_approval_text(doc, doc.relateddocument_set.all()[1])
r = self.client.post(
url, {
'form-0-announcement_text': msg0,
'form-1-announcement_text': msg1,
'form-TOTAL_FORMS': '2',
'form-INITIAL_FORMS': '2',
'form-MAX_NUM_FORMS': ''
})
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertEquals(doc.get_state_slug(), 'appr-sent')
self.assertFalse(doc.ballot_open("statchg"))
self.assertEquals(len(outbox), messages_before + 2)
self.assertTrue('Action:' in outbox[-1]['Subject'])
self.assertTrue('(rfc9999) to Internet Standard' in ''.join(
wrap(unicode(outbox[-1]) + unicode(outbox[-2]), 2**16)))
self.assertTrue('(rfc9998) to Historic' in ''.join(
wrap(unicode(outbox[-1]) + unicode(outbox[-2]), 2**16)))
self.assertTrue(
doc.latest_event(DocEvent, type="added_comment").desc.startswith(
'The following approval message was sent'))
def test_delete_possible_wg(self):
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "klm", url)
r = self.client.post(url, dict(delete="1",
filename='sieve-charter.txt'))
self.assertEquals(r.status_code, 200)
self.assertTrue('(sieve)' not in r.content)
def send_by_email(self, fake=False):
if self.is_pending():
return self.notify_pending_by_email(fake)
subject = 'New Liaison Statement, "%s"' % (self.title)
from_email = settings.LIAISON_UNIVERSAL_FROM
to_email = self.to_poc.split(',')
cc = self.cc1.split(',')
if self.technical_contact:
cc += self.technical_contact.split(',')
if self.response_contact:
cc += self.response_contact.split(',')
bcc = ['*****@*****.**']
body = render_to_string('liaisons/liaison_mail.txt', {
'liaison': self,
'url': settings.IDTRACKER_BASE_URL + urlreverse("liaison_detail", kwargs=dict(object_id=self.pk)),
'referenced_url': settings.IDTRACKER_BASE_URL + urlreverse("liaison_detail", kwargs=dict(object_id=self.related_to.pk)) if self.related_to else None,
})
send_mail_text(context=None,to=to_email,frm=from_email,subject=subject,txt=body,cc=cc,bcc=bcc)
def placeOrder(request):
switch = False
#pdb.set_trace()
if request.user.is_anonymous():
#return redirect_to_login('/',login_url="/login")
return HttpResponseRedirect(urlreverse('login'))
else:
#pdb.set_trace()this time switch
d = datetime.date.today()
if datetime.datetime.now() > datetime.datetime(d.year, d.month, d.day,
10, 25, 0, 0):
switch = True
# if lunch was already submitted today...
todays_orders = Order.objects.filter(user=request.user,
date__year=d.year,
date__month=d.month,
date__day=d.day)
if todays_orders.exists():
switch = True
if request.method == 'POST' and not switch: # If the form has been submitted...
#request.META['REMOTE_HOST']
#pdb.set_trace()
form = OrderForm(
request.POST,
instance=Order(user=request.user,
pc=request.META['REMOTE_ADDR'],
total=request.POST.get(
'total'))) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
#pdb.set_trace()
form.save()
return HttpResponseRedirect(urlreverse(
'thanksorder')) # Redirect after POSTthanksorder
else:
form = OrderForm() # An unbound form
return render_to_response('meal/orderform.html', {
'form': form,
'username': request.user.username,
'switch': switch
},
context_instance=RequestContext(request))
def edit_working_group_action(request, wga_id):
if wga_id != None:
wga = get_object_or_404(WGAction, pk=wga_id)
else:
wga = WGAction()
try:
wga.group_acronym = Acronym.objects.get(acronym=request.GET.get('acronym'))
except Acronym.DoesNotExist:
pass
wga.token_name = request.GET.get('token')
try:
d = datetime.datetime.strptime(request.GET.get('status_date'), '%Y-%m-%d').date()
except:
d = datetime.date.today()
wga.status_date = d
wga.telechat_date = TelechatDates.objects.all()[0].date1
wga.agenda = True
initial = dict(telechat_date=wga.telechat_date if wga.agenda else None)
if request.method == 'POST':
if "delete" in request.POST:
wga.delete()
return HttpResponseRedirect(urlreverse('iesg_working_group_actions'))
form = EditWGActionForm(request.POST, instance=wga, initial=initial)
if form.is_valid():
form.save(commit=False)
wga.agenda = bool(form.cleaned_data['telechat_date'])
if wga.category in (11, 21):
wga.agenda = False
if wga.agenda:
wga.telechat_date = form.cleaned_data['telechat_date']
wga.save()
return HttpResponseRedirect(urlreverse('iesg_working_group_actions'))
else:
form = EditWGActionForm(instance=wga, initial=initial)
return render_to_response("iesg/edit_working_group_action.html",
dict(wga=wga,
form=form),
context_instance=RequestContext(request))
def test_edit_telechat_date(self):
doc = Document.objects.get(name='status-change-imaginary-mid-review')
url = urlreverse('status_change_telechat_date',
kwargs=dict(name=doc.name))
login_testing_unauthorized(self, "ad", url)
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('select[name=telechat_date]')), 1)
# set a date
self.assertFalse(
doc.latest_event(TelechatDocEvent, "scheduled_for_telechat"))
telechat_date = TelechatDate.objects.active().order_by('date')[0].date
r = self.client.post(url,
dict(telechat_date=telechat_date.isoformat()))
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertEquals(
doc.latest_event(TelechatDocEvent,
"scheduled_for_telechat").telechat_date,
telechat_date)
# move it forward a telechat (this should set the returning item bit)
telechat_date = TelechatDate.objects.active().order_by('date')[1].date
r = self.client.post(url,
dict(telechat_date=telechat_date.isoformat()))
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertTrue(doc.returning_item())
# clear the returning item bit
r = self.client.post(url,
dict(telechat_date=telechat_date.isoformat()))
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertFalse(doc.returning_item())
# set the returning item bit without changing the date
r = self.client.post(
url,
dict(telechat_date=telechat_date.isoformat(), returning_item="on"))
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertTrue(doc.returning_item())
# Take the doc back off any telechat
r = self.client.post(url, dict(telechat_date=""))
self.assertEquals(r.status_code, 302)
doc = Document.objects.get(name='status-change-imaginary-mid-review')
self.assertEquals(
doc.latest_event(TelechatDocEvent,
"scheduled_for_telechat").telechat_date, None)
def wrap_up_email(to, text):
text = wrap(strip_tags(text), 70)
text += "\n\n"
text += u"URL: %s" % (settings.IDTRACKER_BASE_URL + urlreverse(
"wg_charter", kwargs=dict(acronym=group.acronym)))
send_mail_text(
request, to, None,
u"Milestones changed for %s %s" % (group.acronym, group.type.name),
text)
def test_milestone_sets(self):
m1, m2, group = self.create_test_milestones()
url = urlreverse('wg_edit_milestones',
kwargs=dict(acronym=group.acronym))
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
self.assertTrue(m1.desc in r.content)
self.assertTrue(m2.desc not in r.content)
url = urlreverse('wg_edit_charter_milestones',
kwargs=dict(acronym=group.acronym))
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
self.assertTrue(m1.desc not in r.content)
self.assertTrue(m2.desc in r.content)
