altf4arnold/datatracker
1
0
Fork 0
Code Issues Pull requests Actions 3 Packages Projects Releases Wiki Activity

Merge in changes from the old shimfree branch

Browse source 
- Legacy-Id: 6764
This commit is contained in:
Ole Laursen 2013-11-27 12:55:50 +00:00
parent d2d1c839c9 12722a68fa
commit 9457669310
335 changed files with 12078 additions and 22065 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bin/mkdiagram
View file

@ -9,7 +9,7 @@ trap 'echo "$program($LINENO): Command failed with error code $? ($0 $*)"; exit
if [ "$*" ]; then apps="$@"; graph="${1%.*}"; else apps=$(ls */models.py | sed 's!/models.py!!'); graph="models"; fi
newapps="doc group meeting message person name"
legacyapps="announcements idindex idrfc idtracker iesg ietfauth ietfworkflows ipr liaisons mailinglists proceedings redirects submit wgchairs wgcharter wginfo"
legacyapps="announcements idindex idrfc idtracker iesg ietfauth ipr liaisons mailinglists proceedings redirects submit wgcharter wginfo"
proxy="$(grep ^class */proxy.py | tr '()' ' ' | awk '{printf $2 ","}')"
names="$(grep ^class name/models.py | tr '()' ' ' | awk '{printf $2 ","}')"

20
ietf/bin/expire-submissions Normal file
View file

@ -0,0 +1,20 @@
#!/usr/bin/env python
import datetime, os
import syslog
from ietf import settings
from django.core import management
management.setup_environ(settings)
syslog.openlog(os.path.basename(__file__), syslog.LOG_PID, syslog.LOG_USER)
from ietf.person.models import Person
from ietf.submit.utils import expirable_submissions, expire_submission
system = Person.objects.get(name="(System)")
for sub in expirable_submissions(older_than_days=30):
expire_submission(sub, system)
syslog.syslog("Expired submission %s of %s-%s" % (sub.pk, sub.name, sub.rev))

9
ietf/bin/find-submission-confirmation-email-in-postfix-log
View file

@ -31,7 +31,7 @@ from django.conf import settings
from ietf.utils.path import path as Path
from ietf.submit.models import IdSubmissionDetail
from ietf.submit.models import Submission
from ietf.doc.models import Document
@ -56,13 +56,13 @@ from_email = settings.IDSUBMIT_FROM_EMAIL
if "<" in from_email:
from_email = from_email.split("<")[1].split(">")[0]
submission = IdSubmissionDetail.objects.filter(filename=draft).latest('submission_date')
submission = Submission.objects.filter(name=draft).latest('submission_date')
document = Document.objects.get(name=draft)
emails = [ author.address for author in document.authors.all() ]
timestrings = []
for file in [ Path(settings.INTERNET_DRAFT_PATH) / ("%s-%s.txt"%(draft, submission.revision)),
Path(settings.IDSUBMIT_STAGING_PATH) / ("%s-%s.txt"%(draft, submission.revision)) ]:
for file in [ Path(settings.INTERNET_DRAFT_PATH) / ("%s-%s.txt"%(draft, submission.rev)),
Path(settings.IDSUBMIT_STAGING_PATH) / ("%s-%s.txt"%(draft, submission.rev)) ]:
if os.path.exists(file):
upload_time = time.localtime(file.mtime)
ts = time.strftime("%b %d %H:%M", upload_time)
@ -95,4 +95,3 @@ for log in logfiles:
for qi in queue_ids:
if qi in line:
sys.stdout.write(line)

2
ietf/bin/test-crawl
View file

@ -24,7 +24,7 @@ connection.queries = DontSaveQueries()
MAX_URL_LENGTH = 500
SLOW_THRESHOLD = 1.0
initial = ["/doc/all/", "/doc/in-last-call/"]
initial = ["/doc/all/", "/doc/in-last-call/", "/iesg/decisions/"]
visited = set()
urls = {} # url -> referrer

1
ietf/community/display.py
View file

@ -3,7 +3,6 @@ import datetime
from django.db.models import Q
from django.core.urlresolvers import reverse as urlreverse
from ietf.ietfworkflows.utils import get_state_for_draft
from ietf.doc.models import DocAlias, DocEvent

65
ietf/doc/mails.py
View file

@ -9,7 +9,7 @@ from django.core.urlresolvers import reverse as urlreverse
from ietf.utils.mail import send_mail, send_mail_text
from ietf.ipr.search import iprs_from_docs, related_docs
from ietf.doc.models import WriteupDocEvent, BallotPositionDocEvent, LastCallDocEvent, DocAlias, ConsensusDocEvent
from ietf.doc.models import WriteupDocEvent, BallotPositionDocEvent, LastCallDocEvent, DocAlias, ConsensusDocEvent, DocTagName
from ietf.person.models import Person
from ietf.group.models import Group, Role
@ -413,3 +413,66 @@ def email_last_call_expired(doc):
doc=doc,
url=settings.IDTRACKER_BASE_URL + doc.get_absolute_url()),
cc="iesg-secretary@ietf.org")
def stream_state_email_recipients(doc, extra_recipients=[]):
persons = set()
res = []
for r in Role.objects.filter(group=doc.group, name__in=("chair", "delegate")).select_related("person", "email"):
res.append(r.formatted_email())
persons.add(r.person)
for email in doc.authors.all():
if email.person not in persons:
res.append(email.formatted_email())
persons.add(email.person)
for p in extra_recipients:
if not p in persons:
res.append(p.formatted_email())
persons.add(p)
return res
def email_draft_adopted(request, doc, by, comment):
recipients = stream_state_email_recipients(doc)
send_mail(request, recipients, settings.DEFAULT_FROM_EMAIL,
u"%s adopted in %s %s" % (doc.name, doc.group.acronym, doc.group.type.name),
'doc/mail/draft_adopted_email.txt',
dict(doc=doc,
url=settings.IDTRACKER_BASE_URL + doc.get_absolute_url(),
by=by,
comment=comment))
def email_stream_state_changed(request, doc, prev_state, new_state, by, comment=""):
recipients = stream_state_email_recipients(doc)
state_type = (prev_state or new_state).type
send_mail(request, recipients, settings.DEFAULT_FROM_EMAIL,
u"%s changed for %s" % (state_type.label, doc.name),
'doc/mail/stream_state_changed_email.txt',
dict(doc=doc,
url=settings.IDTRACKER_BASE_URL + doc.get_absolute_url(),
state_type=state_type,
prev_state=prev_state,
new_state=new_state,
by=by,
comment=comment))
def email_stream_tags_changed(request, doc, added_tags, removed_tags, by, comment=""):
extra_recipients = []
if DocTagName.objects.get(slug="sheph-u") in added_tags and doc.shepherd:
extra_recipients.append(doc.shepherd)
recipients = stream_state_email_recipients(doc, extra_recipients)
send_mail(request, recipients, settings.DEFAULT_FROM_EMAIL,
u"Tags changed for %s" % doc.name,
'doc/mail/stream_tags_changed_email.txt',
dict(doc=doc,
url=settings.IDTRACKER_BASE_URL + doc.get_absolute_url(),
added=added_tags,
removed=removed_tags,
by=by,
comment=comment))

435
ietf/doc/migrations/0015_split_state_changing_iesg_approve_events.py Normal file
View file

@ -0,0 +1,435 @@
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import DataMigration
from django.db import models
class Migration(DataMigration):
def forwards(self, orm):
state_mapping = dict((s.name.lower(), s) for s in orm.State.objects.filter(type="draft-iesg"))
doc_type_mapping = {
'draft': " the document",
'conflrev': " the conflict review response",
'statchg': " the status change",
'charter': " the charter",
}
import re
approve_re = re.compile(r"IESG has approved( the charter| the document| the conflict review response| the status change)?( and state has been changed to '?(.*?)'?( by .*)?\.?)?$")
disapprove_re = re.compile("(DNP|Do Not Publish) note has been sent to( the)? RFC Editor( and state has been changed to '?(.*?)'?( by .*)?\.?)?$")
for e in orm.DocEvent.objects.filter(type__in=("iesg_disapproved", "iesg_approved")).order_by("id").select_related("doc").iterator():
if e.type == "iesg_approved":
m = approve_re.match(e.desc)
if not m:
print "FAIL", e.desc
else:
doc_type, state_set, state_name, by = m.groups()
if state_set:
state = state_mapping[state_name.lower()]
s = orm.StateDocEvent()
s.doc_id = e.doc_id
s.by_id = e.by_id
s.type = "changed_state"
s.state_type_id = state.type_id
s.state = state
s.desc = "%s changed to <b>%s</b>" % (state.type.label, state.name)
s.time = e.time
s.save()
#print e.doc_id, s.desc
if not doc_type:
doc_type = doc_type_mapping[e.doc.type_id]
new_desc = "IESG has approved%s" % doc_type
if new_desc != e.desc:
#print e.doc_id, e.desc, "->", new_desc
orm.DocEvent.objects.filter(id=e.id).update(desc=new_desc)
elif e.type == "iesg_disapproved":
m = disapprove_re.match(e.desc)
if not m:
print "FAIL", e.desc
else:
dnp, the, state_set, state_name, by = m.groups()
if state_set:
state = state_mapping[state_name.lower()]
s = orm.StateDocEvent()
s.doc_id = e.doc_id
s.by_id = e.by_id
s.type = "changed_state"
s.state_type_id = state.type_id
s.state = state
s.desc = "%s changed to <b>%s</b>" % (state.type.label, state.name)
s.time = e.time
s.save()
#print e.doc_id, s.desc
new_desc = "Do Not Publish note has been sent to the RFC Editor"
if new_desc != e.desc:
#print e.doc_id, e.desc, "->", new_desc
orm.DocEvent.objects.filter(id=e.id).update(desc=new_desc)
def backwards(self, orm):
"Write your backwards methods here."
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'doc.ballotdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'BallotDocEvent', '_ormbases': ['doc.DocEvent']},
'ballot_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.BallotType']"}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'})
},
'doc.ballotpositiondocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'BallotPositionDocEvent', '_ormbases': ['doc.DocEvent']},
'ad': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'ballot': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['doc.BallotDocEvent']", 'null': 'True'}),
'comment': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'comment_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'discuss': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'discuss_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'pos': ('django.db.models.fields.related.ForeignKey', [], {'default': "'norecord'", 'to': "orm['name.BallotPositionName']"})
},
'doc.ballottype': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotType'},
'doc_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'positions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['name.BallotPositionName']", 'symmetrical': 'False', 'blank': 'True'}),
'question': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50', 'db_index': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'doc.consensusdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'ConsensusDocEvent', '_ormbases': ['doc.DocEvent']},
'consensus': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'})
},
'doc.deletedevent': {
'Meta': {'object_name': 'DeletedEvent'},
'by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'json': ('django.db.models.fields.TextField', [], {}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'})
},
'doc.docalias': {
'Meta': {'object_name': 'DocAlias'},
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'})
},
'doc.docevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'DocEvent'},
'by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'desc': ('django.db.models.fields.TextField', [], {}),
'doc': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now', 'db_index': 'True'}),
'type': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'doc.dochistory': {
'Meta': {'object_name': 'DocHistory'},
'abstract': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'ad_dochistory_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'authors': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['person.Email']", 'symmetrical': 'False', 'through': "orm['doc.DocHistoryAuthor']", 'blank': 'True'}),
'doc': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'history_set'", 'to': "orm['doc.Document']"}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'external_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.IntendedStdLevelName']", 'null': 'True', 'blank': 'True'}),
'internal_comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'note': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'notify': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1', 'blank': 'True'}),
'pages': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'related': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.DocAlias']", 'symmetrical': 'False', 'through': "orm['doc.RelatedDocHistory']", 'blank': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'shepherd_dochistory_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StdLevelName']", 'null': 'True', 'blank': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StreamName']", 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['name.DocTagName']", 'null': 'True', 'blank': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'})
},
'doc.dochistoryauthor': {
'Meta': {'ordering': "['document', 'order']", 'object_name': 'DocHistoryAuthor'},
'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Email']"}),
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocHistory']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {})
},
'doc.docreminder': {
'Meta': {'object_name': 'DocReminder'},
'active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'due': ('django.db.models.fields.DateTimeField', [], {}),
'event': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocEvent']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocReminderTypeName']"})
},
'doc.document': {
'Meta': {'object_name': 'Document'},
'abstract': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'ad_document_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'authors': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['person.Email']", 'symmetrical': 'False', 'through': "orm['doc.DocumentAuthor']", 'blank': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'external_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'intended_std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.IntendedStdLevelName']", 'null': 'True', 'blank': 'True'}),
'internal_comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'primary_key': 'True'}),
'note': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'notify': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1', 'blank': 'True'}),
'pages': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'shepherd_document_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StdLevelName']", 'null': 'True', 'blank': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StreamName']", 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['name.DocTagName']", 'null': 'True', 'blank': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'})
},
'doc.documentauthor': {
'Meta': {'ordering': "['document', 'order']", 'object_name': 'DocumentAuthor'},
'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Email']"}),
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1'})
},
'doc.initialreviewdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'InitialReviewDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
},
'doc.lastcalldocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'LastCallDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
},
'doc.newrevisiondocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'NewRevisionDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16'})
},
'doc.relateddochistory': {
'Meta': {'object_name': 'RelatedDocHistory'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relationship': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocRelationshipName']"}),
'source': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocHistory']"}),
'target': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'reversely_related_document_history_set'", 'to': "orm['doc.DocAlias']"})
},
'doc.relateddocument': {
'Meta': {'object_name': 'RelatedDocument'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relationship': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocRelationshipName']"}),
'source': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'target': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocAlias']"})
},
'doc.state': {
'Meta': {'ordering': "['type', 'order']", 'object_name': 'State'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'next_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'previous_states'", 'blank': 'True', 'to': "orm['doc.State']"}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50', 'db_index': 'True'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.StateType']"}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'doc.statedocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'StateDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.State']", 'null': 'True', 'blank': 'True'}),
'state_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.StateType']"})
},
'doc.statetype': {
'Meta': {'object_name': 'StateType'},
'label': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '30', 'primary_key': 'True'})
},
'doc.telechatdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'TelechatDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'returning_item': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'telechat_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'doc.writeupdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'WriteupDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'text': ('django.db.models.fields.TextField', [], {'blank': 'True'})
},
'group.group': {
'Meta': {'object_name': 'Group'},
'acronym': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '40', 'db_index': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']", 'null': 'True', 'blank': 'True'}),
'charter': ('django.db.models.fields.related.OneToOneField', [], {'blank': 'True', 'related_name': "'chartered_group'", 'unique': 'True', 'null': 'True', 'to': "orm['doc.Document']"}),
'comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'list_archive': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'list_email': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'list_subscribe': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '80'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.GroupStateName']", 'null': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.GroupTypeName']", 'null': 'True'}),
'unused_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'unused_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['name.DocTagName']", 'symmetrical': 'False', 'blank': 'True'})
},
'name.ballotpositionname': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotPositionName'},
'blocking': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docrelationshipname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocRelationshipName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'revname': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docremindertypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocReminderTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctagname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTagName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.grouptypename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.intendedstdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'IntendedStdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.stdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'StdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.streamname': {
'Meta': {'ordering': "['order']", 'object_name': 'StreamName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'person.email': {
'Meta': {'object_name': 'Email'},
'active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'address': ('django.db.models.fields.CharField', [], {'max_length': '64', 'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']", 'null': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'})
},
'person.person': {
'Meta': {'object_name': 'Person'},
'address': ('django.db.models.fields.TextField', [], {'max_length': '255', 'blank': 'True'}),
'affiliation': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'ascii': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'ascii_short': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True', 'null': 'True', 'blank': 'True'})
}
}
complete_apps = ['doc']

370
ietf/doc/migrations/0016_add_docevent_time_index.py Normal file
View file

@ -0,0 +1,370 @@
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding index on 'DocEvent', fields ['time']
db.create_index('doc_docevent', ['time'])
def backwards(self, orm):
# Removing index on 'DocEvent', fields ['time']
db.delete_index('doc_docevent', ['time'])
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'doc.ballotdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'BallotDocEvent', '_ormbases': ['doc.DocEvent']},
'ballot_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.BallotType']"}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'})
},
'doc.ballotpositiondocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'BallotPositionDocEvent', '_ormbases': ['doc.DocEvent']},
'ad': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'ballot': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['doc.BallotDocEvent']", 'null': 'True'}),
'comment': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'comment_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'discuss': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'discuss_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'pos': ('django.db.models.fields.related.ForeignKey', [], {'default': "'norecord'", 'to': "orm['name.BallotPositionName']"})
},
'doc.ballottype': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotType'},
'doc_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'positions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['name.BallotPositionName']", 'symmetrical': 'False', 'blank': 'True'}),
'question': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50', 'db_index': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'doc.consensusdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'ConsensusDocEvent', '_ormbases': ['doc.DocEvent']},
'consensus': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'})
},
'doc.deletedevent': {
'Meta': {'object_name': 'DeletedEvent'},
'by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'json': ('django.db.models.fields.TextField', [], {}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'})
},
'doc.docalias': {
'Meta': {'object_name': 'DocAlias'},
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'})
},
'doc.docevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'DocEvent'},
'by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']"}),
'desc': ('django.db.models.fields.TextField', [], {}),
'doc': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now', 'db_index': 'True'}),
'type': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'doc.dochistory': {
'Meta': {'object_name': 'DocHistory'},
'abstract': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'ad_dochistory_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'authors': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['person.Email']", 'symmetrical': 'False', 'through': "orm['doc.DocHistoryAuthor']", 'blank': 'True'}),
'doc': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'history_set'", 'to': "orm['doc.Document']"}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'external_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.IntendedStdLevelName']", 'null': 'True', 'blank': 'True'}),
'internal_comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'note': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'notify': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1', 'blank': 'True'}),
'pages': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'related': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.DocAlias']", 'symmetrical': 'False', 'through': "orm['doc.RelatedDocHistory']", 'blank': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'shepherd_dochistory_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StdLevelName']", 'null': 'True', 'blank': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StreamName']", 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['name.DocTagName']", 'null': 'True', 'blank': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'})
},
'doc.dochistoryauthor': {
'Meta': {'ordering': "['document', 'order']", 'object_name': 'DocHistoryAuthor'},
'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Email']"}),
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocHistory']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {})
},
'doc.docreminder': {
'Meta': {'object_name': 'DocReminder'},
'active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'due': ('django.db.models.fields.DateTimeField', [], {}),
'event': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocEvent']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocReminderTypeName']"})
},
'doc.document': {
'Meta': {'object_name': 'Document'},
'abstract': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'ad_document_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'authors': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['person.Email']", 'symmetrical': 'False', 'through': "orm['doc.DocumentAuthor']", 'blank': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'external_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'intended_std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.IntendedStdLevelName']", 'null': 'True', 'blank': 'True'}),
'internal_comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'primary_key': 'True'}),
'note': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'notify': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1', 'blank': 'True'}),
'pages': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'shepherd_document_set'", 'null': 'True', 'to': "orm['person.Person']"}),
'states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'std_level': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StdLevelName']", 'null': 'True', 'blank': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.StreamName']", 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['name.DocTagName']", 'null': 'True', 'blank': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocTypeName']", 'null': 'True', 'blank': 'True'})
},
'doc.documentauthor': {
'Meta': {'ordering': "['document', 'order']", 'object_name': 'DocumentAuthor'},
'author': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Email']"}),
'document': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '1'})
},
'doc.initialreviewdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'InitialReviewDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
},
'doc.lastcalldocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'LastCallDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'expires': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
},
'doc.newrevisiondocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'NewRevisionDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'rev': ('django.db.models.fields.CharField', [], {'max_length': '16'})
},
'doc.relateddochistory': {
'Meta': {'object_name': 'RelatedDocHistory'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relationship': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocRelationshipName']"}),
'source': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocHistory']"}),
'target': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'reversely_related_document_history_set'", 'to': "orm['doc.DocAlias']"})
},
'doc.relateddocument': {
'Meta': {'object_name': 'RelatedDocument'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relationship': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.DocRelationshipName']"}),
'source': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.Document']"}),
'target': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.DocAlias']"})
},
'doc.state': {
'Meta': {'ordering': "['type', 'order']", 'object_name': 'State'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'next_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'previous_states'", 'blank': 'True', 'to': "orm['doc.State']"}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '50', 'db_index': 'True'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.StateType']"}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'doc.statedocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'StateDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.State']", 'null': 'True', 'blank': 'True'}),
'state_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['doc.StateType']"})
},
'doc.statetype': {
'Meta': {'object_name': 'StateType'},
'label': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '30', 'primary_key': 'True'})
},
'doc.telechatdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'TelechatDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'returning_item': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'telechat_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'doc.writeupdocevent': {
'Meta': {'ordering': "['-time', '-id']", 'object_name': 'WriteupDocEvent', '_ormbases': ['doc.DocEvent']},
'docevent_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['doc.DocEvent']", 'unique': 'True', 'primary_key': 'True'}),
'text': ('django.db.models.fields.TextField', [], {'blank': 'True'})
},
'group.group': {
'Meta': {'object_name': 'Group'},
'acronym': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '40', 'db_index': 'True'}),
'ad': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']", 'null': 'True', 'blank': 'True'}),
'charter': ('django.db.models.fields.related.OneToOneField', [], {'blank': 'True', 'related_name': "'chartered_group'", 'unique': 'True', 'null': 'True', 'to': "orm['doc.Document']"}),
'comments': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'list_archive': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'list_email': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'list_subscribe': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '80'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['group.Group']", 'null': 'True', 'blank': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.GroupStateName']", 'null': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['name.GroupTypeName']", 'null': 'True'}),
'unused_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['doc.State']", 'symmetrical': 'False', 'blank': 'True'}),
'unused_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['name.DocTagName']", 'symmetrical': 'False', 'blank': 'True'})
},
'name.ballotpositionname': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotPositionName'},
'blocking': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docrelationshipname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocRelationshipName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'revname': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docremindertypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocReminderTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctagname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTagName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.grouptypename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.intendedstdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'IntendedStdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.stdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'StdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.streamname': {
'Meta': {'ordering': "['order']", 'object_name': 'StreamName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'person.email': {
'Meta': {'object_name': 'Email'},
'active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'address': ('django.db.models.fields.CharField', [], {'max_length': '64', 'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['person.Person']", 'null': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'})
},
'person.person': {
'Meta': {'object_name': 'Person'},
'address': ('django.db.models.fields.TextField', [], {'max_length': '255', 'blank': 'True'}),
'affiliation': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'ascii': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'ascii_short': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'time': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True', 'null': 'True', 'blank': 'True'})
}
}
complete_apps = ['doc']

34
ietf/doc/models.py
View file

@ -80,6 +80,8 @@ class DocumentInfo(models.Model):
return settings.CHARTER_PATH
elif self.type_id == "conflrev":
return settings.CONFLICT_REVIEW_PATH
elif self.type_id == "statchg":
return settings.STATUS_CHANGE_PATH
else:
raise NotImplemented
@ -120,7 +122,7 @@ class DocumentInfo(models.Model):
if not hasattr(self, "state_cache") or self.state_cache == None:
self.state_cache = {}
for s in self.states.all().select_related():
for s in self.states.all().select_related("type"):
self.state_cache[s.type_id] = s
return self.state_cache.get(state_type, None)
@ -147,8 +149,8 @@ class DocumentInfo(models.Model):
def active_ballot(self):
"""Returns the most recently created ballot if it isn't closed."""
ballot = self.latest_event(BallotDocEvent, type="created_ballot")
if ballot and self.ballot_open(ballot.ballot_type.slug):
ballot = self.latest_event(BallotDocEvent, type__in=("created_ballot", "closed_ballot"))
if ballot and ballot.type == "created_ballot":
return ballot
else:
return None
@ -306,7 +308,7 @@ class Document(DocumentInfo):
if g:
if g.type_id == "area":
return g.acronym
elif g.type_id != "individ":
elif g.type_id != "individ" and g.parent:
return g.parent.acronym
else:
return None
@ -339,7 +341,7 @@ class Document(DocumentInfo):
return self.latest_event(LastCallDocEvent,type="sent_last_call")
def displayname_with_link(self):
return '<a href="%s">%s-%s</a>' % (self.get_absolute_url(), self.name , self.rev)
return mark_safe('<a href="%s">%s-%s</a>' % (self.get_absolute_url(), self.name , self.rev))
def rfc_number(self):
n = self.canonical_name()
@ -568,7 +570,7 @@ EVENT_TYPES = [
class DocEvent(models.Model):
"""An occurrence for a document, used for tracking who, when and what."""
time = models.DateTimeField(default=datetime.datetime.now, help_text="When the event happened")
time = models.DateTimeField(default=datetime.datetime.now, help_text="When the event happened", db_index=True)
type = models.CharField(max_length=50, choices=EVENT_TYPES)
by = models.ForeignKey(Person)
doc = models.ForeignKey('doc.Document')
@ -614,17 +616,15 @@ class BallotDocEvent(DocEvent):
active_ads = list(Person.objects.filter(role__name="ad", role__group__state="active"))
res = {}
if self.doc.latest_event(BallotDocEvent, type="created_ballot") == self:
positions = BallotPositionDocEvent.objects.filter(type="changed_ballot_position",ad__in=active_ads, ballot=self).select_related('ad', 'pos').order_by("-time", "-id")
for pos in positions:
if pos.ad not in res:
res[pos.ad] = pos
for ad in active_ads:
if ad not in res:
res[ad] = None
positions = BallotPositionDocEvent.objects.filter(type="changed_ballot_position",ad__in=active_ads, ballot=self).select_related('ad', 'pos').order_by("-time", "-id")
for pos in positions:
if pos.ad not in res:
res[pos.ad] = pos
for ad in active_ads:
if ad not in res:
res[ad] = None
return res
def all_positions(self):

5
ietf/doc/proxy.py
View file

@ -194,11 +194,6 @@ class InternetDraft(Document):
def authors(self):
return IDAuthor.objects.filter(document=self)
@property
def protowriteup_set(self):
from ietf.wgchairs.models import ProtoWriteUpProxy
return ProtoWriteUpProxy.objects.filter(doc=self, type="changed_protocol_writeup")
# methods from InternetDraft
def displayname(self):
return self.name

72
ietf/doc/templatetags/ballot_icon.py
View file

@ -40,31 +40,35 @@ from django.utils.safestring import mark_safe
from ietf.ietfauth.utils import user_is_person, has_role
from ietf.doc.models import BallotDocEvent, BallotPositionDocEvent, IESG_BALLOT_ACTIVE_STATES, IESG_SUBSTATE_TAGS
from ietf.name.models import BallotPositionName
register = template.Library()
def render_ballot_icon(user, doc):
@register.filter
def showballoticon(doc):
if doc.type_id == "draft":
if doc.get_state_slug("draft-iesg") not in IESG_BALLOT_ACTIVE_STATES:
return False
elif doc.type_id == "charter":
if doc.get_state_slug() not in ("intrev", "iesgrev"):
return False
elif doc.type_id == "conflrev":
if doc.get_state_slug() not in ("iesgeval","defer"):
return False
elif doc.type_id == "statchg":
if doc.get_state_slug() not in ("iesgeval","defer"):
return False
return True
def render_ballot_icon(doc, user):
if not doc:
return ""
# FIXME: temporary backwards-compatibility hack
from ietf.doc.models import Document
if not isinstance(doc, Document):
doc = doc._draft
if doc.type_id == "draft":
if doc.get_state_slug("draft-iesg") not in IESG_BALLOT_ACTIVE_STATES:
return ""
elif doc.type_id == "charter":
if doc.get_state_slug() not in ("intrev", "iesgrev"):
return ""
elif doc.type_id == "conflrev":
if doc.get_state_slug() not in ("iesgeval","defer"):
return ""
elif doc.type_id == "statchg":
if doc.get_state_slug() not in ("iesgeval","defer"):
return ""
if not showballoticon(doc):
return ""
ballot = doc.active_ballot()
if not ballot:
@ -119,7 +123,7 @@ class BallotIconNode(template.Node):
self.doc_var = doc_var
def render(self, context):
doc = template.resolve_variable(self.doc_var, context)
return render_ballot_icon(context.get("user"), doc)
return render_ballot_icon(doc, context.get("user"))
def do_ballot_icon(parser, token):
try:
@ -132,29 +136,24 @@ register.tag('ballot_icon', do_ballot_icon)
@register.filter
def my_position(doc, user):
if not has_role(user, "Area Director"):
def ballotposition(doc, user):
if not showballoticon(doc) or not has_role(user, "Area Director"):
return None
# FIXME: temporary backwards-compatibility hack
from ietf.doc.models import Document
if not isinstance(doc, Document):
doc = doc._draft
ballot = doc.active_ballot()
pos = "No Record"
if ballot:
changed_pos = doc.latest_event(BallotPositionDocEvent, type="changed_ballot_position", ad__user=user, ballot=ballot)
if changed_pos:
pos = changed_pos.pos.name;
if not ballot:
return None
changed_pos = doc.latest_event(BallotPositionDocEvent, type="changed_ballot_position", ad__user=user, ballot=ballot)
if changed_pos:
pos = changed_pos.pos
else:
pos = BallotPositionName.objects.get(slug="norecord")
return pos
@register.filter()
def state_age_colored(doc):
# FIXME: temporary backwards-compatibility hack
from ietf.doc.models import Document
if not isinstance(doc, Document):
doc = doc._draft
@register.filter
def state_age_colored(doc):
if doc.type_id == 'draft':
if not doc.get_state_slug() in ["active", "rfc"]:
# Don't show anything for expired/withdrawn/replaced drafts
@ -174,7 +173,6 @@ def state_age_colored(doc):
Q(desc__istartswith="State Changes to ")|
Q(desc__istartswith="Sub state has been changed to ")|
Q(desc__istartswith="State has been changed to ")|
Q(desc__istartswith="IESG has approved and state has been changed to")|
Q(desc__istartswith="IESG process started in state")
).order_by('-time')[0].time.date()
except IndexError:

29
ietf/doc/templatetags/ietf_filters.py
View file

@ -9,6 +9,7 @@ from django.template.defaultfilters import linebreaksbr, wordwrap, stringfilter,
from django.template import resolve_variable
from django.utils.safestring import mark_safe, SafeData
from django.utils import simplejson
from django.utils.html import strip_tags
try:
from email import utils as emailutils
except ImportError:
@ -276,6 +277,10 @@ def truncate_ellipsis(text, arg):
else:
return escape(text)
@register.filter
def split(text, splitter=None):
return text.split(splitter)
@register.filter(name="wrap_long_lines")
def wrap_long_lines(text):
"""Wraps long lines without loosing the formatting and indentation
@ -413,14 +418,6 @@ def equal(x, y):
def startswith(x, y):
return unicode(x).startswith(y)
# based on http://www.djangosnippets.org/snippets/847/ by 'whiteinge'
@register.filter
def in_group(user, groups):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return has_role(user, groups.replace("Area_Director", "Area Director"))
return user and user.is_authenticated() and bool(user.groups.filter(name__in=groups.split(',')).values('name'))
@register.filter
def has_role(user, role_names):
from ietf.ietfauth.decorators import has_role
@ -475,6 +472,18 @@ def state(doc, slug):
slug = "%s-stream-%s" % (doc.type_id, doc.stream_id)
return doc.get_state(slug)
@register.filter
def statehelp(state):
"Output help icon with tooltip for state."
from django.core.urlresolvers import reverse as urlreverse
tooltip = escape(strip_tags(state.desc))
url = urlreverse("state_help", kwargs=dict(type=state.type_id)) + "#" + state.slug
return mark_safe('<a class="state-help-icon" href="%s" title="%s">?</a>' % (url, tooltip))
@register.filter
def sectionlevel(section_number):
return section_number.count(".") + 1
def _test():
import doctest
doctest.testmod()
@ -483,13 +492,13 @@ if __name__ == "__main__":
_test()
@register.filter
def plural(text, list, arg=u's'):
def plural(text, seq, arg=u's'):
"Similar to pluralize, but looks at the text, too"
from django.template.defaultfilters import pluralize
if text.endswith('s'):
return text
else:
return text + pluralize(len(list), arg)
return text + pluralize(len(seq), arg)
@register.filter
def ics_esc(text):

32
ietf/doc/templatetags/streams_menu.py Normal file
View file

@ -0,0 +1,32 @@
from django import template
from django.conf import settings
from django.core.urlresolvers import reverse as urlreverse
from django.contrib.auth.models import AnonymousUser
from ietf.ietfauth.utils import has_role
from ietf.group.models import Group
from ietf.name.models import StreamName
register = template.Library()
@register.inclusion_tag('base/streams_menu.html', takes_context=True)
def streams_menu(context):
editable_streams = []
user = context["request"].user if "request" in context else AnonymousUser()
if user.is_authenticated():
streams = StreamName.objects.exclude(slug="legacy")
if has_role(user, "Secretariat"):
editable_streams.extend(streams)
else:
acronyms = Group.objects.filter(acronym__in=(s.slug for s in streams),
role__name="chair",
role__person__user=user).distinct().values_list("acronym", flat=True)
for s in streams:
if s.slug in acronyms:
editable_streams.append(s)
return { 'editable_streams': editable_streams }

2
ietf/doc/templatetags/wg_menu.py
View file

@ -61,7 +61,7 @@ class WgMenuNode(template.Node):
areas = [a for a in areas if a.active_groups]
res = loader.render_to_string('base_wgmenu.html', {'areas':areas})
res = loader.render_to_string('base/wg_menu.html', {'areas':areas})
cache.set('base_left_wgmenu', x, 30*60)
return res

9
ietf/doc/tests.py
View file

@ -24,9 +24,6 @@ from ietf.doc.tests_status_change import *
class SearchTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
def test_search(self):
draft = make_test_data()
@ -127,9 +124,6 @@ class SearchTestCase(TestCase):
class DocTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
def test_document_draft(self):
draft = make_test_data()
@ -251,9 +245,6 @@ class DocTestCase(TestCase):
class AddCommentTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
def test_add_comment(self):
draft = make_test_data()
url = urlreverse('doc_add_comment', kwargs=dict(name=draft.name))

22
ietf/doc/tests_ballot.py
View file

@ -20,10 +20,7 @@ from ietf.utils.test_data import make_test_data
from ietf.utils.mail import outbox
from ietf.utils import TestCase
class EditPositionTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class EditPositionTests(TestCase):
def test_edit_position(self):
draft = make_test_data()
url = urlreverse('ietf.doc.views_ballot.edit_position', kwargs=dict(name=draft.name,
@ -170,10 +167,7 @@ class EditPositionTestCase(TestCase):
self.assertTrue("Test!" in str(m))
class DeferBallotTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class DeferBallotTests(TestCase):
def test_defer_ballot(self):
draft = make_test_data()
draft.set_state(State.objects.get(used=True, type="draft-iesg", slug="iesg-eva"))
@ -217,10 +211,8 @@ class DeferBallotTestCase(TestCase):
draft = Document.objects.get(name=draft.name)
self.assertEquals(draft.get_state_slug("draft-iesg"), "iesg-eva")
class BallotWriteupsTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class BallotWriteupsTests(TestCase):
def test_edit_last_call_text(self):
draft = make_test_data()
url = urlreverse('doc_ballot_lastcall', kwargs=dict(name=draft.name))
@ -409,10 +401,8 @@ class BallotWriteupsTestCase(TestCase):
draft = Document.objects.get(name=draft.name)
self.assertTrue("Subject: Results of IETF-conflict review" in draft.latest_event(WriteupDocEvent, type="changed_ballot_approval_text").text)
class ApproveBallotTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ApproveBallotTests(TestCase):
def test_approve_ballot(self):
draft = make_test_data()
draft.set_state(State.objects.get(used=True, type="draft-iesg", slug="iesg-eva")) # make sure it's approvable
@ -460,10 +450,8 @@ class ApproveBallotTestCase(TestCase):
self.assertEquals(len(outbox), mailbox_before + 3)
self.assertTrue("NOT be published" in str(outbox[-1]))
class MakeLastCallTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class MakeLastCallTests(TestCase):
def test_make_last_call(self):
draft = make_test_data()
draft.set_state(State.objects.get(used=True, type="draft-iesg", slug="lc-req"))

10
ietf/doc/tests_conflict_review.py
View file

@ -22,10 +22,7 @@ from ietf.group.models import Person
from ietf.iesg.models import TelechatDate
class ConflictReviewTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ConflictReviewTests(TestCase):
def test_start_review(self):
doc = Document.objects.get(name='draft-imaginary-independent-submission')
@ -254,10 +251,7 @@ class ConflictReviewTestCase(TestCase):
make_test_data()
class ConflictReviewSubmitTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names',]
class ConflictReviewSubmitTests(TestCase):
def test_initial_submission(self):
doc = Document.objects.get(name='conflict-review-imaginary-irtf-submission')
url = urlreverse('conflict_review_submit',kwargs=dict(name=doc.name))

157
ietf/doc/tests_draft.py
View file

@ -10,6 +10,7 @@ from pyquery import PyQuery
import debug
from ietf.doc.models import *
from ietf.doc .utils import *
from ietf.name.models import *
from ietf.group.models import *
from ietf.person.models import *
@ -21,10 +22,7 @@ from ietf.utils.mail import outbox
from ietf.utils import TestCase
class ChangeStateTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ChangeStateTests(TestCase):
def test_change_state(self):
draft = make_test_data()
draft.set_state(State.objects.get(used=True, type="draft-iesg", slug="ad-eval"))
@ -178,10 +176,7 @@ class ChangeStateTestCase(TestCase):
self.assertTrue("Last call was requested" in draft.latest_event().desc)
class EditInfoTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class EditInfoTests(TestCase):
def test_edit_info(self):
draft = make_test_data()
url = urlreverse('doc_edit_info', kwargs=dict(name=draft.name))
@ -361,10 +356,7 @@ class EditInfoTestCase(TestCase):
self.assertEqual(draft.latest_event(ConsensusDocEvent, type="changed_consensus").consensus, True)
class ResurrectTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ResurrectTests(TestCase):
def test_request_resurrect(self):
draft = make_test_data()
draft.set_state(State.objects.get(used=True, type="draft", slug="expired"))
@ -429,10 +421,7 @@ class ResurrectTestCase(TestCase):
self.assertEquals(len(outbox), mailbox_before + 1)
class ExpireIDsTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ExpireIDsTests(TestCase):
def setUp(self):
self.id_dir = os.path.abspath("tmp-id-dir")
self.archive_dir = os.path.abspath("tmp-id-archive")
@ -612,10 +601,8 @@ class ExpireIDsTestCase(TestCase):
self.assertTrue(not os.path.exists(os.path.join(self.id_dir, txt)))
self.assertTrue(os.path.exists(os.path.join(self.archive_dir, "deleted_tombstones", txt)))
class ExpireLastCallTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class ExpireLastCallTests(TestCase):
def test_expire_last_call(self):
from ietf.doc.lastcall import get_expired_last_calls, expire_last_call
@ -662,10 +649,8 @@ class ExpireLastCallTestCase(TestCase):
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("Last Call Expired" in outbox[-1]["Subject"])
class IndividualInfoFormsTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class IndividualInfoFormsTests(TestCase):
def test_doc_change_stream(self):
url = urlreverse('doc_change_stream', kwargs=dict(name=self.docname))
login_testing_unauthorized(self, "secretary", url)
@ -890,10 +875,8 @@ class IndividualInfoFormsTestCase(TestCase):
self.docname='draft-ietf-mars-test'
self.doc = Document.objects.get(name=self.docname)
class SubmitToIesgTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class SubmitToIesgTests(TestCase):
def verify_permissions(self):
def verify_fail(remote_user):
@ -951,10 +934,8 @@ class SubmitToIesgTestCase(TestCase):
self.doc = Document.objects.get(name=self.docname)
self.doc.unset_state('draft-iesg')
class RequestPublicationTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class RequestPublicationTests(TestCase):
def test_request_publication(self):
draft = make_test_data()
draft.stream = StreamName.objects.get(slug="iab")
@ -990,3 +971,123 @@ class RequestPublicationTestCase(TestCase):
# the IANA copy
self.assertTrue("Document Action" in outbox[-1]['Subject'])
self.assertTrue(not outbox[-1]['CC'])
class AdoptDraftTests(TestCase):
def test_adopt_document(self):
draft = make_test_data()
draft.stream = None
draft.group = Group.objects.get(type="individ")
draft.save()
draft.unset_state("draft-stream-ietf")
url = urlreverse('doc_adopt_draft', kwargs=dict(name=draft.name))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
self.assertEqual(len(q('form select[name="group"] option')), 1) # we can only select "mars"
# adopt in mars WG
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
r = self.client.post(url,
dict(comment="some comment",
group=Group.objects.get(acronym="mars").pk,
weeks="10"))
self.assertEqual(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEqual(draft.group.acronym, "mars")
self.assertEqual(draft.stream_id, "ietf")
self.assertEqual(draft.docevent_set.count() - events_before, 4)
self.assertEqual(len(outbox), mailbox_before + 1)
self.assertTrue("adopted" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))
class ChangeStreamStateTests(TestCase):
def test_set_tags(self):
draft = make_test_data()
draft.tags = DocTagName.objects.filter(slug="w-expert")
draft.group.unused_tags.add("w-refdoc")
url = urlreverse('doc_change_stream_state', kwargs=dict(name=draft.name, state_type="draft-stream-ietf"))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
# make sure the unused tags are hidden
unused = draft.group.unused_tags.values_list("slug", flat=True)
for t in q("input[name=tags]"):
self.assertTrue(t.attrib["value"] not in unused)
# set tags
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
r = self.client.post(url,
dict(new_state=draft.get_state("draft-stream-%s" % draft.stream_id).pk,
comment="some comment",
weeks="10",
tags=["need-aut", "sheph-u"],
))
self.assertEqual(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEqual(draft.tags.count(), 2)
self.assertEqual(draft.tags.filter(slug="w-expert").count(), 0)
self.assertEqual(draft.tags.filter(slug="need-aut").count(), 1)
self.assertEqual(draft.tags.filter(slug="sheph-u").count(), 1)
self.assertEqual(draft.docevent_set.count() - events_before, 2)
self.assertEqual(len(outbox), mailbox_before + 1)
self.assertTrue("tags changed" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))
self.assertTrue("plain@example.com" in unicode(outbox[-1]))
def test_set_state(self):
draft = make_test_data()
url = urlreverse('doc_change_stream_state', kwargs=dict(name=draft.name, state_type="draft-stream-ietf"))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
q = PyQuery(r.content)
# make sure the unused states are hidden
unused = draft.group.unused_states.values_list("pk", flat=True)
for t in q("select[name=new_state]").find("option[name=tags]"):
self.assertTrue(t.attrib["value"] not in unused)
self.assertEqual(len(q('select[name=new_state]')), 1)
# set new state
old_state = draft.get_state("draft-stream-%s" % draft.stream_id )
new_state = State.objects.get(used=True, type="draft-stream-%s" % draft.stream_id, slug="parked")
self.assertNotEqual(old_state, new_state)
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
r = self.client.post(url,
dict(new_state=new_state.pk,
comment="some comment",
weeks="10",
tags=[t.pk for t in draft.tags.filter(slug__in=get_tags_for_stream_id(draft.stream_id))],
))
self.assertEqual(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEqual(draft.get_state("draft-stream-%s" % draft.stream_id), new_state)
self.assertEqual(draft.docevent_set.count() - events_before, 2)
reminder = DocReminder.objects.filter(event__doc=draft, type="stream-s")
self.assertEqual(len(reminder), 1)
due = datetime.datetime.now() + datetime.timedelta(weeks=10)
self.assertTrue(due - datetime.timedelta(days=1) <= reminder[0].due <= due + datetime.timedelta(days=1))
self.assertEqual(len(outbox), mailbox_before + 1)
self.assertTrue("state changed" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))

10
ietf/doc/tests_status_change.py
View file

@ -22,10 +22,7 @@ from ietf.group.models import Person
from ietf.iesg.models import TelechatDate
class StatusChangeTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class StatusChangeTests(TestCase):
def test_start_review(self):
url = urlreverse('start_rfc_status_change',kwargs=dict(name=""))
@ -353,10 +350,7 @@ class StatusChangeTestCase(TestCase):
make_test_data()
class StatusChangeSubmitTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class StatusChangeSubmitTests(TestCase):
def test_initial_submission(self):
doc = Document.objects.get(name='status-change-imaginary-mid-review')
url = urlreverse('status_change_submit',kwargs=dict(name=doc.name))

3
ietf/doc/urls.py
View file

@ -66,7 +66,6 @@ urlpatterns += patterns('',
url(r'^(?P<name>[A-Za-z0-9._+-]+)/ballot/$', views_doc.document_ballot, name="doc_ballot"),
(r'^(?P<name>[A-Za-z0-9._+-]+)/doc.json$', views_doc.document_json),
(r'^(?P<name>[A-Za-z0-9._+-]+)/ballotpopup/(?P<ballot_id>[0-9]+)/$', views_doc.ballot_popup),
#(r'^(?P<name>[A-Za-z0-9._+-]+)/ballot.json$', views_doc.ballot_json), # legacy view
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/state/$', views_draft.change_state, name='doc_change_state'), # IESG state
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/state/(?P<state_type>iana-action|iana-review)/$', views_draft.change_iana_state, name='doc_change_iana_state'),
@ -88,6 +87,8 @@ urlpatterns += patterns('',
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/shepherd/$', views_draft.edit_shepherd, name='doc_edit_shepherd'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/shepherdwriteup/$', views_draft.edit_shepherd_writeup, name='doc_edit_shepherd_writeup'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/requestpublication/$', views_draft.request_publication, name='doc_request_publication'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/adopt/$', views_draft.adopt_draft, name='doc_adopt_draft'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/state/(?P<state_type>draft-stream-[a-z]+)/$', views_draft.change_stream_state, name='doc_change_stream_state'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/clearballot/$', views_ballot.clear_ballot, name='doc_clear_ballot'),
url(r'^(?P<name>[A-Za-z0-9._+-]+)/edit/deferballot/$', views_ballot.defer_ballot, name='doc_defer_ballot'),

41
ietf/doc/utils.py
View file

@ -5,6 +5,8 @@ from django.conf import settings
from ietf.utils import markup_txt
from ietf.doc.models import *
from ietf.group.models import Role
from ietf.ietfauth.utils import has_role
from ietf.utils import draft
@ -39,6 +41,20 @@ def get_tags_for_stream_id(stream_id):
else:
return []
def can_adopt_draft(user, doc):
if not user.is_authenticated():
return False
if has_role(user, "Secretariat"):
return True
return (doc.stream_id in (None, "ietf", "irtf")
and doc.group.type_id == "individ"
and Role.objects.filter(name__in=("chair", "delegate", "secr"),
group__type__in=("wg", "rg"),
group__state="active",
person__user=user).exists())
def needed_ballot_positions(doc, active_positions):
'''Returns text answering the question "what does this document
need to pass?". The return value is only useful if the document
@ -227,7 +243,30 @@ def add_state_change_event(doc, by, prev_state, new_state, timestamp=None):
e.time = timestamp
e.save()
return e
def update_reminder(doc, reminder_type_slug, event, due_date):
reminder_type = DocReminderTypeName.objects.get(slug=reminder_type_slug)
try:
reminder = DocReminder.objects.get(event__doc=doc, type=reminder_type, active=True)
except DocReminder.DoesNotExist:
reminder = None
if due_date:
# activate/update reminder
if not reminder:
reminder = DocReminder(type=reminder_type)
reminder.event = event
reminder.due = due_date
reminder.active = True
reminder.save()
else:
# deactivate reminder
if reminder:
reminder.active = False
reminder.save()
def prettify_std_name(n):
if re.match(r"(rfc|bcp|fyi|std)[0-9]+", n):
return n[:3].upper() + " " + n[3:]

2
ietf/doc/views_ballot.py
View file

@ -693,7 +693,7 @@ def approve_ballot(request, name):
e = DocEvent(doc=doc, by=login)
if action == "do_not_publish":
e.type = "iesg_disapproved"
e.desc = "Do Not Publish note has been sent to RFC Editor"
e.desc = "Do Not Publish note has been sent to the RFC Editor"
else:
e.type = "iesg_approved"
e.desc = "IESG has approved the document"

58
ietf/doc/views_doc.py
View file

@ -61,12 +61,10 @@ def render_document_top(request, doc, tab, name):
ballot = doc.latest_event(BallotDocEvent, type="created_ballot")
if doc.type_id in ("draft","conflrev", "statchg"):
# if doc.in_ietf_process and doc.ietf_process.has_iesg_ballot:
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":
tabs.append(("IESG Review", "ballot", urlreverse("doc_ballot", kwargs=dict(name=name)), ballot, None if ballot else "IEST Review Ballot has not been created yet"))
# FIXME: if doc.in_ietf_process and doc.ietf_process.has_iesg_ballot:
if doc.type_id not in ["conflrev", "statchg"]:
tabs.append(("IESG Writeups", "writeup", urlreverse("doc_writeup", kwargs=dict(name=name)), True))
@ -254,9 +252,11 @@ def document_main(request, name, rev=None):
resurrected_by = e.by
# stream info
stream_state_type_slug = None
stream_state = None
if doc.stream:
stream_state = doc.get_state("draft-stream-%s" % doc.stream_id)
stream_state_type_slug = "draft-stream-%s" % doc.stream_id
stream_state = doc.get_state(stream_state_type_slug)
stream_tags = doc.tags.filter(slug__in=get_tags_for_stream_id(doc.stream_id))
shepherd_writeup = doc.latest_event(WriteupDocEvent, type="changed_protocol_writeup")
@ -286,13 +286,8 @@ def document_main(request, name, rev=None):
# remaining actions
actions = []
if ((not doc.stream_id or doc.stream_id in ("ietf", "irtf")) and group.type_id == "individ" and
(request.user.is_authenticated() and
Role.objects.filter(person__user=request.user, name__in=("chair", "secr", "delegate"),
group__type__in=("wg","rg"),
group__state="active")
or has_role(request.user, "Secretariat"))):
actions.append(("Adopt in Group", urlreverse('edit_adopt', kwargs=dict(name=doc.name))))
if can_adopt_draft(request.user, doc):
actions.append(("Adopt in Group", urlreverse('doc_adopt_draft', kwargs=dict(name=doc.name))))
if doc.get_state_slug() == "expired" and not resurrected_by and can_edit:
actions.append(("Request Resurrect", urlreverse('doc_request_resurrect', kwargs=dict(name=doc.name))))
@ -366,6 +361,7 @@ def document_main(request, name, rev=None):
has_errata=doc.tags.filter(slug="errata"),
published=doc.latest_event(type="published_rfc"),
file_urls=file_urls,
stream_state_type_slug=stream_state_type_slug,
stream_state=stream_state,
stream_tags=stream_tags,
milestones=doc.groupmilestone_set.filter(state="active"),
@ -742,48 +738,6 @@ def document_json(request, name):
return HttpResponse(json.dumps(data, indent=2), mimetype='text/plain')
def ballot_json(request, name):
# REDESIGN: this view needs to be deleted or updated
def get_ballot(name):
from ietf.doc.models import DocAlias
alias = get_object_or_404(DocAlias, name=name)
d = alias.document
from ietf.idtracker.models import InternetDraft, BallotInfo
from ietf.idrfc.idrfc_wrapper import BallotWrapper, IdWrapper, RfcWrapper
id = None
bw = None
dw = None
if (d.type_id=='draft'):
id = get_object_or_404(InternetDraft, name=d.name)
try:
if not id.ballot.ballot_issued:
raise Http404
except BallotInfo.DoesNotExist:
raise Http404
bw = BallotWrapper(id) # XXX Fixme: Eliminate this as we go forward
# Python caches ~100 regex'es -- explicitly compiling it inside a method
# (where you then throw away the compiled version!) doesn't make sense at
# all.
if re.search("^rfc([1-9][0-9]*)$", name):
id.viewing_as_rfc = True
dw = RfcWrapper(id)
else:
dw = IdWrapper(id)
# XXX Fixme: Eliminate 'dw' as we go forward
try:
b = d.latest_event(BallotDocEvent, type="created_ballot")
except BallotDocEvent.DoesNotExist:
raise Http404
return (bw, dw, b, d)
ballot, doc, b, d = get_ballot(name)
response = HttpResponse(mimetype='text/plain')
response.write(json.dumps(ballot.dict(), indent=2))
return response
class AddCommentForm(forms.Form):
comment = forms.CharField(required=True, widget=forms.Textarea)

232
ietf/doc/views_draft.py
View file

@ -15,6 +15,7 @@ from django.db.models import Max
from django.conf import settings
from django.forms.util import ErrorList
from django.contrib.auth.decorators import login_required
from django.template.defaultfilters import pluralize
from ietf.utils.mail import send_mail_text, send_mail_message
from ietf.ietfauth.decorators import role_required
@ -27,11 +28,6 @@ from ietf.person.forms import EmailsField
from ietf.group.models import Group
from ietf.secr.lib import jsonapi
from ietf.ietfworkflows.models import Stream
from ietf.ietfworkflows.utils import update_stream
from ietf.ietfworkflows.streams import get_stream_from_draft
from ietf.ietfworkflows.accounts import can_edit_state
from ietf.doc.models import *
from ietf.doc.utils import *
from ietf.name.models import IntendedStdLevelName, DocTagName, StreamName
@ -402,7 +398,7 @@ def replaces(request, name):
return HttpResponseRedirect(doc.get_absolute_url())
else:
form = ReplacesForm(doc=doc)
return render_to_response('idrfc/change_replaces.html',
return render_to_response('doc/draft/change_replaces.html',
dict(form=form,
doc=doc,
),
@ -1180,7 +1176,7 @@ def request_publication(request, name):
doc = get_object_or_404(Document, type="draft", name=name, stream__in=("iab", "ise", "irtf"))
if not can_edit_state(request.user, doc):
if not is_authorized_in_doc_stream(request.user, doc):
return HttpResponseForbidden("You do not have the necessary permissions to view this page")
m = Message()
@ -1255,3 +1251,225 @@ def request_publication(request, name):
),
context_instance = RequestContext(request))
class AdoptDraftForm(forms.Form):
group = forms.ModelChoiceField(queryset=Group.objects.filter(type__in=["wg", "rg"], state="active").order_by("-type", "acronym"), required=True, empty_label=None)
comment = forms.CharField(widget=forms.Textarea, required=False, label="Comment", help_text="Optional comment explaining the reasons for the adoption")
weeks = forms.IntegerField(required=False, label="Expected weeks in adoption state")
def __init__(self, *args, **kwargs):
user = kwargs.pop("user")
super(AdoptDraftForm, self).__init__(*args, **kwargs)
if has_role(user, "Secretariat"):
pass # all groups
else:
self.fields["group"].queryset = self.fields["group"].queryset.filter(role__person__user=user, role__name__in=("chair", "delegate", "secr")).distinct()
self.fields['group'].choices = [(g.pk, '%s - %s' % (g.acronym, g.name)) for g in self.fields["group"].queryset]
@login_required
def adopt_draft(request, name):
doc = get_object_or_404(Document, type="draft", name=name)
if not can_adopt_draft(request.user, doc):
return HttpResponseForbidden("You don't have permission to access this page")
if request.method == 'POST':
form = AdoptDraftForm(request.POST, user=request.user)
if form.is_valid():
# adopt
by = request.user.get_profile()
save_document_in_history(doc)
doc.time = datetime.datetime.now()
group = form.cleaned_data["group"]
if group.type.slug == "rg":
new_stream = StreamName.objects.get(slug="irtf")
adopt_state_slug = "active"
else:
new_stream = StreamName.objects.get(slug="ietf")
adopt_state_slug = "c-adopt"
# stream
if doc.stream != new_stream:
e = DocEvent(type="changed_stream", time=doc.time, by=by, doc=doc)
e.desc = u"Changed stream to <b>%s</b>" % new_stream.name
if doc.stream:
e.desc += u" from %s" % doc.stream.name
e.save()
doc.stream = new_stream
# group
if group != doc.group:
e = DocEvent(type="changed_group", time=doc.time, by=by, doc=doc)
e.desc = u"Changed group to <b>%s (%s)</b>" % (group.name, group.acronym.upper())
if doc.group.type_id != "individ":
e.desc += " from %s (%s)" % (doc.group.name, doc.group.acronym.upper())
e.save()
doc.group = group
doc.save()
# state
prev_state = doc.get_state("draft-stream-%s" % doc.stream_id)
new_state = State.objects.get(slug=adopt_state_slug, type="draft-stream-%s" % doc.stream_id, used=True)
if new_state != prev_state:
doc.set_state(new_state)
e = add_state_change_event(doc, by, prev_state, new_state, doc.time)
due_date = None
if form.cleaned_data["weeks"] != None:
due_date = datetime.date.today() + datetime.timedelta(weeks=form.cleaned_data["weeks"])
update_reminder(doc, "stream-s", e, due_date)
# comment
comment = form.cleaned_data["comment"].strip()
if comment:
e = DocEvent(type="added_comment", time=doc.time, by=by, doc=doc)
e.desc = comment
e.save()
email_draft_adopted(request, doc, by, comment)
return HttpResponseRedirect(doc.get_absolute_url())
else:
form = AdoptDraftForm(user=request.user)
return render_to_response('doc/draft/adopt_draft.html',
{'doc': doc,
'form': form,
},
context_instance=RequestContext(request))
class ChangeStreamStateForm(forms.Form):
new_state = forms.ModelChoiceField(queryset=State.objects.filter(used=True), label='State', help_text=u"Only select 'Submitted to IESG for Publication' to correct errors. Use the document's main page to request publication.")
weeks = forms.IntegerField(label='Expected weeks in state',required=False)
comment = forms.CharField(widget=forms.Textarea, required=False, help_text="Optional comment for the document history")
tags = forms.ModelMultipleChoiceField(queryset=DocTagName.objects.filter(used=True), widget=forms.CheckboxSelectMultiple, required=False)
def __init__(self, *args, **kwargs):
doc = kwargs.pop("doc")
state_type = kwargs.pop("state_type")
super(ChangeStreamStateForm, self).__init__(*args, **kwargs)
f = self.fields["new_state"]
f.queryset = f.queryset.filter(type=state_type)
if doc.group:
unused_states = doc.group.unused_states.values_list("pk", flat=True)
f.queryset = f.queryset.exclude(pk__in=unused_states)
f.label = state_type.label
f = self.fields['tags']
f.queryset = f.queryset.filter(slug__in=get_tags_for_stream_id(doc.stream_id))
if doc.group:
unused_tags = doc.group.unused_tags.values_list("pk", flat=True)
f.queryset = f.queryset.exclude(pk__in=unused_tags)
def next_states_for_stream_state(doc, state_type, current_state):
# find next states
next_states = []
if current_state:
next_states = current_state.next_states.all()
if doc.stream_id == "ietf" and doc.group:
transitions = doc.group.groupstatetransitions_set.filter(state=current_state)
if transitions:
next_states = transitions[0].next_states.all()
else:
# return the initial state
states = State.objects.filter(used=True, type=state_type).order_by('order')
if states:
next_states = states[:1]
if doc.group:
unused_states = doc.group.unused_states.values_list("pk", flat=True)
next_states = [n for n in next_states if n.pk not in unused_states]
return next_states
@login_required
def change_stream_state(request, name, state_type):
doc = get_object_or_404(Document, type="draft", name=name)
if not doc.stream:
raise Http404
state_type = get_object_or_404(StateType, slug=state_type)
if not is_authorized_in_doc_stream(request.user, doc):
return HttpResponseForbidden("You don't have permission to access this page")
prev_state = doc.get_state(state_type.slug)
next_states = next_states_for_stream_state(doc, state_type, prev_state)
if request.method == 'POST':
form = ChangeStreamStateForm(request.POST, doc=doc, state_type=state_type)
if form.is_valid():
by = request.user.get_profile()
save_document_in_history(doc)
doc.time = datetime.datetime.now()
comment = form.cleaned_data["comment"].strip()
# state
new_state = form.cleaned_data["new_state"]
if new_state != prev_state:
doc.set_state(new_state)
e = add_state_change_event(doc, by, prev_state, new_state, doc.time)
due_date = None
if form.cleaned_data["weeks"] != None:
due_date = datetime.date.today() + datetime.timedelta(weeks=form.cleaned_data["weeks"])
update_reminder(doc, "stream-s", e, due_date)
email_stream_state_changed(request, doc, prev_state, new_state, by, comment)
# tags
existing_tags = set(doc.tags.all())
new_tags = set(form.cleaned_data["tags"])
if existing_tags != new_tags:
doc.tags = new_tags
e = DocEvent(type="changed_document", time=doc.time, by=by, doc=doc)
added_tags = new_tags - existing_tags
removed_tags = existing_tags - new_tags
l = []
if added_tags:
l.append(u"Tag%s %s set." % (pluralize(added_tags), ", ".join(t.name for t in added_tags)))
if removed_tags:
l.append(u"Tag%s %s cleared." % (pluralize(removed_tags), ", ".join(t.name for t in removed_tags)))
e.desc = " ".join(l)
e.save()
email_stream_tags_changed(request, doc, added_tags, removed_tags, by, comment)
# comment
if comment:
e = DocEvent(type="added_comment", time=doc.time, by=by, doc=doc)
e.desc = comment
e.save()
return HttpResponseRedirect(doc.get_absolute_url())
else:
form = ChangeStreamStateForm(initial=dict(new_state=prev_state.pk if prev_state else None),
doc=doc, state_type=state_type)
milestones = doc.groupmilestone_set.all()
return render_to_response("doc/draft/change_stream_state.html",
{"doc": doc,
"form": form,
"milestones": milestones,
"state_type": state_type,
"next_states": next_states,
},
context_instance=RequestContext(request))

8
ietf/doc/views_help.py
View file

@ -3,12 +3,14 @@ from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext
from ietf.doc.models import *
from ietf.doc.utils import get_tags_for_stream_id
def state_help(request, type):
slug, title = {
"draft-iesg": ("draft-iesg", "IESG States For Internet-Drafts"),
"draft-rfceditor": ("draft-rfceditor", "RFC Editor States For Internet-Drafts"),
"draft-iana-action": ("draft-iana-action", "IANA Action States For Internet-Drafts"),
"draft-stream-ietf": ("draft-stream-ietf", "IETF Stream States For Internet-Drafts"),
"charter": ("charter", "Charter States"),
"conflict-review": ("conflrev", "Conflict Review States"),
"status-change": ("statchg", "RFC Status Change States"),
@ -35,6 +37,9 @@ def state_help(request, type):
states.insert(0, fake_state)
tags = DocTagName.objects.filter(slug__in=IESG_SUBSTATE_TAGS)
elif state_type.slug.startswith("draft-stream-"):
possible = get_tags_for_stream_id(state_type.slug.replace("draft-stream-", ""))
tags = DocTagName.objects.filter(slug__in=possible)
return render_to_response("doc/state_help.html", {
"title": title,
@ -42,5 +47,4 @@ def state_help(request, type):
"states": states,
"has_next_states": has_next_states,
"tags": tags,
},
context_instance=RequestContext(request))
}, context_instance=RequestContext(request))

19
ietf/group/models.py
View file

@ -58,26 +58,15 @@ class Group(GroupInfo):
e = model.objects.filter(group=self).filter(**filter_args).order_by('-time', '-id')[:1]
return e[0] if e else None
def is_chair(self, user):
chair = self.get_chair()
if chair:
return self.get_chair().person.user == user
else:
return False
def is_member(self, user):
members = self.get_members()
users = [member.person.user for member in members]
return user in users
def has_role(self, user, role_names):
if isinstance(role_names, str) or isinstance(role_names, unicode):
role_names = [role_names]
return user.is_authenticated() and self.role_set.filter(name__in=role_names, person__user=user).exists()
def get_chair(self):
chair = self.role_set.filter(name__slug='chair')[:1]
return chair and chair[0] or None
def get_members(self):
members = self.role_set.filter(name__slug__in=["chair", "member", "advisor", "liaison"])
return members
# these are copied to Group because it is still proxied.
@property
def upcase_acronym(self):

16
ietf/group/proxy.py
View file

@ -94,6 +94,19 @@ def proxied_role_emails(emails):
proxy_role_email(e)
return emails
class WGDelegateProxy(Role):
#person = models.ForeignKey(PersonOrOrgInfo) # same name
#wg = models.ForeignKey(IETFWG)
@property
def wg(self):
return self.group
def __unicode__(self):
return u"%s" % self.person
class Meta:
proxy = True
class IETFWG(Group):
objects = TranslatingManager(dict(group_acronym="id",
group_acronym__acronym="acronym",
@ -211,8 +224,7 @@ class IETFWG(Group):
return d
@property
def wgdelegate_set(self):
from ietf.wgchairs.models import WGDelegate
return WGDelegate.objects.filter(group=self, name="delegate")
return WGDelegateProxy.objects.filter(group=self, name="delegate")
class Meta:
proxy = True

11
ietf/group/stream_urls.py
View file

@ -2,13 +2,10 @@
from django.conf.urls.defaults import patterns, include
import views
import views_stream
urlpatterns = patterns('',
(r'^$', views.streams),
(r'^(?P<acronym>[a-zA-Z0-9-]+)/$', views.stream_documents, None),
# (r'^(?P<acronym>[a-zA-Z0-9-]+)/history/$', views.stream_history),
# (r'^(?P<acronym>[a-zA-Z0-9-]+)/edit/$', views.stream_edit)
(r'^management/', include('ietf.ietfworkflows.urls')),
(r'^$', views_stream.streams),
(r'^(?P<acronym>[a-zA-Z0-9-]+)/$', views_stream.stream_documents, None),
(r'^(?P<acronym>[a-zA-Z0-9-]+)/edit/$', views_stream.stream_edit),
)

31
ietf/group/tests.py Normal file
View file

@ -0,0 +1,31 @@
import os, shutil, datetime
import django.test
from django.core.urlresolvers import reverse as urlreverse
from pyquery import PyQuery
from ietf.utils.mail import outbox
from ietf.utils.test_utils import login_testing_unauthorized
from ietf.utils.test_data import make_test_data
from ietf.name.models import *
from ietf.group.models import *
from ietf.person.models import *
class StreamTests(TestCase):
def test_stream_edit(self):
make_test_data()
stream_acronym = "ietf"
url = urlreverse("ietf.group.views_stream.stream_edit", kwargs=dict(acronym=stream_acronym))
login_testing_unauthorized(self, "secretary", url)
# get
r = self.client.get(url)
self.assertEqual(r.status_code, 200)
r = self.client.post(url, dict(delegates="ad2@ietf.org"))
self.assertEqual(r.status_code, 302)
self.assertTrue(Role.objects.filter(name="delegate", group__acronym=stream_acronym, email__address="ad2@ietf.org"))

29
ietf/group/views.py
View file

@ -1,29 +0,0 @@
# Copyright The IETF Trust 2008, All Rights Reserved
from django.shortcuts import render_to_response
from django.template import RequestContext, loader
from django.http import Http404, HttpResponse
from ietf.group.models import Group
from ietf.doc.models import Document
from ietf.doc.views_search import SearchForm, retrieve_search_results
from ietf.name.models import StreamName
import debug
def streams(request):
streams = [ s.slug for s in StreamName.objects.all().exclude(slug__in=['ietf', 'legacy']) ]
streams = Group.objects.filter(acronym__in=streams)
return render_to_response('group/index.html', {'streams':streams}, context_instance=RequestContext(request))
def stream_documents(request, acronym):
streams = [ s.slug for s in StreamName.objects.all().exclude(slug__in=['ietf', 'legacy']) ]
if not acronym in streams:
raise Http404("No such stream: %s" % acronym)
stream = StreamName.objects.get(slug=acronym)
form = SearchForm({'by':'stream', 'stream':acronym,
'rfcs':'on', 'activedrafts':'on'})
docs, meta = retrieve_search_results(form)
return render_to_response('group/stream_documents.html', {'stream':stream, 'docs':docs, 'meta':meta }, context_instance=RequestContext(request))

75
ietf/group/views_stream.py Normal file
View file

@ -0,0 +1,75 @@
# Copyright The IETF Trust 2008, All Rights Reserved
from django.shortcuts import render_to_response, get_object_or_404, redirect
from django.template import RequestContext, loader
from django.http import Http404, HttpResponse, HttpResponseForbidden
from django import forms
from ietf.group.models import *
from ietf.group.utils import *
from ietf.doc.models import Document
from ietf.doc.views_search import SearchForm, retrieve_search_results
from ietf.name.models import StreamName
from ietf.ietfauth.utils import has_role
from ietf.person.forms import EmailsField
import debug
def streams(request):
streams = [ s.slug for s in StreamName.objects.all().exclude(slug__in=['ietf', 'legacy']) ]
streams = Group.objects.filter(acronym__in=streams)
return render_to_response('group/index.html', {'streams':streams}, context_instance=RequestContext(request))
def stream_documents(request, acronym):
streams = [ s.slug for s in StreamName.objects.all().exclude(slug__in=['ietf', 'legacy']) ]
if not acronym in streams:
raise Http404("No such stream: %s" % acronym)
stream = StreamName.objects.get(slug=acronym)
form = SearchForm({'by':'stream', 'stream':acronym,
'rfcs':'on', 'activedrafts':'on'})
docs, meta = retrieve_search_results(form)
return render_to_response('group/stream_documents.html', {'stream':stream, 'docs':docs, 'meta':meta }, context_instance=RequestContext(request))
class StreamEditForm(forms.Form):
delegates = EmailsField(label="Delegates", required=False, help_text=u"Type in name to search for person")
def stream_edit(request, acronym):
group = get_object_or_404(Group, acronym=acronym)
if not (has_role(request.user, "Secretariat") or group.has_role(request.user, "chair")):
return HttpResponseForbidden("You don't have permission to access this page.")
chairs = Email.objects.filter(role__group=group, role__name="chair").select_related("person")
if request.method == 'POST':
form = StreamEditForm(request.POST)
if form.is_valid():
save_group_in_history(group)
# update roles
attr, slug, title = ('delegates', 'delegate', "Delegates")
new = form.cleaned_data[attr]
old = Email.objects.filter(role__group=group, role__name=slug).select_related("person")
if set(new) != set(old):
desc = "%s changed to <b>%s</b> from %s" % (
title, ", ".join(x.get_name() for x in new), ", ".join(x.get_name() for x in old))
GroupEvent.objects.create(group=group, by=request.user.get_profile(), type="info_changed", desc=desc)
group.role_set.filter(name=slug).delete()
for e in new:
Role.objects.get_or_create(name_id=slug, email=e, group=group, person=e.person)
return redirect("ietf.group.views.streams")
else:
form = StreamEditForm(initial=dict(delegates=Email.objects.filter(role__group=group, role__name="delegate")))
return render_to_response('group/stream_edit.html',
{'group': group,
'chairs': chairs,
'form': form,
},
context_instance=RequestContext(request))

5
ietf/idindex/tests.py
View file

@ -9,10 +9,7 @@ from ietf.doc.models import *
from ietf.idindex.index import *
class IndexTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class IndexTests(TestCase):
def setUp(self):
self.id_dir = os.path.abspath("tmp-id-dir")
os.mkdir(self.id_dir)

1
ietf/idrfc/.gitignore vendored
View file

@ -1 +0,0 @@
/*.pyc

1
ietf/idrfc/__init__.py
View file

@ -1 +0,0 @@
#

967
ietf/idrfc/idrfc_wrapper.py
View file

@ -1,967 +0,0 @@
# Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved. Contact: Pasi Eronen <pasi.eronen@nokia.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
#
# * Neither the name of the Nokia Corporation and/or its
# subsidiary(-ies) nor the names of its contributors may be used
# to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from ietf.idtracker.models import InternetDraft, IDInternal, BallotInfo, IESGDiscuss, IESGLogin, DocumentComment, Acronym, IDState
from ietf.idrfc.models import RfcEditorQueue
from ietf.ipr.models import IprRfc, IprDraft, IprDetail
from ietf.doc.models import BallotDocEvent
import re
from datetime import date
from django.utils import simplejson as json
from django.db.models import Q
from django.db import models
from django.core.urlresolvers import reverse
from django.conf import settings
import types
import debug
BALLOT_ACTIVE_STATES = ['In Last Call',
'Waiting for Writeup',
'Waiting for AD Go-Ahead',
'IESG Evaluation',
'IESG Evaluation - Defer']
def jsonify_helper(obj, keys):
result = {}
for k in keys:
if hasattr(obj, k):
v = getattr(obj, k)
if callable(v):
v = v()
if v == None:
pass
elif isinstance(v, (types.StringType, types.IntType, types.BooleanType, types.LongType, types.ListType, types.UnicodeType)):
result[k] = v
elif isinstance(v, date):
result[k] = str(v)
else:
result[k] = 'Unknown type '+str(type(v))
return result
# Wrappers to make writing templates less painful
# ---------------------------------------------------------------------------
class IdWrapper:
_draft = None
_idinternal = None
is_id_wrapper = True
is_rfc_wrapper = False
draft_name = None
# Active/Expired/RFC/Withdrawn by Submitter/Replaced/Withdrawn by IETF
draft_status = None
# Revision is sometimes incorrect (+1 too large) if status != Active
latest_revision = None
# Set if and only if draft_status is "RFC"
rfc_number = None
title = None
tracker_id = None
publication_date = None
ietf_process = None
def __init__(self, draft):
self.id = self
if isinstance(draft, IDInternal) and not settings.USE_DB_REDESIGN_PROXY_CLASSES:
self._idinternal = draft
self._draft = self._idinternal.draft
else:
self._draft = draft
if draft.idinternal:
self._idinternal = draft.idinternal
if self._idinternal:
self.ietf_process = IetfProcessData(self._idinternal)
self.draft_name = self._draft.filename
self.draft_status = str(self._draft.status)
if self.draft_status == "RFC":
if self._draft.rfc_number:
self.rfc_number = self._draft.rfc_number
else:
# Handle incorrect database entries
self.draft_status = "Expired"
self.latest_revision = self._draft.revision_display()
self.title = self._draft.title
self.tracker_id = self._draft.id_document_tag
self.resurrect_requested_by = self._idinternal.resurrect_requested_by if self._idinternal else None
self.publication_date = self._draft.revision_date
if not self.publication_date:
# should never happen -- but unfortunately it does. Return an
# obviously bogus date
self.publication_date = date(1990,1,1)
def rfc_editor_state(self):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
s = self._draft.get_state("draft-rfceditor")
if s:
# extract possible extra annotations
tags = self._draft.tags.filter(slug__in=("iana", "ref"))
return "*".join([s.name] + [t.slug.upper() for t in tags])
else:
return None
try:
qs = self._draft.rfc_editor_queue_state
return qs.state
except RfcEditorQueue.DoesNotExist:
pass
return None
def replaced_by(self):
try:
if self._draft.replaced_by:
return [self._draft.replaced_by.filename]
except InternetDraft.DoesNotExist:
pass
return None
def replaces(self):
r = [str(r.filename) for r in self._draft.replaces_set.all()]
if len(r) > 0:
return r
else:
return None
def in_ietf_process(self):
return self.ietf_process != None
def submission(self):
if self._draft.stream_id != u'ietf':
return self._draft.stream
if self._draft.group_id == Acronym.INDIVIDUAL_SUBMITTER:
return "Individual"
if self._draft.group and self._draft.group.type_id == "area":
return u"Individual in %s area" % self._draft.group.acronym
a = self.group_acronym()
if a:
if self._draft.stream_id == "ietf" and self._draft.get_state_slug("draft-stream-ietf") == "c-adopt":
return "candidate for <a href='/wg/%s/'>%s WG</a>" % (a, a)
return "<a href='/wg/%s/'>%s WG</a>" % (a, a)
return ""
submission.allow_tags = True
def search_archive(self):
if self._idinternal and self._idinternal.stream in ("IRTF","ISE"):
return "www.ietf.org/mail-archive/web/"
if self._draft.group_id == Acronym.INDIVIDUAL_SUBMITTER or (settings.USE_DB_REDESIGN_PROXY_CLASSES and self._draft.group.type_id == "area"):
return "www.ietf.org/mail-archive/web/"
a = self._draft.group_ml_archive()
if a:
return a
return ""
def file_types(self):
return self._draft.file_type.split(",")
def group_acronym(self):
if self._draft.group_id != 0 and self._draft.group != None and str(self._draft.group) != "none":
if settings.USE_DB_REDESIGN_PROXY_CLASSES and self._draft.group.type_id == "area":
return None
return str(self._draft.group)
else:
return None
# TODO: Returning integers here isn't nice
# 0=Unknown, 1=IETF, 2=IAB, 3=IRTF, 4=Independent
def stream_id(self):
if self.draft_name.startswith("draft-iab-"):
return 2
elif self.draft_name.startswith("draft-irtf-"):
return 3
elif self._idinternal:
if self._idinternal.stream == "ISE":
return 4
else:
return 1
elif self.group_acronym():
return 1
else:
return 0
def draft_name_and_revision(self):
return self.draft_name+"-"+self.latest_revision
def friendly_state(self):
if self.draft_status == "RFC":
return "<a href=\"%s\">RFC %d</a>" % (reverse('doc_view', args=['rfc%d' % self.rfc_number]), self.rfc_number)
elif self.draft_status == "Active":
if self.in_ietf_process():
if self.ietf_process.main_state == "Dead":
# Many drafts in "Dead" state are not dead; they're
# just not currently under IESG processing. Show
# them as "I-D Exists (IESG: Dead)" instead...
return "I-D Exists (IESG: "+self.ietf_process.state+")"
elif self.ietf_process.main_state == "In Last Call":
return self.ietf_process.state + " (ends "+str(self._idinternal.document().lc_expiration_date)+")"
else:
return self.ietf_process.state
else:
return "I-D Exists"
else:
if self.in_ietf_process() and self.ietf_process.main_state == "Dead":
return self.draft_status+" (IESG: "+self.ietf_process.state+")"
# Expired/Withdrawn by Submitter/IETF
return self.draft_status
def abstract(self):
return self._draft.clean_abstract()
# TODO: ugly hack
def authors(self):
return self._draft.authors
def expected_expiration_date(self):
if self.draft_status == "Active" and self._draft.can_expire():
return self._draft.expiration()
else:
return None
def ad_name(self):
if self.in_ietf_process():
return self.ietf_process.ad_name()
else:
return None
def get_absolute_url(self):
return "/doc/"+self.draft_name+"/"
def displayname_with_link(self):
return '<a href="%s">%s</a>' % (self.get_absolute_url(), self.draft_name_and_revision())
def underlying_document(self):
""" Expose the Document object underneath the proxy """
from ietf.doc.models import Document
return Document.objects.get(docalias__name=self.draft_name)
def to_json(self):
result = jsonify_helper(self, ['draft_name', 'draft_status', 'latest_revision', 'rfc_number', 'title', 'tracker_id', 'publication_date','rfc_editor_state', 'replaced_by', 'replaces', 'in_ietf_process', 'file_types', 'group_acronym', 'stream_id','friendly_state', 'abstract', 'ad_name'])
if self.in_ietf_process():
result['ietf_process'] = self.ietf_process.dict()
return json.dumps(result, indent=2)
# ---------------------------------------------------------------------------
class RfcWrapper:
_rfc = None
_rfcindex = None
_idinternal = None
is_id_wrapper = False
is_rfc_wrapper = True
rfc_number = None
title = None
publication_date = None
maturity_level = None
ietf_process = None
draft_name = None
def __init__(self, rfcindex, rfc=None, idinternal=None):
self._rfcindex = rfcindex
self._rfc = rfc
self._idinternal = idinternal
self.rfc = self
if not self._idinternal:
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
pub = rfcindex.rfc_published_date
started = rfcindex.started_iesg_process if hasattr(rfcindex, 'started_iesg_process') else rfcindex.latest_event(type="started_iesg_process")
if pub and started and pub < started.time.date():
self._idinternal = rfcindex
else:
try:
self._idinternal = IDInternal.objects.get(rfc_flag=1, draft=self._rfcindex.rfc_number)
except IDInternal.DoesNotExist:
pass
if self._idinternal:
self.ietf_process = IetfProcessData(self._idinternal)
self.rfc_number = self._rfcindex.rfc_number
self.title = self._rfcindex.title
self.publication_date = self._rfcindex.rfc_published_date
self.maturity_level = self._rfcindex.current_status
if not self.maturity_level:
self.maturity_level = "Unknown"
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if not rfcindex.name.startswith('rfc'):
self.draft_name = rfcindex.name
return # we've already done the lookup while importing so skip the rest
ids = InternetDraft.objects.filter(rfc_number=self.rfc_number)
if len(ids) >= 1:
self.draft_name = ids[0].filename
elif self._rfcindex and self._rfcindex.draft:
# rfcindex occasionally includes drafts that were not
# really submitted to IETF (e.g. April 1st)
ids = InternetDraft.objects.filter(filename=self._rfcindex.draft)
if len(ids) > 0:
self.draft_name = self._rfcindex.draft
def _rfc_doc_list(self, name):
if (not self._rfcindex) or (not getattr(self._rfcindex, name)):
return None
else:
s = getattr(self._rfcindex, name)
s = s.replace(",", ", ")
s = re.sub("([A-Z])([0-9])", "\\1 \\2", s)
return s
def obsoleted_by(self):
return self._rfc_doc_list("obsoleted_by")
def obsoletes(self):
return self._rfc_doc_list("obsoletes")
def updated_by(self):
return self._rfc_doc_list("updated_by")
def updates(self):
return self._rfc_doc_list("updates")
def also(self):
return self._rfc_doc_list("also")
def has_errata(self):
return self._rfcindex and (self._rfcindex.has_errata > 0)
def stream_name(self):
if not self._rfcindex:
return None
else:
x = self._rfcindex.stream
if x == "INDEPENDENT":
return "Independent Submission Stream"
elif x == "LEGACY":
return "Legacy Stream"
else:
return x+" Stream"
def in_ietf_process(self):
return self.ietf_process != None
def file_types(self):
types = self._rfcindex.file_formats
types = types.replace("ascii","txt")
return ["."+x for x in types.split(",")]
def friendly_state(self):
if self.in_ietf_process():
s = self.ietf_process.main_state
if not s in ["RFC Published", "AD is watching", "Dead"]:
return "RFC %d (%s)<br/>%s (to %s)" % (self.rfc_number, self.maturity_level, self.ietf_process.state, self.ietf_process.intended_maturity_level())
return "RFC %d (%s)" % (self.rfc_number, self.maturity_level)
def ad_name(self):
if self.in_ietf_process():
return self.ietf_process.ad_name()
else:
# TODO: get AD name of the draft
return None
def filename(self):
return self._rfcindex.filename
@models.permalink
def get_absolute_url(self):
return ('ietf.doc.views_doc.document_main', ['rfc%s' % (str(self.rfc_number))])
def displayname_with_link(self):
return '<a href="%s">RFC %d</a>' % (self.get_absolute_url(), self.rfc_number)
def to_json(self):
result = jsonify_helper(self, ['rfc_number', 'title', 'publication_date', 'maturity_level', 'obsoleted_by','obsoletes','updated_by','updates','also','has_errata','stream_name','file_types','in_ietf_process', 'friendly_state'])
if self.in_ietf_process():
result['ietf_process'] = self.ietf_process.dict()
return json.dumps(result, indent=2)
def underlying_document(self):
""" Expose the Document object underneath the proxy """
# Things like RFC500 are special - there may not _be_ a docalias for them
from ietf.doc.models import Document
q = Document.objects.filter(docalias__name='rfc%04d'%self.rfc_number)
if q:
return q[0]
else:
return None
# ---------------------------------------------------------------------------
class IetfProcessData:
_idinternal = None
main_state = None
sub_state = None
state = None
_ballot = None
def __init__(self, idinternal):
self._idinternal = idinternal
i = self._idinternal
self.main_state = str(i.cur_state)
if i.cur_sub_state_id > 0:
self.sub_state = str(i.cur_sub_state)
self.state = self.main_state + "::" + self.sub_state
else:
self.sub_state = None
self.state = self.main_state
def has_iesg_ballot(self):
try:
if self._idinternal.ballot.ballot_issued:
return True
except BallotInfo.DoesNotExist:
pass
return False
def has_active_iesg_ballot(self):
if not self.has_iesg_ballot():
return False
if not self.main_state in BALLOT_ACTIVE_STATES:
return False
if (not self._idinternal.rfc_flag) and self._idinternal.draft.status_id != 1:
# Active
return False
return True
# don't call this unless has_[active_]iesg_ballot returns True
def iesg_ballot(self):
if not self._ballot:
self._ballot = BallotWrapper(self._idinternal)
return self._ballot
# don't call this unless has_[active_]iesg_ballot returns True
def iesg_ballot_needed( self ):
standardsTrack = 'Standard' in self.intended_maturity_level() or \
self.intended_maturity_level() in ("BCP", "Best Current Practice")
return self.iesg_ballot().ballot.needed( standardsTrack )
def ad_name(self):
return str(self._idinternal.job_owner)
def iesg_note(self):
if self._idinternal.note:
n = self._idinternal.note
# Hide unnecessary note of form "RFC 1234"
if re.match("^RFC\s*\d+$", n):
return None
return n
else:
return None
def state_date(self):
try:
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return self._idinternal.docevent_set.filter(
Q(desc__istartswith="Draft Added by ")|
Q(desc__istartswith="Draft Added in state ")|
Q(desc__istartswith="Draft added in state ")|
Q(desc__istartswith="State changed to ")|
Q(desc__istartswith="State Changes to ")|
Q(desc__istartswith="Sub state has been changed to ")|
Q(desc__istartswith="State has been changed to ")|
Q(desc__istartswith="IESG has approved and state has been changed to")|
Q(desc__istartswith="IESG process started in state")).order_by('-time')[0].time.date()
return self._idinternal.comments().filter(
Q(comment_text__istartswith="Draft Added by ")|
Q(comment_text__istartswith="Draft Added in state ")|
Q(comment_text__istartswith="Draft added in state ")|
Q(comment_text__istartswith="State changed to ")|
Q(comment_text__istartswith="State Changes to ")|
Q(comment_text__istartswith="Sub state has been changed to ")|
Q(comment_text__istartswith="State has been changed to ")|
Q(comment_text__istartswith="IESG has approved and state has been changed to")).order_by('-id')[0].date
except IndexError:
# should never happen -- return an obviously bogus date
return date(1990,1,1)
def dict(self):
result = {'main_state':self.main_state,
'sub_state':self.sub_state,
'state':self.state,
'state_date':str(self.state_date()),
'has_iesg_ballot':self.has_iesg_ballot(),
'has_active_iesg_ballot':self.has_active_iesg_ballot(),
'ad_name':self.ad_name(),
'intended_maturity_level':self.intended_maturity_level(),
'telechat_date':self.telechat_date()}
if result['telechat_date']:
result['telechat_date'] = str(result['telechat_date'])
result['telechat_returning_item'] = self.telechat_returning_item()
if self.iesg_note():
result['iesg_note'] = self.iesg_note()
if self.has_iesg_ballot():
result['iesg_ballot'] = self.iesg_ballot().dict()
return result
def intended_maturity_level(self):
if self._idinternal.rfc_flag:
s = str(self._idinternal.document().intended_status)
# rfc_intend_status table uses different names, argh!
if s == "Proposed":
s = "Proposed Standard"
elif s == "Draft":
s = "Draft Standard"
elif s == "None":
s = None
else:
s = str(self._idinternal.draft.intended_status)
if s == "None":
s = None
elif s == "Request":
s = None
return s
def telechat_date(self):
# return date only if it's on upcoming agenda
if self._idinternal.agenda:
return self._idinternal.telechat_date
else:
return None
def telechat_returning_item(self):
# should be called only if telechat_date() returns non-None
return bool(self._idinternal.returning_item)
def state_change_notice_to(self):
return self._idinternal.state_change_notice_to
# comment_log?
# ---------------------------------------------------------------------------
class IdRfcWrapper:
rfc = None
id = None
iprCount = None
iprUrl = None
def __init__(self, id, rfc):
self.id = id
self.rfc = rfc
if id:
iprs = IprDraft.objects.filter(document=self.id.tracker_id, ipr__status__in=[1,3])
self.iprUrl = "/ipr/search?option=document_search&id_document_tag=" + str(self.id.tracker_id)
elif rfc:
iprs = IprRfc.objects.filter(document=self.rfc.rfc_number, ipr__status__in=[1,3])
self.iprUrl = "/ipr/search?option=rfc_search&rfc_search=" + str(self.rfc.rfc_number)
else:
raise ValueError("Construction with null id and rfc")
# iprs is a list of docs which contain IPR
self.iprCount = len(iprs)
def title(self):
if self.rfc:
return self.rfc.title
else:
return self.id.title
def friendly_state(self):
if self.rfc:
return self.rfc.friendly_state()
else:
return self.id.friendly_state()
def get_absolute_url(self):
if self.rfc:
return self.rfc.get_absolute_url()
else:
return self.id.get_absolute_url()
def comment_count(self):
if self.rfc:
return DocumentComment.objects.filter(document=self.rfc.rfc_number,rfc_flag=1).count()
else:
return DocumentComment.objects.filter(document=self.id.tracker_id).exclude(rfc_flag=1).count()
def ad_name(self):
if self.rfc:
s = self.rfc.ad_name()
if s:
return s
if self.id:
return self.id.ad_name()
return None
def publication_date(self):
if self.rfc:
return self.rfc.publication_date
else:
return self.id.publication_date
def telechat_date(self):
if self.rfc and self.rfc.in_ietf_process():
return self.rfc.ietf_process.telechat_date()
elif self.id and self.id.in_ietf_process():
return self.id.ietf_process.telechat_date()
else:
return None
def view_sort_group(self):
if self.rfc:
return 'RFC'
elif self.id.draft_status == "Active":
return 'Active Internet-Draft'
else:
return 'Old Internet-Draft'
def view_sort_group_byad(self):
if self.rfc:
return 'RFC'
elif self.id.draft_status == "Active":
if self.id.in_ietf_process():
if self.id.ietf_process._idinternal.cur_state_id == IDState.DEAD:
return 'IESG Dead Internet-Draft'
else:
return "%s Internet-Draft" % self.id.ietf_process._idinternal.cur_state
else:
return 'Active Internet-Draft'
else:
return 'Old Internet-Draft'
def view_sort_key(self, sort_by=None):
if sort_by is None:
if self.rfc:
return "2%04d" % self.rfc.rfc_number
elif self.id.draft_status == "Active":
return "1"+self.id.draft_name
else:
return "3"+self.id.draft_name
else:
if self.rfc:
sort_key = "2"
elif self.id.draft_status == "Active":
sort_key = "1"
else:
sort_key = "3"
# Depending on what we're sorting on, we may
# need to do some conversion.
if sort_by == "title":
sort_key += self.title()
elif sort_by == "date":
sort_key = sort_key + str(self.publication_date())
elif sort_by == "status":
if self.rfc:
sort_key += "%04d" % self.rfc.rfc_number
else:
sort_key += self.id.draft_status
elif sort_by == "ipr":
sort_key += self.iprUrl
elif sort_by == "ad":
return self.view_sort_key_byad()
else:
# sort default or unknown sort value, revert to default
if self.rfc:
sort_key += "%04d" % self.rfc.rfc_number
else:
sort_key += self.id.draft_name
return sort_key
def view_sort_key_byad(self):
if self.rfc:
return "2%04d" % self.rfc.rfc_number
elif self.id.draft_status == "Active":
if self.id.in_ietf_process():
return "11%02d" % (self.id.ietf_process._idinternal.cur_state_id)
else:
return "10"
else:
return "3"
# ---------------------------------------------------------------------------
class BallotWrapper:
_idinternal = None
ballot = None
ballot_active = False
_positions = None
position_values = ["Discuss", "Yes", "No Objection", "Abstain", "Recuse", "No Record"]
def __init__(self, idinternal):
self._idinternal = idinternal
self.ballot = idinternal.ballot
if not idinternal.rfc_flag:
self.ballot_active = self.ballot.ballot_issued and (str(idinternal.cur_state) in BALLOT_ACTIVE_STATES) and str(idinternal.draft.status)=="Active";
else:
self.ballot_active = self.ballot.ballot_issued and (str(idinternal.cur_state) in BALLOT_ACTIVE_STATES)
self._ballot_set = None
def approval_text(self):
return self.ballot.approval_text
def ballot_writeup(self):
return self.ballot.ballot_writeup
def is_active(self):
return self.ballot_active
def ballot_id(self):
return self._idinternal.ballot_id
def was_deferred(self):
return self.ballot.defer
def deferred_by(self):
return self.ballot.defer_by
def deferred_date(self):
return self.ballot.defer_date
def is_ballot_set(self):
if not self._ballot_set:
self._ballot_set = self._idinternal.ballot_set()
return len(list(self._ballot_set)) > 1
def ballot_set_other(self):
if not self.is_ballot_set():
return []
else:
return self._ballot_set.exclude(draft=self._idinternal)
def _init(self):
if not settings.USE_DB_REDESIGN_PROXY_CLASSES:
self.old_init()
return
from ietf.person.models import Person
from ietf.doc.models import BallotPositionDocEvent, NewRevisionDocEvent, BallotDocEvent
active_ads = Person.objects.filter(role__name="ad", role__group__state="active").distinct()
positions = []
seen = {}
new_revisions = list(NewRevisionDocEvent.objects.filter(doc=self.ballot, type="new_revision").order_by('-time', '-id'))
ballot = self.ballot.latest_event(BallotDocEvent, type="created_ballot")
for pos in BallotPositionDocEvent.objects.filter(doc=self.ballot, type="changed_ballot_position", ballot=ballot).select_related('ad').order_by("-time", '-id'):
if pos.ad not in seen:
p = dict(ad_name=pos.ad.plain_name(),
ad_username=pos.ad.pk, # ought to rename this in doc_ballot_list
position=pos.pos.name,
is_old_ad=pos.ad not in active_ads,
old_positions=[])
rev = pos.doc.rev
for n in new_revisions:
if n.time <= pos.time:
rev = n.rev
break
if pos.pos.slug == "discuss":
p["has_text"] = True
p["discuss_text"] = pos.discuss
p["discuss_date"] = pos.discuss_time.date()
p["discuss_revision"] = rev
if pos.comment:
p["has_text"] = True
p["comment_text"] = pos.comment
p["comment_date"] = pos.comment_time.date()
p["comment_revision"] = rev
positions.append(p)
seen[pos.ad] = p
else:
latest = seen[pos.ad]
if latest["old_positions"]:
prev = latest["old_positions"][-1]
else:
prev = latest["position"]
if prev != pos.pos.name:
seen[pos.ad]["old_positions"].append(pos.pos.name)
# add any missing ADs as No Record
if self.ballot_active:
for ad in active_ads:
if ad not in seen:
d = dict(ad_name=ad.plain_name(),
ad_username=ad.pk,
position="No Record",
)
positions.append(d)
self._positions = positions
def old_init(self):
try:
ads = set()
except NameError:
# for Python 2.3
from sets import Set as set
ads = set()
positions = []
all_comments = self.ballot.comments.all().select_related('ad')
for p in self.ballot.positions.all().select_related('ad'):
po = create_position_object(self.ballot, p, all_comments)
#if not self.ballot_active:
# if 'is_old_ad' in po:
# del po['is_old_ad']
ads.add(str(p.ad))
positions.append(po)
for c in all_comments:
if (str(c.ad) not in ads) and c.ad.is_current_ad():
positions.append({'has_text':True,
'comment_text':c.text,
'comment_date':c.date,
'comment_revision':str(c.revision),
'ad_name':str(c.ad),
'ad_username': c.ad.login_name,
'position':'No Record',
'is_old_ad':False})
ads.add(str(c.ad))
if self.ballot_active:
for ad in IESGLogin.active_iesg():
if str(ad) not in ads:
positions.append(dict(ad_name=str(ad),
ad_username=ad.login_name,
position="No Record"))
self._positions = positions
def position_for_ad(self, ad_name):
pl = self.position_list()
for p in pl:
if p["ad_name"] == ad_name:
return p["position"]
return None
def position_list(self):
if not self._positions:
self._init()
return self._positions
def get(self, v):
return [p for p in self.position_list() if p['position']==v]
def get_discuss(self):
return self.get("Discuss")
def get_yes(self):
return self.get("Yes")
def get_no_objection(self):
return self.get("No Objection")
def get_abstain(self):
return self.get("Abstain")
def get_recuse(self):
return self.get("Recuse")
def get_no_record(self):
return self.get("No Record")
def get_texts(self):
return [p for p in self.position_list() if ('has_text' in p) and p['has_text']]
def dict(self):
summary = {}
for key in self.position_values:
tag = key.lower().replace(" ", "_")
summary[tag] = [ pos["ad_name"] for pos in self.get(key) ]
positions = self.position_list()
for i in range(len(positions)):
for key in ["comment_date", "discuss_date", ]:
if key in positions[i]:
positions[i][key] = positions[i][key].strftime("%Y-%m-%d")
return {
"active": self.is_active(),
"approval_text": self.approval_text(),
"ballot_writeup": self.ballot_writeup(),
"ballot_id": self.ballot_id(),
"deferred_by": unicode(self.deferred_by()),
"deferred_date": self.deferred_date() and self.deferred_date().strftime("%Y-%m-%d") ,
"positions": positions,
"summary": summary,
"was_deferred": self.was_deferred(),
}
def position_to_string(position):
positions = {"yes":"Yes",
"noobj":"No Objection",
"discuss":"Discuss",
"abstain":"Abstain",
"recuse":"Recuse"}
if not position:
return "No Record"
p = None
for k,v in positions.iteritems():
if getattr(position, k) > 0:
p = v
if not p:
p = "No Record"
return p
def create_position_object(ballot, position, all_comments):
positions = {"yes":"Yes",
"noobj":"No Objection",
"discuss":"Discuss",
"abstain":"Abstain",
"recuse":"Recuse"}
p = None
for k,v in positions.iteritems():
if position.__dict__[k] > 0:
p = v
if not p:
p = "No Record"
r = dict(ad_name=str(position.ad),
ad_username=position.ad.login_name,
position=p)
if not position.ad.is_current_ad():
r['is_old_ad'] = True
else:
r['is_old_ad'] = False
was = [v for k,v in positions.iteritems() if position.__dict__[k] < 0]
if len(was) > 0:
r['old_positions'] = was
comment = None
for c in all_comments:
if c.ad == position.ad:
comment = c
break
if comment and comment.text:
r['has_text'] = True
r['comment_text'] = comment.text
r['comment_date'] = comment.date
r['comment_revision'] = str(comment.revision)
if p == "Discuss":
try:
discuss = ballot.discusses.get(ad=position.ad)
if discuss.text:
r['discuss_text'] = discuss.text
else:
r['discuss_text'] = '(empty)'
r['discuss_revision'] = str(discuss.revision)
r['discuss_date'] = discuss.date
except IESGDiscuss.DoesNotExist:
# this should never happen, but unfortunately it does
# fill in something to keep other parts of the code happy
r['discuss_text'] = "(error: discuss text not found)"
r['discuss_revision'] = "00"
r['discuss_date'] = date(2000, 1,1)
r['has_text'] = True
return r

88
ietf/idrfc/mirror_draft_versions.py
View file

@ -1,88 +0,0 @@
# Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved. Contact: Pasi Eronen <pasi.eronen@nokia.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
#
# * Neither the name of the Nokia Corporation and/or its
# subsidiary(-ies) nor the names of its contributors may be used
# to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from ietf import settings
from django.core import management
management.setup_environ(settings)
from django import db
import urllib2
from datetime import datetime
import socket
import sys
URL = "http://merlot.tools.ietf.org/~pasi/draft_versions.txt"
TABLE = "draft_versions_mirror"
log_data = ""
def log(line):
global log_data
if len(sys.argv) > 1:
print line
else:
log_data += line + "\n"
try:
log("output from mirror_draft_versions.py:\n")
log("time: "+str(datetime.now()))
log("host: "+socket.gethostname())
log("url: "+URL)
log("downloading...")
socket.setdefaulttimeout(30)
response = urllib2.urlopen(URL)
#log("got \n"+str(response.info()))
log("parsing...")
data = []
for line in response.readlines():
rec = line[:-1].split("\t")
data.append(rec)
log("got " + str(len(data)) + " entries")
if len(data) < 10000:
raise Exception('not enough data')
log("connecting to database...")
cursor = db.connection.cursor()
log("removing old data...")
cursor.execute("DELETE FROM "+TABLE)
log("inserting new data...")
cursor.executemany("INSERT INTO "+TABLE+" (filename, revision, revision_date) VALUES (%s, %s, %s)", data)
cursor.close()
db.connection._commit()
db.connection.close()
log("all done!")
log_data = ""
finally:
if len(log_data) > 0:
print log_data

104
ietf/idrfc/models.py
View file

@ -1,104 +0,0 @@
# Copyright (C) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved. Contact: Pasi Eronen <pasi.eronen@nokia.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
#
# * Neither the name of the Nokia Corporation and/or its
# subsidiary(-ies) nor the names of its contributors may be used
# to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from django.db import models
from ietf.idtracker.models import InternetDraft
class RfcEditorQueue(models.Model):
STREAM_CHOICES = (
(0, 'Unknown'),
(1, 'IETF'),
(2, 'IAB'),
(3, 'IRTF'),
(4, 'Independent')
)
draft = models.OneToOneField(InternetDraft, db_column="id_document_tag", related_name="rfc_editor_queue_state",primary_key=True)
date_received = models.DateField()
state = models.CharField(max_length=200, blank=True, null=True)
# currently, queue2.xml does not have this information, so
# this field will be NULL (but we could get it from other sources)
state_date = models.DateField(blank=True,null=True)
stream = models.IntegerField(choices=STREAM_CHOICES)
auth48_url = models.CharField(max_length=200, blank=True, null=True)
rfc_number = models.IntegerField(null=True)
def __str__(self):
return "RfcEditorQueue"+str([self.draft, self.date_received, self.state, self.state_date, self.stream])
class Meta:
db_table = "rfc_editor_queue_mirror"
class RfcEditorQueueRef(models.Model):
source = models.ForeignKey(InternetDraft, db_column="source", related_name="rfc_editor_queue_refs")
destination = models.CharField(max_length=200)
in_queue = models.BooleanField()
direct = models.BooleanField() # Is this a direct (or indirect) depencency?
class Meta:
db_table = "rfc_editor_queue_mirror_refs"
class RfcIndex(models.Model):
rfc_number = models.IntegerField(primary_key=True)
title = models.CharField(max_length=250)
authors = models.CharField(max_length=250)
rfc_published_date = models.DateField()
current_status = models.CharField(max_length=50,null=True)
updates = models.CharField(max_length=200,blank=True,null=True)
updated_by = models.CharField(max_length=200,blank=True,null=True)
obsoletes = models.CharField(max_length=200,blank=True,null=True)
obsoleted_by = models.CharField(max_length=200,blank=True,null=True)
also = models.CharField(max_length=50,blank=True,null=True)
draft = models.CharField(max_length=200,null=True)
has_errata = models.BooleanField()
stream = models.CharField(max_length=15,blank=True,null=True)
wg = models.CharField(max_length=15,blank=True,null=True)
file_formats = models.CharField(max_length=20,blank=True,null=True)
def __str__(self):
return "RfcIndex"+str(self.rfc_number)
class Meta:
db_table = "rfc_index_mirror"
class DraftVersions(models.Model):
# Django does not support multi-column primary keys, so
# we can't use filename+revision. But the key for this table
# does not really matter, so we'll have an 'id' field
id = models.AutoField(primary_key=True)
filename = models.CharField(max_length=200, db_index=True)
revision = models.CharField(max_length=2)
revision_date = models.DateField()
def __str__(self):
return "DraftVersions"+self.filename+self.revision+str(self.revision_date)
class Meta:
db_table = "draft_versions_mirror"
from django.conf import settings
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
RfcIndexOld = RfcIndex
from ietf.doc.proxy import RfcIndex

4
ietf/iesg/admin.py
View file

@ -5,9 +5,5 @@ class TelechatAgendaItemAdmin(admin.ModelAdmin):
pass
admin.site.register(TelechatAgendaItem, TelechatAgendaItemAdmin)
class WGActionAdmin(admin.ModelAdmin):
pass
admin.site.register(WGAction, WGActionAdmin)
admin.site.register(TelechatDate)

217
ietf/iesg/agenda.py Normal file
View file

@ -0,0 +1,217 @@
# utilities for constructing agendas for IESG telechats
import codecs, re, os, datetime
# FIXME: once we're on Python 2.7, replace with: from collections import OrderedDict
from django.utils.datastructures import SortedDict as OrderedDict
from django.http import Http404
from django.conf import settings
from ietf.iesg.models import TelechatDate, TelechatAgendaItem
from ietf.doc.models import Document, TelechatDocEvent, LastCallDocEvent, ConsensusDocEvent, DocEvent
from ietf.group.models import Group, GroupMilestone
def get_agenda_date(date=None):
if not date:
try:
return TelechatDate.objects.active().order_by('date')[0].date
except IndexError:
return datetime.date.today()
else:
try:
# FIXME: .active()
return TelechatDate.objects.all().get(date=datetime.datetime.strptime(date, "%Y-%m-%d").date()).date
except (ValueError, TelechatDate.DoesNotExist):
raise Http404
def get_doc_section(doc):
if doc.type_id == 'draft':
if doc.intended_std_level_id in ["bcp", "ds", "ps", "std"]:
s = "2"
else:
s = "3"
g = doc.group_acronym()
if g and str(g) != 'none':
s += ".1"
elif s == "3" and doc.stream_id in ("ise","irtf"):
s += ".3"
else:
s += ".2"
if doc.get_state_slug() != "rfc" and doc.get_state_slug('draft-iesg') not in ("lc", "writeupw", "goaheadw", "iesg-eva", "defer"):
s += ".3"
elif doc.returning_item():
s += ".2"
else:
s += ".1"
elif doc.type_id == 'charter':
s = "4"
if doc.group.state_id in ('active', 'dormant'):
s += ".2"
else:
s += ".1"
if doc.get_state_slug() in ('extrev', 'iesgrev'):
s += '.2'
else:
s += '.1'
elif doc.type_id == 'statchg':
protocol_action = False
for relation in doc.relateddocument_set.filter(relationship__slug__in=('tops','tois','tohist','toinf','tobcp','toexp')):
if relation.relationship.slug in ('tops','tois') or relation.target.document.std_level.slug in ('std','ds','ps'):
protocol_action = True
if protocol_action:
s = "2.3"
else:
s = "3.3"
if doc.get_state_slug() not in ("iesgeval", "defer", "appr-pr", "appr-pend", "appr-sent"):
s += ".3"
elif doc.returning_item():
s += ".2"
else:
s += ".1"
elif doc.type_id == 'conflrev':
if doc.get_state('conflrev').slug not in ('adrev','iesgeval','appr-reqnopub-pend','appr-reqnopub-sent','appr-noprob-pend','appr-noprob-sent','defer'):
s = "3.4.3"
elif doc.returning_item():
s = "3.4.2"
else:
s = "3.4.1"
return s
def agenda_sections():
return OrderedDict([
('1', {'title':"Administrivia"}),
('1.1', {'title':"Roll Call"}),
('1.2', {'title':"Bash the Agenda"}),
('1.3', {'title':"Approval of the Minutes of Past Telechats"}),
('1.4', {'title':"List of Remaining Action Items from Last Telechat"}),
('2', {'title':"Protocol Actions"}),
('2.1', {'title':"WG Submissions"}),
('2.1.1', {'title':"New Items", 'docs': []}),
('2.1.2', {'title':"Returning Items", 'docs':[]}),
('2.1.3', {'title':"For Action", 'docs':[]}),
('2.2', {'title':"Individual Submissions"}),
('2.2.1', {'title':"New Items", 'docs':[]}),
('2.2.2', {'title':"Returning Items", 'docs':[]}),
('2.2.3', {'title':"For Action", 'docs':[]}),
('2.3', {'title':"Status Changes"}),
('2.3.1', {'title':"New Items", 'docs':[]}),
('2.3.2', {'title':"Returning Items", 'docs':[]}),
('2.3.3', {'title':"For Action", 'docs':[]}),
('3', {'title':"Document Actions"}),
('3.1', {'title':"WG Submissions"}),
('3.1.1', {'title':"New Items", 'docs':[]}),
('3.1.2', {'title':"Returning Items", 'docs':[]}),
('3.1.3', {'title':"For Action", 'docs':[]}),
('3.2', {'title':"Individual Submissions Via AD"}),
('3.2.1', {'title':"New Items", 'docs':[]}),
('3.2.2', {'title':"Returning Items", 'docs':[]}),
('3.2.3', {'title':"For Action", 'docs':[]}),
('3.3', {'title':"Status Changes"}),
('3.3.1', {'title':"New Items", 'docs':[]}),
('3.3.2', {'title':"Returning Items", 'docs':[]}),
('3.3.3', {'title':"For Action", 'docs':[]}),
('3.4', {'title':"IRTF and Independent Submission Stream Documents"}),
('3.4.1', {'title':"New Items", 'docs':[]}),
('3.4.2', {'title':"Returning Items", 'docs':[]}),
('3.4.3', {'title':"For Action", 'docs':[]}),
('4', {'title':"Working Group Actions"}),
('4.1', {'title':"WG Creation"}),
('4.1.1', {'title':"Proposed for IETF Review", 'docs':[]}),
('4.1.2', {'title':"Proposed for Approval", 'docs':[]}),
('4.2', {'title':"WG Rechartering"}),
('4.2.1', {'title':"Under Evaluation for IETF Review", 'docs':[]}),
('4.2.2', {'title':"Proposed for Approval", 'docs':[]}),
('5', {'title':"IAB News We Can Use"}),
('6', {'title':"Management Issues"}),
('7', {'title':"Working Group News"}),
])
def fill_in_agenda_administrivia(date, sections):
extra_info_files = (
("1.1", "roll_call", settings.IESG_ROLL_CALL_FILE),
("1.3", "minutes", settings.IESG_MINUTES_FILE),
("1.4", "action_items", settings.IESG_TASK_FILE),
)
for s, key, filename in extra_info_files:
try:
with codecs.open(filename, 'r', 'utf-8', 'replace') as f:
t = f.read().strip()
except IOError:
t = u"(Error reading %s)" % filename
sections[s]["text"] = t
def fill_in_agenda_docs(date, sections, matches=None):
if not matches:
matches = Document.objects.filter(docevent__telechatdocevent__telechat_date=date)
matches = matches.select_related("stream", "group").distinct()
docs = []
for doc in matches:
if doc.latest_event(TelechatDocEvent, type="scheduled_for_telechat").telechat_date != date:
continue
e = doc.latest_event(type="started_iesg_process")
doc.balloting_started = e.time if e else datetime.datetime.min
if doc.type_id == "draft":
s = doc.get_state("draft-iana-review")
if s: # and s.slug in ("not-ok", "changed", "need-rev"):
doc.iana_review_state = str(s)
if doc.get_state_slug("draft-iesg") == "lc":
e = doc.latest_event(LastCallDocEvent, type="sent_last_call")
if e:
doc.lastcall_expires = e.expires
if doc.stream_id in ("ietf", "irtf", "iab"):
doc.consensus = "Unknown"
e = doc.latest_event(ConsensusDocEvent, type="changed_consensus")
if e:
doc.consensus = "Yes" if e.consensus else "No"
elif doc.type_id == "conflrev":
doc.conflictdoc = doc.relateddocument_set.get(relationship__slug='conflrev').target.document
elif doc.type_id == "charter":
#if doc.group.state_id not in ("proposed", "active"):
# continue
doc.group.txt_link = settings.CHARTER_TXT_URL + "%s-%s.txt" % (doc.canonical_name(), doc.rev)
num = get_doc_section(doc)
if num: # and num in sections
sections[num]["docs"].append(doc)
# prune empty "For action" sections
empty_for_action = [num for num, section in sections.iteritems()
if section["title"] == "For Action" and not section["docs"]]
for num in empty_for_action:
del sections[num]
# Be careful to keep this the same as what's used in agenda_documents
for s in sections.itervalues():
if "docs" in s:
s["docs"].sort(key=lambda d: d.balloting_started)
def fill_in_agenda_management_issues(date, sections):
s = "6.%s"
for i, item in enumerate(TelechatAgendaItem.objects.filter(type=3).order_by('id'), start=1):
sections[s % i] = { "title": item.title, "text": item.text }
def agenda_data(date=None):
"""Return a dict with the different IESG telechat agenda components."""
date = get_agenda_date(date)
sections = agenda_sections()
fill_in_agenda_administrivia(date, sections)
fill_in_agenda_docs(date, sections)
fill_in_agenda_management_issues(date, sections)
return { 'date': date.isoformat(), 'sections': sections }

34
ietf/iesg/feeds.py
View file

@ -8,27 +8,31 @@ import datetime
class IESGAgenda(Feed):
title = "Documents on Future IESG Telechat Agendas"
link = "http://datatracker.ietf.org/iesg/agenda/"
link = settings.IDTRACKER_BASE_URL + "/iesg/agenda/"
feed_type = Atom1Feed
def items(self):
from ietf.doc.models import TelechatDocEvent
drafts = Document.objects.filter(docevent__telechatdocevent__telechat_date__gte=datetime.date.min).distinct()
for d in drafts:
docs = Document.objects.filter(docevent__telechatdocevent__telechat_date__gte=datetime.date.today()).distinct()
for d in docs:
d.latest_telechat_event = d.latest_event(TelechatDocEvent, type="scheduled_for_telechat")
drafts = [d for d in drafts if d.latest_telechat_event.telechat_date]
drafts.sort(key=lambda d: d.latest_telechat_event.telechat_date)
return drafts
docs = [d for d in docs if d.latest_telechat_event.telechat_date]
docs.sort(key=lambda d: d.latest_telechat_event.telechat_date, reverse=True)
return docs
def item_categories(self, doc):
return [ str(doc.telechat_date) ]
def item_categories(self, item):
return [ str(item.telechat_date) ]
def item_pubdate(self, item):
return item.latest_telechat_event.time
def item_pubdate(self, doc):
return doc.latest_telechat_event.time
def item_author_name(self, item):
return str( item.ad ) if item.ad else "None"
def item_author_name(self, doc):
return doc.ad.plain_name() if doc.ad else "None"
def item_author_email(self, item):
return str( item.ad.role_email("ad") ) if item.ad else ""
def item_author_email(self, doc):
if not doc.ad:
return ""
e = doc.ad.role_email("ad")
if not e:
return ""
return e.address

143
ietf/iesg/fixtures/sieve-charter.txt
View file

@ -1,143 +0,0 @@
Sieve Mail Filtering Language (sieve)
-------------------------------------
Current Status: Active
Last updated: 2010-05-07
Chairs:
Cyrus Daboo <cyrus@daboo.name>
Aaron Stone <aaron@serendipity.cx>
Applications Area Directors:
Alexey Melnikov <alexey.melnikov@isode.com>
Peter Saint-Andre <stpeter@stpeter.im>
Applications Area Advisor:
Alexey Melnikov <alexey.melnikov@isode.com>
Mailing Lists:
General Discussion: sieve@ietf.org
To Subscribe: sieve-request@ietf.org
Archive:
http://www.ietf.org/mail-archive/web/sieve/current/maillist.html
Description of Working Group:
The SIEVE email filtering language is specified in RFC 5228, together
with a number of extensions.
The SIEVE working group is being re-chartered to:
(1) Finish work on existing in-progress Working Group documents:
(a) External lists (draft-ietf-sieve-external-lists)
(b) Notify SIP (draft-ietf-sieve-notify-sip-message)
(c) RegEx (draft-ietf-sieve-regex)
(d) Include/multi-script (draft-ietf-sieve-include)
(e) Sieve in IMAP (draft-ietf-sieve-imap-sieve)
(2) Finalize and publish the following SIEVE extensions as proposed
standards:
(a) General Auto-reply (draft-george-sieve-autoreply)
(b) Notify presence (draft-george-sieve-notify-presence)
(c) Vacation time (draft-george-sieve-vacation-time)
(d) Convert messages (draft-melnikov-sieve-convert)
Additional drafts may be added to this list, but only via a charter
revision. There must also be demonstrable willingness in the SIEVE
development community to actually implement a given extension before it
can be added to this charter.
(3) Work on a specification for iCalendar and vCard extraction, and
cooperate with the VCARDDAV WG for address book tests in Sieve.
(4) Work on a specification to describe how EAI/IDN issues should be
handled in SIEVE.
(5) Work on a "Benefits of SIEVE" guide for client and server vendors
that:
(a) Describes the SIEVE protocol and its suite of extensions.
(b) Explains the benefits of server-side filtering in practical terms.
(c) Shows how client-side filtering can be migrated to SIEVE.
(6) Produce one or more informational RFCs containing a set of test
scripts and test email messages that are to be filtered by the scripts,
and the expected results of that filtering. This will serve as the basis
of a interoperability test suite to help determine the suitability of
moving the base specification and selected extensions to Draft status.
Goals and Milestones:
Done - Submit revised variables draft.
Done - Submit revised vacation draft.
Done - WG last call for variables draft.
Done - Initial submission of RFC 3028bis.
Done - WG last call for RFC 3028bis.
Done - Initial submission of revised relational draft.
Done - Initial submission of revised subaddress draft.
Done - Initial submission of revised spamtest/virustest draft.
Done - Submit revised editheader draft.
Done - Submit revised imapflags draft.
Done - WG last call of revised subaddress draft.
Done - Submit revised body test draft.
Done - Submit revised reject before delivery draft.
Done - WG last call for editheader draft.
Done - WG last call for body test draft.
Done - WG last call for refuse draft
Done - WG last call of revised spamtest draft
Done - Submit variables draft to IESG
Done - Submit revised loop draft
Done - Submit revised notification action draft
Done - WG last call of revised relational draft
Done - WG last call for imap-flags draft
Done - WG last call for vacation draft
Done - WG last call of revised subaddress draft
Done - Submit revised relational draft to IESG
Done - Submit vacation draft to IESG
Done - Submit revised subaddress draft to IESG
Done - Submit imapflags draft to IESG
Done - Submit revised spamtest draft to IESG
Done - Submit 3028bis to IESG
Done - Submit editheader draft to IESG
Done - Submit body test draft to IESG
Done - WG last call for notification action draft
Done - Submit notification action draft to IESG
Done - Submit refuse-reject to IESG
Done - Submit notify-mailto to IESG
Done - Submit mime-loops to IESG
Done - WGLC iHave
Done - WGLC Notary
Done - Submit iHave to IESG
Done - Submit Notary to IESG
Done - WGLC sieve-in-xml
Done - Submit sieve-in-xml to IESG
Done - WGLC ManageSIEVE
Done - Submit ManageSIEVE to IESG
Done - WGLC Notify-sip
Done - WGLC Metadata
Done - Submit Metadata to IESG
Done - Publish refuse/reject - RFC 5429
Done - Publish notify base spec - RFC 5435
Done - Publish notify mailto extension - RFC 5436
Done - Publish notify xmpp extension - RFC 5437
Done - Publish ihave - RFC 5463
Done - Publish meta-data - RFC 5490
Done - Publish mime loops - RFC 5703
Done - Publish Sieve in XML - RFC 5784
Done - Revised RegEx draft
Apr 2010 - Revised Include/multi-script draft
Apr 2010 - WGLC external-lists
May 2010 - WGLC Include/multi-script
May 2010 - Submit external-lists to IESG
Jun 2010 - Submit Include/multi-script to IESG
Jun 2010 - WGLC Notify-SIP
Jul 2010 - Initial eai-issues draft
Jul 2010 - Submit Notify-SIP to IESG
Aug 2010 - WGLC RegEx
Aug 2010 - Initial test-scripts draft
Aug 2010 - Initial benefits draft
Sep 2010 - Submit RegEx to IESG
Oct 2010 - WGLC eai-issues
Nov 2010 - Submit eai-issues to IESG
Nov 2010 - WGLC benefits
Jan 2011 - Submit benefits to IESG
Mar 2011 - WGLC test-scripts
Apr 2011 - Submit test-scripts to IESG

133
ietf/iesg/models.py
View file

@ -32,53 +32,10 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from django.db import models
from django.conf import settings
from ietf.idtracker.models import Acronym
import datetime
# This table is not used by any code right now, and according to Glen,
# probably not currently (Aug 2009) maintained by the secretariat.
#class TelechatMinutes(models.Model):
# telechat_date = models.DateField(null=True, blank=True)
# telechat_minute = models.TextField(blank=True)
# exported = models.IntegerField(null=True, blank=True)
# def get_absolute_url(self):
# return "/iesg/telechat/%d/" % self.id
# def __str__(self):
# return "IESG Telechat Minutes for %s" % self.telechat_date
# class Meta:
# db_table = 'telechat_minutes'
# verbose_name = "Telechat Minute Text"
# verbose_name_plural = "Telechat Minutes"
# this model is deprecated
class TelechatDates(models.Model):
date1 = models.DateField(primary_key=True, null=True, blank=True)
date2 = models.DateField(null=True, blank=True)
date3 = models.DateField(null=True, blank=True)
date4 = models.DateField(null=True, blank=True)
def dates(self):
l = []
if self.date1:
l.append(self.date1)
if self.date2:
l.append(self.date2)
if self.date3:
l.append(self.date3)
if self.date4:
l.append(self.date4)
return l
def save(self):
# date1 isn't really a primary id, so save() doesn't work
raise NotImplemented
def __str__(self):
return " / ".join([str(d) for d in [self.date1,self.date2,self.date3,self.date4]])
class Meta:
db_table = "telechat_dates"
verbose_name = "Next Telechat Date"
from django.db import models
from django.conf import settings
class TelechatAgendaItem(models.Model):
TYPE_CHOICES = (
@ -91,41 +48,10 @@ class TelechatAgendaItem(models.Model):
text = models.TextField(blank=True, db_column='template_text')
type = models.IntegerField(db_column='template_type', choices=TYPE_CHOICES, default=3)
title = models.CharField(max_length=255, db_column='template_title')
#The following fields are apparently not used
#note = models.TextField(null=True,blank=True)
#discussed_status_id = models.IntegerField(null=True, blank=True)
#decision = models.TextField(null=True,blank=True)
def __unicode__(self):
type_name = self.TYPE_CHOICES_DICT.get(self.type, str(self.type))
return u'%s: %s' % (type_name, self.title or "")
class Meta:
if not settings.USE_DB_REDESIGN_PROXY_CLASSES:
db_table = 'templates'
class WGAction(models.Model):
CATEGORY_CHOICES = (
(11, "WG Creation::In Internal Review"),
(12, "WG Creation::Proposed for IETF Review"),
(13, "WG Creation::Proposed for Approval"),
(21, "WG Rechartering::In Internal Review"),
(22, "WG Rechartering::Under evaluation for IETF Review"),
(23, "WG Rechartering::Proposed for Approval")
)
# note that with the new schema, Acronym is monkey-patched and is really Group
group_acronym = models.ForeignKey(Acronym, db_column='group_acronym_id', primary_key=True, unique=True)
note = models.TextField(blank=True,null=True)
status_date = models.DateField()
agenda = models.BooleanField("On Agenda")
token_name = models.CharField(max_length=25)
category = models.IntegerField(db_column='pwg_cat_id', choices=CATEGORY_CHOICES, default=11)
telechat_date = models.DateField() #choices = [(x.telechat_date,x.telechat_date) for x in Telechat.objects.all().order_by('-telechat_date')])
def __str__(self):
return str(self.telechat_date)+": "+str(self.group_acronym)
class Meta:
if not settings.USE_DB_REDESIGN_PROXY_CLASSES:
db_table = 'group_internal'
ordering = ['-telechat_date']
verbose_name = "WG Action"
class Telechat(models.Model):
telechat_id = models.IntegerField(primary_key=True)
@ -136,6 +62,7 @@ class Telechat(models.Model):
management_issue = models.TextField(blank=True)
frozen = models.IntegerField(null=True, blank=True)
mi_frozen = models.IntegerField(null=True, blank=True)
class Meta:
db_table = u'telechat'
@ -160,55 +87,3 @@ class TelechatDate(models.Model):
class Meta:
ordering = ['-date']
class TelechatDatesProxyDummy(object):
def all(self):
class Dummy(object):
def __getitem__(self, i):
return self
def get_date(self, index):
if not hasattr(self, "date_cache"):
self.date_cache = TelechatDate.objects.active().order_by("date")
if index < len(self.date_cache):
return self.date_cache[index].date
return None
#date1 = models.DateField(primary_key=True, null=True, blank= True)
@property
def date1(self):
return self.get_date(0)
#date2 = models.DateField(null=True, blank=True)
@property
def date2(self):
return self.get_date(1)
#date3 = models.DateField(null=True, blank=True)
@property
def date3(self):
return self.get_date(2)
#date4 = models.DateField(null=True, blank=True)
@property
def date4(self):
return self.get_date(3)
def dates(self):
l = []
if self.date1:
l.append(self.date1)
if self.date2:
l.append(self.date2)
if self.date3:
l.append(self.date3)
if self.date4:
l.append(self.date4)
return l
return Dummy()
class TelechatDatesProxy(object):
objects = TelechatDatesProxyDummy()
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
TelechatDatesOld = TelechatDates
TelechatDates = TelechatDatesProxy

780
ietf/iesg/tests.py
View file

@ -1,67 +1,367 @@
from datetime import timedelta
import os, shutil
import os, shutil, json
from django.core.urlresolvers import reverse as urlreverse
from django.conf import settings
from pyquery import PyQuery
from ietf.idtracker.models import *
from ietf.utils.test_data import make_test_data
from ietf.doc.models import *
from ietf.person.models import Person
from ietf.group.models import Group
from ietf.name.models import StreamName
from ietf.iesg.models import *
from ietf.utils.test_utils import TestCase, SimpleUrlTestCase, RealDatabaseTest, canonicalize_feed, login_testing_unauthorized
from ietf.ietfworkflows.models import Stream
from ietf.utils.test_utils import TestCase, login_testing_unauthorized
from ietf.iesg.agenda import get_agenda_date, agenda_data
class RescheduleOnAgendaTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['base', 'draft']
class ReviewDecisionsTests(TestCase):
def test_review_decisions(self):
draft = make_test_data()
def test_reschedule(self):
draft = InternetDraft.objects.get(filename="draft-ietf-mipshop-pfmipv6")
draft.idinternal.telechat_date = TelechatDates.objects.all()[0].dates()[0]
draft.idinternal.agenda = True
draft.idinternal.returning_item = True
draft.idinternal.save()
e = DocEvent(type="iesg_approved")
e.doc = draft
e.by = Person.objects.get(name="Aread Irector")
e.save()
form_id = draft.idinternal.draft_id
telechat_date_before = draft.idinternal.telechat_date
url = urlreverse('ietf.iesg.views.agenda_documents')
self.client.login(remote_user="klm")
url = urlreverse('ietf.iesg.views.review_decisions')
# normal get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form select[name=%s-telechat_date]' % form_id)), 1)
self.assertEquals(len(q('form input[name=%s-clear_returning_item]' % form_id)), 1)
self.assertTrue(draft.name in r.content)
# reschedule
comments_before = draft.idinternal.comments().count()
d = TelechatDates.objects.all()[0].dates()[2]
class IESGAgendaTests(TestCase):
def setUp(self):
make_test_data()
r = self.client.post(url, { '%s-telechat_date' % form_id: d.strftime("%Y-%m-%d"),
'%s-clear_returning_item' % form_id: "1" })
ise_draft = Document.objects.get(name="draft-imaginary-independent-submission")
ise_draft.stream = StreamName.objects.get(slug="ise")
ise_draft.save()
self.telechat_docs = {
"ietf_draft": Document.objects.get(name="draft-ietf-mars-test"),
"ise_draft": ise_draft,
"conflrev": Document.objects.get(name="conflict-review-imaginary-irtf-submission"),
"statchg": Document.objects.get(name="status-change-imaginary-mid-review"),
"charter": Document.objects.filter(type="charter")[0],
}
by = Person.objects.get(name="Aread Irector")
date = get_agenda_date()
self.draft_dir = os.path.abspath("tmp-agenda-draft-dir")
os.mkdir(self.draft_dir)
settings.INTERNET_DRAFT_PATH = self.draft_dir
for d in self.telechat_docs.values():
TelechatDocEvent.objects.create(type="scheduled_for_telechat",
doc=d,
by=by,
telechat_date=date,
returning_item=True)
def tearDown(self):
shutil.rmtree(self.draft_dir)
def test_fill_in_agenda_docs(self):
draft = self.telechat_docs["ietf_draft"]
statchg = self.telechat_docs["statchg"]
conflrev = self.telechat_docs["conflrev"]
charter = self.telechat_docs["charter"]
# put on agenda
date = datetime.date.today() + datetime.timedelta(days=50)
TelechatDate.objects.create(date=date)
telechat_event = TelechatDocEvent.objects.create(
type="scheduled_for_telechat",
doc=draft,
by=Person.objects.get(name="Aread Irector"),
telechat_date=date,
returning_item=False)
date_str = date.isoformat()
# 2.1 protocol WG submissions
draft.intended_std_level_id = "ps"
draft.group = Group.objects.get(acronym="mars")
draft.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="iesg-eva"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.1.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.1.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="pub-req"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.1.3"]["docs"])
# 2.2 protocol individual submissions
draft.group = Group.objects.get(type="individ")
draft.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="iesg-eva"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.2.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.2.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="pub-req"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["2.2.3"]["docs"])
# 3.1 document WG submissions
draft.intended_std_level_id = "inf"
draft.group = Group.objects.get(acronym="mars")
draft.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="iesg-eva"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.1.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.1.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="pub-req"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.1.3"]["docs"])
# 3.2 document individual submissions
draft.group = Group.objects.get(type="individ")
draft.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="iesg-eva"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.2.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.2.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
draft.set_state(State.objects.get(type="draft-iesg", slug="pub-req"))
self.assertTrue(draft in agenda_data(date_str)["sections"]["3.2.3"]["docs"])
# 2.3 protocol status changes
telechat_event.doc = statchg
telechat_event.save()
relation = RelatedDocument.objects.create(
source=statchg,
target=DocAlias.objects.filter(name__startswith='rfc', document__std_level="ps")[0],
relationship_id="tohist")
statchg.group = Group.objects.get(acronym="mars")
statchg.save()
statchg.set_state(State.objects.get(type="statchg", slug="iesgeval"))
self.assertTrue(statchg in agenda_data(date_str)["sections"]["2.3.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(statchg in agenda_data(date_str)["sections"]["2.3.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
statchg.set_state(State.objects.get(type="statchg", slug="adrev"))
self.assertTrue(statchg in agenda_data(date_str)["sections"]["2.3.3"]["docs"])
# 3.3 document status changes
relation.target = DocAlias.objects.filter(name__startswith='rfc', document__std_level="inf")[0]
relation.save()
statchg.group = Group.objects.get(acronym="mars")
statchg.save()
statchg.set_state(State.objects.get(type="statchg", slug="iesgeval"))
self.assertTrue(statchg in agenda_data(date_str)["sections"]["3.3.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(statchg in agenda_data(date_str)["sections"]["3.3.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
statchg.set_state(State.objects.get(type="statchg", slug="adrev"))
self.assertTrue(statchg in agenda_data(date_str)["sections"]["3.3.3"]["docs"])
# 3.4 IRTF/ISE conflict reviews
telechat_event.doc = conflrev
telechat_event.save()
conflrev.group = Group.objects.get(acronym="mars")
conflrev.save()
conflrev.set_state(State.objects.get(type="conflrev", slug="iesgeval"))
self.assertTrue(conflrev in agenda_data(date_str)["sections"]["3.4.1"]["docs"])
telechat_event.returning_item = True
telechat_event.save()
self.assertTrue(conflrev in agenda_data(date_str)["sections"]["3.4.2"]["docs"])
telechat_event.returning_item = False
telechat_event.save()
conflrev.set_state(State.objects.get(type="conflrev", slug="needshep"))
self.assertTrue(conflrev in agenda_data(date_str)["sections"]["3.4.3"]["docs"])
# 4 WGs
telechat_event.doc = charter
telechat_event.save()
charter.group = Group.objects.get(acronym="mars")
charter.save()
charter.group.state_id = "bof"
charter.group.save()
charter.set_state(State.objects.get(type="charter", slug="infrev"))
self.assertTrue(charter in agenda_data(date_str)["sections"]["4.1.1"]["docs"])
charter.set_state(State.objects.get(type="charter", slug="iesgrev"))
self.assertTrue(charter in agenda_data(date_str)["sections"]["4.1.2"]["docs"])
charter.group.state_id = "active"
charter.group.save()
charter.set_state(State.objects.get(type="charter", slug="infrev"))
self.assertTrue(charter in agenda_data(date_str)["sections"]["4.2.1"]["docs"])
charter.set_state(State.objects.get(type="charter", slug="iesgrev"))
self.assertTrue(charter in agenda_data(date_str)["sections"]["4.2.2"]["docs"])
#for n, s in agenda_data(date_str)["sections"].iteritems():
# print n, s.get("docs") if "docs" in s else s["title"]
def test_feed(self):
url = "/feed/iesg-agenda/"
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
# check that it moved below the right header in the DOM
d_header_pos = r.content.find("IESG telechat %s" % d.strftime("%Y-%m-%d"))
draft_pos = r.content.find(draft.filename)
self.assertTrue(d_header_pos < draft_pos)
for d in self.telechat_docs.values():
self.assertTrue(d.name in r.content)
self.assertTrue(d.title in r.content)
draft = InternetDraft.objects.get(filename="draft-ietf-mipshop-pfmipv6")
self.assertEquals(draft.idinternal.telechat_date, d)
self.assertTrue(not draft.idinternal.returning_item)
self.assertEquals(draft.idinternal.comments().count(), comments_before + 1)
self.assertTrue("Telechat" in draft.idinternal.comments()[0].comment_text)
def test_agenda_json(self):
r = self.client.get(urlreverse("ietf.iesg.views.agenda_json"))
self.assertEquals(r.status_code, 200)
class RescheduleOnAgendaTestCaseREDESIGN(TestCase):
perma_fixtures = ['names']
for k, d in self.telechat_docs.iteritems():
if d.type_id == "charter":
self.assertTrue(d.group.name in r.content, "%s not in response" % k)
self.assertTrue(d.group.acronym in r.content, "%s acronym not in response" % k)
else:
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
self.assertTrue(json.loads(r.content))
def test_agenda(self):
r = self.client.get(urlreverse("ietf.iesg.views.agenda"))
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_txt(self):
r = self.client.get(urlreverse("ietf.iesg.views.agenda_txt"))
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
if d.type_id == "charter":
self.assertTrue(d.group.name in r.content, "%s not in response" % k)
self.assertTrue(d.group.acronym in r.content, "%s acronym not in response" % k)
else:
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_scribe_template(self):
r = self.client.get(urlreverse("ietf.iesg.views.agenda_scribe_template"))
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
if d.type_id == "charter":
continue # scribe template doesn't contain chartering info
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_moderator_package(self):
url = urlreverse("ietf.iesg.views.agenda_moderator_package")
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
if d.type_id == "charter":
self.assertTrue(d.group.name in r.content, "%s not in response" % k)
self.assertTrue(d.group.acronym in r.content, "%s acronym not in response" % k)
else:
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_package(self):
url = urlreverse("ietf.iesg.views.agenda_package")
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
if d.type_id == "charter":
self.assertTrue(d.group.name in r.content, "%s not in response" % k)
self.assertTrue(d.group.acronym in r.content, "%s acronym not in response" % k)
else:
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_documents_txt(self):
url = urlreverse("ietf.iesg.views.agenda_documents_txt")
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
self.assertTrue(d.name in r.content, "%s not in response" % k)
def test_agenda_documents(self):
url = urlreverse("ietf.iesg.views.agenda_documents")
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
for k, d in self.telechat_docs.iteritems():
self.assertTrue(d.name in r.content, "%s not in response" % k)
self.assertTrue(d.title in r.content, "%s title not in response" % k)
def test_agenda_telechat_docs(self):
d1 = self.telechat_docs["ietf_draft"]
d2 = self.telechat_docs["ise_draft"]
d1_filename = "%s-%s.txt" % (d1.name, d1.rev)
d2_filename = "%s-%s.txt" % (d2.name, d2.rev)
with open(os.path.join(self.draft_dir, d1_filename), "w") as f:
f.write("test content")
url = urlreverse("ietf.iesg.views.telechat_docs_tarfile", kwargs=dict(date=get_agenda_date().isoformat()))
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
import tarfile, StringIO
tar = tarfile.open(None, fileobj=StringIO.StringIO(r.content))
names = tar.getnames()
self.assertTrue(d1_filename in names)
self.assertTrue(d2_filename not in names)
self.assertTrue("manifest.txt" in names)
f = tar.extractfile(d1_filename)
self.assertEqual(f.read(), "test content")
f = tar.extractfile("manifest.txt")
lines = list(f.readlines())
self.assertTrue("Included" in [l for l in lines if d1_filename in l][0])
self.assertTrue("Not found" in [l for l in lines if d2_filename in l][0])
class RescheduleOnAgendaTests(TestCase):
def test_reschedule(self):
from ietf.utils.test_data import make_test_data
from ietf.person.models import Person
from ietf.doc.models import TelechatDocEvent
draft = make_test_data()
# add to schedule
@ -94,10 +394,12 @@ class RescheduleOnAgendaTestCaseREDESIGN(TestCase):
r = self.client.post(url, { '%s-telechat_date' % form_id: d.isoformat(),
'%s-clear_returning_item' % form_id: "1" })
self.assertEquals(r.status_code, 200)
self.assertEquals(r.status_code, 302)
# check that it moved below the right header in the DOM on the
# agenda docs page
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
d_header_pos = r.content.find("IESG telechat %s" % d.isoformat())
draft_pos = r.content.find(draft.name)
self.assertTrue(d_header_pos < draft_pos)
@ -107,376 +409,7 @@ class RescheduleOnAgendaTestCaseREDESIGN(TestCase):
self.assertTrue(not draft.latest_event(TelechatDocEvent, "scheduled_for_telechat").returning_item)
self.assertEquals(draft.docevent_set.count(), events_before + 1)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
RescheduleOnAgendaTestCase = RescheduleOnAgendaTestCaseREDESIGN
class ManageTelechatDatesTestCase(TestCase):
perma_fixtures = ['base', 'draft']
def test_set_dates(self):
dates = TelechatDates.objects.all()[0]
url = urlreverse('ietf.iesg.views.telechat_dates')
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 input[name=date1]')), 1)
# post
new_date = dates.date1 + timedelta(days=7)
r = self.client.post(url, dict(date1=new_date.isoformat(),
date2=new_date.isoformat(),
date3=new_date.isoformat(),
date4=new_date.isoformat(),
))
self.assertEquals(r.status_code, 200)
dates = TelechatDates.objects.all()[0]
self.assertTrue(dates.date1 == new_date)
def test_rollup_dates(self):
dates = TelechatDates.objects.all()[0]
url = urlreverse('ietf.iesg.views.telechat_dates')
login_testing_unauthorized(self, "klm", url)
old_date2 = dates.date2
new_date = dates.date4 + timedelta(days=14)
r = self.client.post(url, dict(rollup_dates="1"))
self.assertEquals(r.status_code, 200)
dates = TelechatDates.objects.all()[0]
self.assertTrue(dates.date4 == new_date)
self.assertTrue(dates.date1 == old_date2)
# class ManageTelechatDatesTestCaseREDESIGN(TestCase):
# perma_fixtures = ['names']
# def test_set_dates(self):
# from ietf.utils.test_data import make_test_data
# make_test_data()
# dates = TelechatDates.objects.all()[0]
# url = urlreverse('ietf.iesg.views.telechat_dates')
# 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 input[name=date1]')), 1)
# # post
# new_date = dates.date1 + timedelta(days=7)
# r = self.client.post(url, dict(date1=new_date.isoformat(),
# date2=new_date.isoformat(),
# date3=new_date.isoformat(),
# date4=new_date.isoformat(),
# ))
# self.assertEquals(r.status_code, 200)
# dates = TelechatDates.objects.all()[0]
# self.assertTrue(dates.date1 == new_date)
# def test_rollup_dates(self):
# from ietf.utils.test_data import make_test_data
# make_test_data()
# dates = TelechatDates.objects.all()[0]
# url = urlreverse('ietf.iesg.views.telechat_dates')
# login_testing_unauthorized(self, "secretary", url)
# old_date2 = dates.date2
# new_date = dates.date4 + timedelta(days=14)
# r = self.client.post(url, dict(rollup_dates="1"))
# self.assertEquals(r.status_code, 200)
# dates = TelechatDates.objects.all()[0]
# self.assertTrue(dates.date4 == new_date)
# self.assertTrue(dates.date1 == old_date2)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
#ManageTelechatDatesTestCase = ManageTelechatDatesTestCaseREDESIGN
del ManageTelechatDatesTestCase
class WorkingGroupActionsTestCase(TestCase):
perma_fixtures = ['base', 'wgactions']
def setUp(self):
super(self.__class__, self).setUp()
curdir = os.path.dirname(os.path.abspath(__file__))
self.evaldir = os.path.join(curdir, "testdir")
os.mkdir(self.evaldir)
src = os.path.join(curdir, "fixtures", "sieve-charter.txt")
shutil.copy(src, self.evaldir)
settings.IESG_WG_EVALUATION_DIR = self.evaldir
def tearDown(self):
super(self.__class__, self).tearDown()
shutil.rmtree(self.evaldir)
def test_working_group_actions(self):
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "klm", url)
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
for wga in WGAction.objects.all():
self.assertTrue(wga.group_acronym.name in r.content)
self.assertTrue('(sieve)' in r.content)
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 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_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_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)
class WorkingGroupActionsTestCaseREDESIGN(TestCase):
perma_fixtures = ['names']
def setUp(self):
super(self.__class__, self).setUp()
curdir = os.path.dirname(os.path.abspath(__file__))
self.evaldir = os.path.join(curdir, "tmp-testdir")
os.mkdir(self.evaldir)
src = os.path.join(curdir, "fixtures", "sieve-charter.txt")
shutil.copy(src, self.evaldir)
settings.IESG_WG_EVALUATION_DIR = self.evaldir
def tearDown(self):
super(self.__class__, self).tearDown()
shutil.rmtree(self.evaldir)
def test_working_group_actions(self):
from ietf.utils.test_data import make_test_data
make_test_data()
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "secretary", url)
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
for wga in WGAction.objects.all():
self.assertTrue(wga.group_acronym.name in r.content)
self.assertTrue('(sieve)' in r.content)
def test_delete_wgaction(self):
from ietf.utils.test_data import make_test_data
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)
r = self.client.post(url, dict(delete="1"))
self.assertEquals(r.status_code, 302)
self.assertTrue(not WGAction.objects.filter(pk=wga.pk))
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_add_possible_wg(self):
from ietf.utils.test_data import make_test_data
from ietf.person.models import Person
from ietf.group.models import Group
make_test_data()
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "secretary", url)
r = self.client.post(url, dict(add="1",
filename='sieve-charter.txt'))
self.assertEquals(r.status_code, 302)
# now we got back a URL we can use for adding, but first make
# sure we got a proposed group with the acronym
group = Group.objects.create(
name="Sieve test test",
acronym="sieve",
state_id="proposed",
type_id="wg",
parent=None
)
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 = TelechatDate.objects.active()
token_name = Person.objects.get(name="Ad No1").plain_name()
r = self.client.post(add_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)
self.assertEquals(wgas_before + 1, WGAction.objects.all().count())
def test_delete_possible_wg(self):
from ietf.utils.test_data import make_test_data
make_test_data()
url = urlreverse('iesg_working_group_actions')
login_testing_unauthorized(self, "secretary", 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)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
WorkingGroupActionsTestCase = WorkingGroupActionsTestCaseREDESIGN
class IesgUrlTestCase(SimpleUrlTestCase):
def testUrls(self):
self.doTestUrls(__file__)
def doCanonicalize(self, url, content):
if url.startswith("/feed/"):
return canonicalize_feed(content)
else:
return content
#Tests added since database redesign that speak the new clases
from ietf.doc.models import Document,TelechatDocEvent,State
from ietf.group.models import Person
class DeferUndeferTestCase(TestCase):
perma_fixtures = ['names']
def helper_test_defer(self,name):
doc = Document.objects.get(name=name)
@ -571,5 +504,24 @@ class DeferUndeferTestCase(TestCase):
# when charters support being deferred, be sure to test them here
def setUp(self):
from ietf.utils.test_data import make_test_data
make_test_data()
class IESGDiscussesTests(TestCase):
def test_feed(self):
draft = make_test_data()
draft.set_state(State.objects.get(type="draft-iesg", slug="iesg-eva"))
pos = BallotPositionDocEvent()
pos.ballot = draft.latest_event(BallotDocEvent, type="created_ballot")
pos.pos_id = "discuss"
pos.type = "changed_ballot_position"
pos.doc = draft
pos.ad = pos.by = Person.objects.get(user__username="ad")
pos.save()
r = self.client.get(urlreverse("ietf.iesg.views.discusses"))
self.assertEquals(r.status_code, 200)
self.assertTrue(draft.name in r.content)
self.assertTrue(pos.ad.plain_name() in r.content)

24
ietf/iesg/testurl.list
View file

@ -1,24 +0,0 @@
301 /iesg/telechat/
301 /iesg/telechat/y/2007/
301 /iesg/telechat/y/2007/apr/
301 /iesg/telechat/354/
200 /iesg/agenda/
200 /iesg/agenda/agenda.txt
200 /iesg/agenda/scribe_template.html
200 /iesg/agenda/documents.txt
200 /iesg/agenda/documents/
200 /iesg/discusses/
302 /iesg/agenda/moderator_package.html
302 /iesg/agenda/agenda_package.txt
200 /iesg/_test/moderator_package.html
200 /iesg/_test/agenda_package.txt
200 /iesg/ann/ind/
200 /iesg/ann/new/
# This takes ~ 300s:
#200 /iesg/ann/prev/
200 /feed/iesg-agenda/

50
ietf/iesg/urls.py
View file

@ -35,41 +35,23 @@
from django.conf.urls.defaults import patterns, url
from django.conf import settings
from ietf.iesg import views
from ietf.idtracker.models import BallotInfo
queryset_ann = BallotInfo.objects.all()
urlpatterns = patterns('',
(r'^telechat/.*$', 'django.views.generic.simple.redirect_to', { 'url': 'http://www.ietf.org/iesg/minutes.html' })
)
(r'^telechat/.*$', 'django.views.generic.simple.redirect_to', { 'url': 'http://www.ietf.org/iesg/minutes.html' }),
(r'^ann/(?:ind|new|prev)/$', 'django.views.generic.simple.redirect_to', { 'url': "/iesg/decisions/", 'permanent': True }),
(r'^telechatdates/$', 'django.views.generic.simple.redirect_to', { 'url': '/admin/iesg/telechatdate/' }),
urlpatterns += patterns('django.views.generic.list_detail',
(r'^ann/(?P<object_id>\d+)/$', 'object_detail', { 'queryset': queryset_ann, 'template_name':"iesg/ballotinfo_detail.html" }),
(r'^decisions/(?:(?P<year>[0-9]{4})/)?$', views.review_decisions),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?$', views.agenda),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?agenda.txt$', views.agenda_txt),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?agenda.json$', views.agenda_json),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?scribe_template.html$', views.agenda_scribe_template),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?moderator_package.html$', views.agenda_moderator_package),
(r'^agenda/(?:(?P<date>\d{4}-\d{2}-\d{2})/)?agenda_package.txt$', views.agenda_package),
(r'^agenda/documents.txt$', views.agenda_documents_txt),
(r'^agenda/documents/$', views.agenda_documents),
(r'^agenda/telechat-(?:(?P<date>\d{4}-\d{2}-\d{2})-)?docs.tgz', views.telechat_docs_tarfile),
(r'^discusses/$', views.discusses),
(r'^milestones/$', views.milestones_needing_review),
)
urlpatterns += patterns('',
(r'^ann/ind/$',views.inddocs),
(r'^ann/(?P<cat>[^/]+)/$',views.wgdocs),
(r'^agenda/$', views.agenda),
(r'^agenda/agenda.txt$', views.agenda_txt),
(r'^agenda/agenda.json$', views.agenda_json),
(r'^agenda/scribe_template.html$', views.agenda_scribe_template),
(r'^agenda/moderator_package.html$', views.agenda_moderator_package),
(r'^agenda/agenda_package.txt$', views.agenda_package),
(r'^agenda/documents.txt$', views.agenda_documents_txt),
(r'^agenda/documents/$', views.agenda_documents),
(r'^agenda/telechat-(?P<year>\d+)-(?P<month>\d+)-(?P<day>\d+)-docs.tgz', views.telechat_docs_tarfile),
(r'^discusses/$', views.discusses),
(r'^milestones', views.milestones_needing_review),
(r'^telechatdates/$', 'django.views.generic.simple.redirect_to', { 'url': '/admin/iesg/telechatdate/' }),
url(r'^wgactions/$', views.working_group_actions, name="iesg_working_group_actions"),
url(r'^wgactions/add/$', views.edit_working_group_action, { 'wga_id': None }, name="iesg_add_working_group_action"),
url(r'^wgactions/(?P<wga_id>\d+)/$', views.edit_working_group_action, name="iesg_edit_working_group_action"),
)
if settings.SERVER_MODE != 'production':
urlpatterns += patterns('',
(r'^agenda/(?P<date>\d{4}-\d\d-\d\d)/$', views.agenda),
(r'^_test/moderator_package.html$', views.agenda_moderator_package_test),
(r'^_test/agenda_package.txt', views.agenda_package_test),
)

948
ietf/iesg/views.py
View file

File diff suppressed because it is too large Load diff

1
ietf/ietfworkflows/.gitignore vendored
View file

@ -1 +0,0 @@
/*.pyc

18
ietf/ietfworkflows/__init__.py
View file

@ -1,18 +0,0 @@
# coding: latin-1
from types import ModuleType
import urls, models, views, forms, accounts
# These people will be sent a stack trace if there's an uncaught exception in
# code any of the modules imported above:
DEBUG_EMAILS = [
('Emilio A. Sánchez', 'esanchez@yaco.es'),
]
for k in locals().keys():
m = locals()[k]
if isinstance(m, ModuleType):
if hasattr(m, "DEBUG_EMAILS"):
DEBUG_EMAILS += list(getattr(m, "DEBUG_EMAILS"))
setattr(m, "DEBUG_EMAILS", DEBUG_EMAILS)

132
ietf/ietfworkflows/accounts.py
View file

@ -1,132 +0,0 @@
from django.conf import settings
from django.db.models import Q
from ietf.ietfworkflows.streams import get_streamed_draft
from ietf.group.models import Role
def get_person_for_user(user):
try:
return user.get_profile().person()
except:
return None
def is_secretariat(user):
if not user or not user.is_authenticated():
return False
return bool(user.groups.filter(name='Secretariat'))
def is_wgchair(person):
return bool(person.wgchair_set.all())
def is_wgchairREDESIGN(person):
return bool(Role.objects.filter(name="chair", group__type="wg", group__state="active", person=person))
def is_rgchairREDESIGN(person):
return bool(Role.objects.filter(name="chair", group__type="rg", group__state="active", person=person))
def is_wgdelegate(person):
return bool(person.wgdelegate_set.all())
def is_wgdelegateREDESIGN(person):
return bool(Role.objects.filter(name="delegate", group__type="wg", group__state="active", person=person))
def is_rgdelegateREDESIGN(person):
return bool(Role.objects.filter(name="delegate", group__type="rg", group__state="active", person=person))
def is_delegate_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_delegate(person)
def is_delegate_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
return user.is_authenticated() and bool(Role.objects.filter(group__acronym=stream.slug, name="delegate", person__user=user))
def is_chair_of_stream(user, stream):
if is_secretariat(user):
return True
person = get_person_for_user(user)
return stream.check_chair(person)
def is_chair_of_streamREDESIGN(user, stream):
if is_secretariat(user):
return True
if isinstance(user, basestring):
return False
return user.is_authenticated() and bool(Role.objects.filter(group__acronym=stream.slug, name="chair", person__user=user))
def is_authorized_in_draft_stream(user, draft):
if is_secretariat(user):
return True
person = get_person_for_user(user)
if not person:
return False
streamed = get_streamed_draft(draft)
if not streamed or not streamed.stream:
return False
# Check if the person is chair of the stream
if is_chair_of_stream(user, streamed.stream):
return True
# Check if the person is delegate of the stream
if is_delegate_of_stream(user, streamed.stream):
return True
# Check if the person is chair of the related group
chairs = streamed.stream.get_chairs_for_document(draft)
if chairs and person in [i.person for i in chairs]:
return True
# Check if the person is authorized by a delegate system
delegates = streamed.stream.get_delegates_for_document(draft)
return bool(person in delegates)
def is_authorized_in_draft_streamREDESIGN(user, draft):
if is_secretariat(user):
return True
from ietf.doc.models import Document
if not super(Document, draft).stream:
return False
# must be a chair or delegate of the stream group (or draft group)
group_req = Q(group__acronym=super(Document, draft).stream.slug)
if draft.group and super(Document, draft).stream.slug in ["ietf", "irtf"]:
group_req |= Q(group=draft.group)
return user.is_authenticated() and bool(Role.objects.filter(name__in=("chair", "secr", "delegate"), person__user=user).filter(group_req))
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.liaisons.accounts import is_secretariat, get_person_for_user
is_wgdelegate = is_wgdelegateREDESIGN
is_wgchair = is_wgchairREDESIGN
is_rgdelegate = is_rgdelegateREDESIGN
is_rgchair = is_rgchairREDESIGN
is_chair_of_stream = is_chair_of_streamREDESIGN
is_delegate_of_stream = is_delegate_of_streamREDESIGN
is_authorized_in_draft_stream = is_authorized_in_draft_streamREDESIGN
def can_edit_state(user, draft):
return (is_secretariat(user) or
is_authorized_in_draft_stream(user, draft))
def can_edit_stream(user, draft):
return is_secretariat(user)
def can_adopt(user, draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES and (not draft.stream_id or draft.stream_id in ["ietf", "irtf"]) and draft.group.type_id == "individ":
person = get_person_for_user(user)
if not person:
return False
return is_wgchair(person) or is_rgchair(person) or is_wgdelegate(person) or is_rgdelegate() or is_secretariat(user)
else:
return is_secretariat(user)

13
ietf/ietfworkflows/constants.py
View file

@ -1,13 +0,0 @@
# Required states
CALL_FOR_ADOPTION = 'Call For Adoption By WG Issued'
WG_DOCUMENT = 'WG Document'
SUBMITTED_TO_IESG = 'Submitted to IESG for Publication'
REQUIRED_STATES = (
CALL_FOR_ADOPTION,
WG_DOCUMENT,
SUBMITTED_TO_IESG,
)
# IETF Stream
IETF_STREAM = 'IETF'

1
ietf/ietfworkflows/fixtures/.gitignore vendored
View file

@ -1 +0,0 @@
/*.pyc

686
ietf/ietfworkflows/fixtures/initial_data.xml
View file

@ -1,686 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<django-objects version="1.0">
<object pk="1" model="workflows.workflow">
<field type="CharField" name="name">Default WG Workflow</field>
<field to="workflows.state" name="initial_state" rel="ManyToOneRel">11</field>
</object>
<object pk="2" model="workflows.workflow">
<field type="CharField" name="name">IAB Workflow</field>
<field to="workflows.state" name="initial_state" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="3" model="workflows.workflow">
<field type="CharField" name="name">IRTF Workflow</field>
<field to="workflows.state" name="initial_state" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="4" model="workflows.workflow">
<field type="CharField" name="name">ISE Workflow</field>
<field to="workflows.state" name="initial_state" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="32" model="workflows.state">
<field type="CharField" name="name">Active IAB Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="42" model="workflows.state">
<field type="CharField" name="name">Active RG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="12" model="workflows.state">
<field type="CharField" name="name">Adopted by a WG</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="12"></object></field>
</object>
<object pk="13" model="workflows.state">
<field type="CharField" name="name">Adopted for WG Info Only</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="36" model="workflows.state">
<field type="CharField" name="name">Approved by IAB, To Be Sent to RFC Editor</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="47" model="workflows.state">
<field type="CharField" name="name">Awaiting IRSG Reviews</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="11" model="workflows.state">
<field type="CharField" name="name">Call For Adoption By WG Issued</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="10"></object><object pk="11"></object></field>
</object>
<object pk="31" model="workflows.state">
<field type="CharField" name="name">Candidate IAB Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="41" model="workflows.state">
<field type="CharField" name="name">Candidate RG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="35" model="workflows.state">
<field type="CharField" name="name">Community Review</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="40" model="workflows.state">
<field type="CharField" name="name">Dead IAB Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="53" model="workflows.state">
<field type="CharField" name="name">Dead IRTF Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="16" model="workflows.state">
<field type="CharField" name="name">Dead WG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="12"></object></field>
</object>
<object pk="51" model="workflows.state">
<field type="CharField" name="name">Document on Hold Based On IESG Request</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="62" model="workflows.state">
<field type="CharField" name="name">Document on Hold Based On IESG Request</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="55" model="workflows.state">
<field type="CharField" name="name">Finding Reviewers</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="34" model="workflows.state">
<field type="CharField" name="name">IAB Review</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="49" model="workflows.state">
<field type="CharField" name="name">In IESG Review</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="58" model="workflows.state">
<field type="CharField" name="name">In IESG Review</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="48" model="workflows.state">
<field type="CharField" name="name">In IRSG Poll</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="56" model="workflows.state">
<field type="CharField" name="name">In ISE Review</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="44" model="workflows.state">
<field type="CharField" name="name">In RG Last Call</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="17" model="workflows.state">
<field type="CharField" name="name">In WG Last Call</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="12"></object><object pk="17"></object><object pk="18"></object></field>
</object>
<object pk="61" model="workflows.state">
<field type="CharField" name="name">No Longer In Independent Submission Stream</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="33" model="workflows.state">
<field type="CharField" name="name">Parked IAB Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="43" model="workflows.state">
<field type="CharField" name="name">Parked RG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="15" model="workflows.state">
<field type="CharField" name="name">Parked WG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="12"></object></field>
</object>
<object pk="57" model="workflows.state">
<field type="CharField" name="name">Response to Review Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="37" model="workflows.state">
<field type="CharField" name="name">Sent to a Different Organization for Publication</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="38" model="workflows.state">
<field type="CharField" name="name">Sent to the RFC Editor</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="59" model="workflows.state">
<field type="CharField" name="name">Sent to the RFC Editor</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="50" model="workflows.state">
<field type="CharField" name="name">Sent to the RFC Editor</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="54" model="workflows.state">
<field type="CharField" name="name">Submission Received</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="20" model="workflows.state">
<field type="CharField" name="name">Submitted to IESG for Publication</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="12"></object></field>
</object>
<object pk="45" model="workflows.state">
<field type="CharField" name="name">Waiting for Document Shepherd</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="46" model="workflows.state">
<field type="CharField" name="name">Waiting for IRTF Chair</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"></field>
</object>
<object pk="18" model="workflows.state">
<field type="CharField" name="name">Waiting for WG Chair Go-Ahead</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="16"></object><object pk="17"></object></field>
</object>
<object pk="19" model="workflows.state">
<field type="CharField" name="name">WG Consensus: Waiting for Write-Up</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="15"></object></field>
</object>
<object pk="14" model="workflows.state">
<field type="CharField" name="name">WG Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.transition" name="transitions" rel="ManyToManyRel"><object pk="13"></object><object pk="14"></object><object pk="16"></object><object pk="17"></object></field>
</object>
<object pk="18" model="workflows.transition">
<field type="CharField" name="name">Wait for go-ahead</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">18</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="17" model="workflows.transition">
<field type="CharField" name="name">Reach consensus</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">19</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="10" model="workflows.transition">
<field type="CharField" name="name">Adopt</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">12</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="11" model="workflows.transition">
<field type="CharField" name="name">Adopt for WG info only</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">13</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="12" model="workflows.transition">
<field type="CharField" name="name">Develop</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">14</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="13" model="workflows.transition">
<field type="CharField" name="name">Park</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">15</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="14" model="workflows.transition">
<field type="CharField" name="name">Die</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">16</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="15" model="workflows.transition">
<field type="CharField" name="name">Submit to IESG</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">20</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="16" model="workflows.transition">
<field type="CharField" name="name">Raise last call</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="workflows.state" name="destination" rel="ManyToOneRel">17</field>
<field type="CharField" name="condition"></field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="31" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="29" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Shepherd Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="30" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Waiting for Dependency on Other Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="26" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="27" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Document Shepherd Followup</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="28" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Editor Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="25" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Awaiting Reviews</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="24" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Waiting for Partner Feedback</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="11" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Other - see Comment Log</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="23" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Editor Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">2</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="10" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Doc Shepherd Follow-Up Underway</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="9" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed - Issue raised by IESG</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="1" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Awaiting Expert Review/Resolution of Issues Raised</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="2" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Awaiting External Review/Resolution of Issues Raised</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="3" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Awaiting Merge with Other Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="4" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Author or Editor Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="5" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Waiting for Referenced Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="8" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed - Issue raised by AD</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="7" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed - Issue raised by WGLC</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="6" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Waiting for Referencing Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">1</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="32" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">IESG Review Completed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">3</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="33" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Waiting for Dependency on Other Document</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="34" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Awaiting Reviews</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="35" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">Revised I-D Needed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="36" model="ietfworkflows.annotationtag">
<field type="CharField" name="name">IESG Review Completed</field>
<field to="workflows.workflow" name="workflow" rel="ManyToOneRel">4</field>
<field to="permissions.permission" name="permission" rel="ManyToOneRel"><None></None></field>
</object>
<object pk="1" model="ietfworkflows.wgworkflow">
<field to="workflows.state" name="selected_states" rel="ManyToManyRel"></field>
<field to="ietfworkflows.annotationtag" name="selected_tags" rel="ManyToManyRel"></field>
</object>
<object pk="2" model="ietfworkflows.wgworkflow">
<field to="workflows.state" name="selected_states" rel="ManyToManyRel"></field>
<field to="ietfworkflows.annotationtag" name="selected_tags" rel="ManyToManyRel"></field>
</object>
<object pk="3" model="ietfworkflows.wgworkflow">
<field to="workflows.state" name="selected_states" rel="ManyToManyRel"></field>
<field to="ietfworkflows.annotationtag" name="selected_tags" rel="ManyToManyRel"></field>
</object>
<object pk="4" model="ietfworkflows.wgworkflow">
<field to="workflows.state" name="selected_states" rel="ManyToManyRel"></field>
<field to="ietfworkflows.annotationtag" name="selected_tags" rel="ManyToManyRel"></field>
</object>
<object pk="1" model="ietfworkflows.stream">
<field type="CharField" name="name">IETF</field>
<field type="CharField" name="document_group_attribute">group.ietfwg</field>
<field type="CharField" name="group_chair_attribute">chairs</field>
<field to="ietfworkflows.wgworkflow" name="workflow" rel="ManyToOneRel">1</field>
</object>
<object pk="2" model="ietfworkflows.stream">
<field type="CharField" name="name">IAB</field>
<field type="CharField" name="document_group_attribute"></field>
<field type="CharField" name="group_chair_attribute"></field>
<field to="ietfworkflows.wgworkflow" name="workflow" rel="ManyToOneRel">2</field>
</object>
<object pk="3" model="ietfworkflows.stream">
<field type="CharField" name="name">IRTF</field>
<field type="CharField" name="document_group_attribute"></field>
<field type="CharField" name="group_chair_attribute"></field>
<field to="ietfworkflows.wgworkflow" name="workflow" rel="ManyToOneRel">3</field>
</object>
<object pk="4" model="ietfworkflows.stream">
<field type="CharField" name="name">ISE</field>
<field type="CharField" name="document_group_attribute"></field>
<field type="CharField" name="group_chair_attribute"></field>
<field to="ietfworkflows.wgworkflow" name="workflow" rel="ManyToOneRel">4</field>
</object>
<object pk="1" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">11</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.1" target="_blank"&gt;4.2.1. Call for Adoption by WG Issued&lt;/a&gt;
The "Call for Adoption by WG Issued" state should be used to indicate
when an I-D is being considered for adoption by an IETF WG. An I-D
that is in this state is actively being considered for adoption and
has not yet achieved consensus, preference, or selection in the WG.
This state may be used to describe an I-D that someone has asked a WG
to consider for adoption, if the WG Chair has agreed with the
request. This state may also be used to identify an I-D that a WG
Chair asked an author to write specifically for consideration as a
candidate WG item [WGDTSPEC], and/or an I-D that is listed as a
'candidate draft' in the WG's charter.
Under normal conditions, it should not be possible for an I-D to be
in the "Call for Adoption by WG Issued" state in more than one
working group at the same time. This said, it is not uncommon for
authors to "shop" their I-Ds to more than one WG at a time, with the
hope of getting their documents adopted somewhere.
After this state is implemented in the Datatracker, an I-D that is in
the "Call for Adoption by WG Issued" state will not be able to be
"shopped" to any other WG without the consent of the WG Chairs and
the responsible ADs impacted by the shopping.
Note that Figure 1 includes an arc leading from this state to outside
of the WG state machine. This illustrates that some I-Ds that are
considered do not get adopted as WG drafts. An I-D that is not
adopted as a WG draft will transition out of the WG state machine and
revert back to having no stream-specific state; however, the status
change history log of the I-D will record that the I-D was previously
in the "Call for Adoption by WG Issued" state.
</field>
<field type="PositiveIntegerField" name="order">1</field>
</object>
<object pk="2" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">12</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.2" target="_blank"&gt;4.2.2. Adopted by a WG&lt;/a&gt;
The "Adopted by a WG" state describes an individual submission I-D
that an IETF WG has agreed to adopt as one of its WG drafts.
WG Chairs who use this state will be able to clearly indicate when
their WGs adopt individual submission I-Ds. This will facilitate the
Datatracker's ability to correctly capture "Replaces" information for
WG drafts and correct "Replaced by" information for individual
submission I-Ds that have been replaced by WG drafts.
This state is needed because the Datatracker uses the filename of an
I-D as a key to search its database for status information about the
I-D, and because the filename of a WG I-D is supposed to be different
from the filename of an individual submission I-D.
The filename of an individual submission I-D will typically be
formatted as 'draft-author-wgname-topic-nn'.
The filename of a WG document is supposed to be formatted as 'draft-
ietf-wgname-topic-nn'.
An individual I-D that is adopted by a WG may take weeks or months to
be resubmitted by the author as a new (version-00) WG draft. If the
"Adopted by a WG" state is not used, the Datatracker has no way to
determine that an I-D has been adopted until a new version of the I-D
is submitted to the WG by the author and until the I-D is approved
for posting by a WG Chair.
</field>
<field type="PositiveIntegerField" name="order">2</field>
</object>
<object pk="3" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">13</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.3" target="_blank"&gt;4.2.3. Adopted for WG Info Only&lt;/a&gt;
The "Adopted for WG Info Only" state describes a document that
contains useful information for the WG that adopted it, but the
document is not intended to be published as an RFC. The WG will not
actively develop the contents of the I-D or progress it for
publication as an RFC. The only purpose of the I-D is to provide
information for internal use by the WG.
</field>
<field type="PositiveIntegerField" name="order">3</field>
</object>
<object pk="4" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">14</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.4" target="_blank"&gt;4.2.4. WG Document&lt;/a&gt;
The "WG Document" state describes an I-D that has been adopted by an
IETF WG and is being actively developed.
A WG Chair may transition an I-D into the "WG Document" state at any
time as long as the I-D is not being considered or developed in any
other WG.
Alternatively, WG Chairs may rely upon new functionality to be added
to the Datatracker to automatically move version-00 drafts into the
"WG Document" state as described in Section 4.1.
Under normal conditions, it should not be possible for an I-D to be
in the "WG Document" state in more than one WG at a time. This said,
I-Ds may be transferred from one WG to another with the consent of
the WG Chairs and the responsible ADs.
</field>
<field type="PositiveIntegerField" name="order">4</field>
</object>
<object pk="5" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">15</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.5" target="_blank"&gt;4.2.5. Parked WG Document&lt;/a&gt;
A "Parked WG Document" is an I-D that has lost its author or editor,
is waiting for another document to be written or for a review to be
completed, or cannot be progressed by the working group for some
other reason.
Some of the annotation tags described in Section 4.3 may be used in
conjunction with this state to indicate why an I-D has been parked,
and/or what may need to happen for the I-D to be un-parked.
Parking a WG draft will not prevent it from expiring; however, this
state can be used to indicate why the I-D has stopped progressing in
the WG.
A "Parked WG Document" that is not expired may be transferred from
one WG to another with the consent of the WG Chairs and the
responsible ADs.
</field>
<field type="PositiveIntegerField" name="order">5</field>
</object>
<object pk="6" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">16</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.6" target="_blank"&gt;4.2.6. Dead WG Document&lt;/a&gt;
A "Dead WG Document" is an I-D that has been abandoned. Note that
'Dead' is not always a final state for a WG I-D. If consensus is
subsequently achieved, a "Dead WG Document" may be resurrected. A
"Dead WG Document" that is not resurrected will eventually expire.
Note that an I-D that is declared to be "Dead" in one WG and that is
not expired may be transferred to a non-dead state in another WG with
the consent of the WG Chairs and the responsible ADs.
</field>
<field type="PositiveIntegerField" name="order">6</field>
</object>
<object pk="7" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">17</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.7" target="_blank"&gt;4.2.7. In WG Last Call&lt;/a&gt;
A document "In WG Last Call" is an I-D for which a WG Last Call
(WGLC) has been issued and is in progress.
Note that conducting a WGLC is an optional part of the IETF WG
process, per Section 7.4 of RFC 2418 [RFC2418].
If a WG Chair decides to conduct a WGLC on an I-D, the "In WG Last
Call" state can be used to track the progress of the WGLC. The Chair
may configure the Datatracker to send a WGLC message to one or more
mailing lists when the Chair moves the I-D into this state. The WG
Chair may also be able to select a different set of mailing lists for
a different document undergoing a WGLC; some documents may deserve
coordination with other WGs.
A WG I-D in this state should remain "In WG Last Call" until the WG
Chair moves it to another state. The WG Chair may configure the
Datatracker to send an e-mail after a specified period of time to
remind or 'nudge' the Chair to conclude the WGLC and to determine the
next state for the document.
It is possible for one WGLC to lead into another WGLC for the same
document. For example, an I-D that completed a WGLC as an
"Informational" document may need another WGLC if a decision is taken
to convert the I-D into a Standards Track document.
</field>
<field type="PositiveIntegerField" name="order">7</field>
</object>
<object pk="8" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">18</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.8" target="_blank"&gt;4.2.8. Waiting for WG Chair Go-Ahead&lt;/a&gt;
A WG Chair may wish to place an I-D that receives a lot of comments
during a WGLC into the "Waiting for WG Chair Go-Ahead" state. This
state describes an I-D that has undergone a WGLC; however, the Chair
is not yet ready to call consensus on the document.
If comments from the WGLC need to be responded to, or a revision to
the I-D is needed, the Chair may place an I-D into this state until
all of the WGLC comments are adequately addressed and the (possibly
revised) document is in the I-D repository.
</field>
<field type="PositiveIntegerField" name="order">8</field>
</object>
<object pk="9" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">19</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.9" target="_blank"&gt;4.2.9. WG Consensus: Waiting for Writeup&lt;/a&gt;
A document in the "WG Consensus: Waiting for Writeup" state has
essentially completed its development within the working group, and
is nearly ready to be sent to the IESG for publication. The last
thing to be done is the preparation of a protocol writeup by a
Document Shepherd. The IESG requires that a document shepherd
writeup be completed before publication of the I-D is requested. The
IETF document shepherding process and the role of a WG Document
Shepherd is described in RFC 4858 [RFC4858]
A WG Chair may call consensus on an I-D without a formal WGLC and
transition an I-D that was in the "WG Document" state directly into
this state.
The name of this state includes the words "Waiting for Writeup"
because a good document shepherd writeup takes time to prepare.
</field>
<field type="PositiveIntegerField" name="order">9</field>
</object>
<object pk="10" model="ietfworkflows.statedescription">
<field to="workflows.state" name="state" rel="ManyToOneRel">20</field>
<field type="TextField" name="definition">&lt;a href="http://tools.ietf.org/html/rfc6174#section-4.2.10" target="_blank"&gt;4.2.10. Submitted to IESG for Publication&lt;/a&gt;
This state describes a WG document that has been submitted to the
IESG for publication and that has not been sent back to the working
group for revision.
An I-D in this state may be under review by the IESG, it may have
been approved and be in the RFC Editor's queue, or it may have been
published as an RFC. Other possibilities exist too. The document
may be "Dead" (in the IESG state machine) or in a "Do Not Publish"
state.
</field>
<field type="PositiveIntegerField" name="order">10</field>
</object>
</django-objects>

363
ietf/ietfworkflows/forms.py
View file

@ -1,363 +0,0 @@
import datetime
from django.conf import settings
from django import forms
from django.template.loader import render_to_string
from workflows.models import State
from workflows.utils import set_workflow_for_object
from ietf.idtracker.models import PersonOrOrgInfo, IETFWG, InternetDraft
from ietf.wgchairs.accounts import get_person_for_user
from ietf.ietfworkflows.models import Stream, StreamDelegate
from ietf.ietfworkflows.utils import (get_workflow_for_draft, get_workflow_for_wg,
get_state_for_draft, get_state_by_name,
update_state, FOLLOWUP_TAG,
get_annotation_tags_for_draft,
update_tags, update_stream)
from ietf.ietfworkflows.accounts import is_secretariat
from ietf.ietfworkflows.streams import (get_stream_from_draft, get_streamed_draft,
get_stream_by_name, set_stream_for_draft)
from ietf.ietfworkflows.constants import CALL_FOR_ADOPTION, IETF_STREAM
from ietf.doc.utils import get_tags_for_stream_id
from ietf.doc.models import save_document_in_history, DocEvent, Document
from ietf.name.models import DocTagName, StreamName, RoleName
from ietf.group.models import Group, GroupStateTransitions, Role
from ietf.group.utils import save_group_in_history
from ietf.person.models import Person, Email
class StreamDraftForm(forms.Form):
can_cancel = False
template = None
def __init__(self, *args, **kwargs):
self.draft = kwargs.pop('draft', None)
self.user = kwargs.pop('user', None)
self.person = get_person_for_user(self.user)
self.workflow = get_workflow_for_draft(self.draft)
self.message = {}
super(StreamDraftForm, self).__init__(*args, **kwargs)
def get_message(self):
return self.message
def set_message(self, msg_type, msg_value):
self.message = {'type': msg_type,
'value': msg_value,
}
def __unicode__(self):
return render_to_string(self.template, {'form': self})
class NoWorkflowStateForm(StreamDraftForm):
comment = forms.CharField(widget=forms.Textarea, required=False)
weeks = forms.IntegerField(required=False)
group = forms.ChoiceField(required=False)
template = 'ietfworkflows/noworkflow_state_form.html'
def __init__(self, *args, **kwargs):
super(NoWorkflowStateForm, self).__init__(*args, **kwargs)
self.groups = None
if is_secretariat(self.user):
groups = IETFWG.objects.all().order_by('group_acronym__acronym')
else:
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
groups = IETFWG.objects.filter(type__in=["wg", "rg"], state="active", role__name__in=("chair", "secr", "delegate"), role__person__user=self.user).order_by('acronym').distinct()
else:
groups = set([i.group_acronym for i in self.person.wgchair_set.all()]).union(set([i.wg for i in self.person.wgdelegate_set.all()]))
groups = list(groups)
groups.sort(lambda x, y: cmp(x.group_acronym.acronym, y.group_acronym.acronym))
self.groups = groups
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
self.fields['group'].choices = [(i.pk, '%s - %s' % (i.acronym, i.name)) for i in self.groups]
else:
self.fields['group'].choices = [(i.pk, '%s - %s' % (i.group_acronym.acronym, i.group_acronym.name)) for i in self.groups]
def save(self):
comment = self.cleaned_data.get('comment').strip()
weeks = self.cleaned_data.get('weeks')
group = IETFWG.objects.get(pk=self.cleaned_data.get('group'))
estimated_date = None
if weeks:
now = datetime.date.today()
estimated_date = now + datetime.timedelta(weeks=weeks)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
# do changes on real Document object instead of proxy to avoid trouble
doc = Document.objects.get(pk=self.draft.pk)
save_document_in_history(doc)
doc.time = datetime.datetime.now()
if group.type.slug == "rg":
new_stream = StreamName.objects.get(slug="irtf")
else:
new_stream = StreamName.objects.get(slug="ietf")
if doc.stream != new_stream:
e = DocEvent(type="changed_stream")
e.time = doc.time
e.by = self.user.get_profile()
e.doc = doc
e.desc = u"Changed to <b>%s</b>" % new_stream.name
if doc.stream:
e.desc += u" from %s" % doc.stream.name
e.save()
doc.stream = new_stream
if doc.group.pk != group.pk:
e = DocEvent(type="changed_group")
e.time = doc.time
e.by = self.user.get_profile()
e.doc = doc
e.desc = u"Changed group to <b>%s (%s)</b>" % (group.name, group.acronym.upper())
if doc.group.type_id != "individ":
e.desc += " from %s (%s)" % (doc.group.name, doc.group.acronym)
e.save()
doc.group_id = group.pk
doc.save()
self.draft = InternetDraft.objects.get(pk=doc.pk) # make sure proxy object is updated
else:
workflow = get_workflow_for_wg(wg)
set_workflow_for_object(self.draft, workflow)
stream = get_stream_by_name(IETF_STREAM)
streamed = get_streamed_draft(self.draft)
if not streamed:
set_stream_for_draft(self.draft, stream)
streamed = get_streamed_draft(self.draft)
streamed.stream = stream
streamed.group = wg
streamed.save()
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.doc.models import State
if self.draft.stream_id == "irtf":
to_state = State.objects.get(used=True, slug="active", type="draft-stream-irtf")
else:
to_state = State.objects.get(used=True, slug="c-adopt", type="draft-stream-%s" % self.draft.stream_id)
else:
to_state = get_state_by_name(CALL_FOR_ADOPTION)
update_state(self.request, self.draft,
comment=comment,
person=self.person,
to_state=to_state,
added_tags=[],
removed_tags=[],
estimated_date=estimated_date)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if comment:
e = DocEvent(type="added_comment")
e.time = self.draft.time
e.by = self.person
e.doc_id = self.draft.pk
e.desc = comment
e.save()
class DraftTagsStateForm(StreamDraftForm):
new_state = forms.ChoiceField(label='State')
weeks = forms.IntegerField(label='Expected weeks in state',required=False)
comment = forms.CharField(widget=forms.Textarea, required=False)
tags = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple, required=False)
template = 'ietfworkflows/state_form.html'
def __init__(self, *args, **kwargs):
super(DraftTagsStateForm, self).__init__(*args, **kwargs)
self.state = get_state_for_draft(self.draft)
self.fields['new_state'].choices = self.get_states()
self.fields['new_state'].initial = self.state.pk if self.state else None
if self.draft.stream_id == 'ietf':
self.fields['new_state'].help_text = "Only select 'Submitted to IESG for Publication' to correct errors. Use the document's main page to request publication."
if self.is_bound:
for key, value in self.data.items():
if key.startswith('transition_'):
new_state = self.get_new_state(key)
if new_state:
self.data = self.data.copy()
self.data.update({'new_state': new_state.id})
if key.startswith('new_state_'): # hack to get value from submit buttons
self.data = self.data.copy()
self.data['new_state'] = key.replace('new_state_', '')
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
possible_tags = get_tags_for_stream_id(self.draft.stream_id)
if self.draft.stream_id == "ietf" and self.draft.group:
unused_tags = self.draft.group.unused_tags.values_list("slug", flat=True)
possible_tags = [t for t in possible_tags if t not in unused_tags]
self.available_tags = DocTagName.objects.filter(slug__in=possible_tags)
self.tags = self.draft.tags.filter(slug__in=possible_tags)
else:
self.available_tags = self.workflow.get_tags()
self.tags = [i.annotation_tag for i in get_annotation_tags_for_draft(self.draft)]
self.fields['tags'].choices = [(i.pk, i.name) for i in self.available_tags]
self.fields['tags'].initial = [i.pk for i in self.tags]
def get_new_state(self, key):
transition_id = key.replace('transition_', '')
transition = self.get_transitions().filter(id=transition_id)
if transition:
return transition[0].destination
return None
def get_transitions(self):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return []
return self.state.transitions.filter(workflow=self.workflow)
def get_next_states(self):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if not self.draft.stream_id:
return []
from ietf.doc.models import State
state_type = "draft-stream-%s" % self.draft.stream_id
s = self.draft.get_state(state_type)
next_states = []
if s:
next_states = s.next_states.all()
if self.draft.stream_id == "ietf" and self.draft.group:
transitions = self.draft.group.groupstatetransitions_set.filter(state=s)
if transitions:
next_states = transitions[0].next_states.all()
else:
# return the initial state
states = State.objects.filter(used=True, type=state_type).order_by('order')
if states:
next_states = states[:1]
unused = []
if self.draft.group:
unused = self.draft.group.unused_states.values_list("pk", flat=True)
return [n for n in next_states if n.pk not in unused]
return []
def get_states(self):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
if not self.draft.stream_id:
return []
from ietf.doc.models import State
states = State.objects.filter(used=True, type="draft-stream-%s" % self.draft.stream_id)
if self.draft.stream_id == "ietf" and self.draft.group:
unused_states = self.draft.group.unused_states.values_list("pk", flat=True)
states = [s for s in states if s.pk not in unused_states]
return [(i.pk, i.name) for i in states]
return [(i.pk, i.name) for i in self.workflow.get_states()]
def save_tags(self,send_email=True):
comment = self.cleaned_data.get('comment')
new_tags = self.cleaned_data.get('tags')
set_tags = [tag for tag in self.available_tags if str(tag.pk) in new_tags and tag not in self.tags]
reset_tags = [tag for tag in self.available_tags if str(tag.pk) not in new_tags and tag in self.tags]
followup = bool([tag for tag in set_tags if tag.name == FOLLOWUP_TAG])
extra_notify = []
if followup:
try:
shepherd = self.draft.shepherd
if shepherd:
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
extra_notify = [shepherd.formatted_email()]
else:
extra_notify = ['%s <%s>' % shepherd.email()]
except PersonOrOrgInfo.DoesNotExist:
pass
if not set_tags and not reset_tags:
return
update_tags(self.request, self.draft,
comment=comment,
person=self.person,
set_tags=set_tags,
reset_tags=reset_tags,
extra_notify=extra_notify,
send_email=send_email)
def save_state(self):
comment = self.cleaned_data.get('comment')
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.doc.models import State
state = State.objects.get(pk=self.cleaned_data.get('new_state'))
old_state = self.draft.get_state("draft-stream-%s" % self.draft.stream_id)
if state==old_state:
self.save_tags()
return
self.save_tags(False)
new_tags = self.cleaned_data.get('tags')
set_tags = [tag for tag in self.available_tags if str(tag.pk) in new_tags and tag not in self.tags]
reset_tags = [tag for tag in self.available_tags if str(tag.pk) not in new_tags and tag in self.tags]
weeks = self.cleaned_data.get('weeks')
estimated_date = None
if weeks:
now = datetime.date.today()
estimated_date = now + datetime.timedelta(weeks=weeks)
update_state(self.request, self.draft,
comment=comment,
person=self.person,
to_state=state,
estimated_date=estimated_date,
added_tags=set_tags,
removed_tags=reset_tags)
def save(self):
self.save_state()
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
comment = self.cleaned_data.get('comment').strip()
if comment:
e = DocEvent(type="added_comment")
e.time = datetime.datetime.now()
e.by = self.person
e.doc_id = self.draft.pk
e.desc = comment
e.save()
class StreamDelegatesForm(forms.Form):
email = forms.EmailField()
def __init__(self, *args, **kwargs):
self.stream = kwargs.pop('stream')
super(StreamDelegatesForm, self).__init__(*args, **kwargs)
def get_person(self, email):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
persons = Person.objects.filter(email__address=email).distinct()
else:
persons = PersonOrOrgInfo.objects.filter(emailaddress__address=email).distinct()
if not persons:
return None
return persons[0]
def clean_email(self):
email = self.cleaned_data.get('email')
self.person = self.get_person(email)
if not self.person:
raise forms.ValidationError('There is no user with this email in the system')
return email
def save(self):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
stream_group = Group.objects.get(acronym=self.stream.slug)
save_group_in_history(stream_group)
Role.objects.get_or_create(person=self.person,
group=stream_group,
name=RoleName.objects.get(slug="delegate"),
email=Email.objects.get(address=self.cleaned_data.get('email')))
return
StreamDelegate.objects.get_or_create(
person=self.person,
stream=self.stream)

1
ietf/ietfworkflows/migrations/.gitignore vendored
View file

@ -1 +0,0 @@
/*.pyc

148
ietf/ietfworkflows/migrations/0001_initial.py
View file

@ -1,148 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding model 'WGWorkflow'
db.create_table('ietfworkflows_wgworkflow', (
('workflow_ptr', orm['ietfworkflows.WGWorkflow:workflow_ptr']),
))
db.send_create_signal('ietfworkflows', ['WGWorkflow'])
# Adding model 'ObjectWorkflowHistoryEntry'
db.create_table('ietfworkflows_objectworkflowhistoryentry', (
('id', orm['ietfworkflows.ObjectWorkflowHistoryEntry:id']),
('content_type', orm['ietfworkflows.ObjectWorkflowHistoryEntry:content_type']),
('content_id', orm['ietfworkflows.ObjectWorkflowHistoryEntry:content_id']),
('from_state', orm['ietfworkflows.ObjectWorkflowHistoryEntry:from_state']),
('to_state', orm['ietfworkflows.ObjectWorkflowHistoryEntry:to_state']),
('transition_date', orm['ietfworkflows.ObjectWorkflowHistoryEntry:transition_date']),
('comment', orm['ietfworkflows.ObjectWorkflowHistoryEntry:comment']),
))
db.send_create_signal('ietfworkflows', ['ObjectWorkflowHistoryEntry'])
# Adding model 'ObjectAnnotationTagHistoryEntry'
db.create_table('ietfworkflows_objectannotationtaghistoryentry', (
('id', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:id']),
('content_type', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:content_type']),
('content_id', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:content_id']),
('setted', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:setted']),
('unsetted', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:unsetted']),
('change_date', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:change_date']),
('comment', orm['ietfworkflows.ObjectAnnotationTagHistoryEntry:comment']),
))
db.send_create_signal('ietfworkflows', ['ObjectAnnotationTagHistoryEntry'])
# Adding model 'AnnotationTag'
db.create_table('ietfworkflows_annotationtag', (
('id', orm['ietfworkflows.AnnotationTag:id']),
('name', orm['ietfworkflows.AnnotationTag:name']),
('workflow', orm['ietfworkflows.AnnotationTag:workflow']),
('permission', orm['ietfworkflows.AnnotationTag:permission']),
))
db.send_create_signal('ietfworkflows', ['AnnotationTag'])
# Adding model 'AnnotationTagObjectRelation'
db.create_table('ietfworkflows_annotationtagobjectrelation', (
('id', orm['ietfworkflows.AnnotationTagObjectRelation:id']),
('content_type', orm['ietfworkflows.AnnotationTagObjectRelation:content_type']),
('content_id', orm['ietfworkflows.AnnotationTagObjectRelation:content_id']),
('annotation_tag', orm['ietfworkflows.AnnotationTagObjectRelation:annotation_tag']),
))
db.send_create_signal('ietfworkflows', ['AnnotationTagObjectRelation'])
def backwards(self, orm):
# Deleting model 'WGWorkflow'
db.delete_table('ietfworkflows_wgworkflow')
# Deleting model 'ObjectWorkflowHistoryEntry'
db.delete_table('ietfworkflows_objectworkflowhistoryentry')
# Deleting model 'ObjectAnnotationTagHistoryEntry'
db.delete_table('ietfworkflows_objectannotationtaghistoryentry')
# Deleting model 'AnnotationTag'
db.delete_table('ietfworkflows_annotationtag')
# Deleting model 'AnnotationTagObjectRelation'
db.delete_table('ietfworkflows_annotationtagobjectrelation')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.wgworkflow': {
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

107
ietf/ietfworkflows/migrations/0002_add_selected_states_and_tags.py
View file

@ -1,107 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding ManyToManyField 'WGWorkflow.selected_tags'
db.create_table('ietfworkflows_wgworkflow_selected_tags', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('wgworkflow', models.ForeignKey(orm.WGWorkflow, null=False)),
('annotationtag', models.ForeignKey(orm.AnnotationTag, null=False))
))
# Adding ManyToManyField 'WGWorkflow.selected_states'
db.create_table('ietfworkflows_wgworkflow_selected_states', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('wgworkflow', models.ForeignKey(orm.WGWorkflow, null=False)),
('state', models.ForeignKey(orm['workflows.State'], null=False))
))
def backwards(self, orm):
# Dropping ManyToManyField 'WGWorkflow.selected_tags'
db.delete_table('ietfworkflows_wgworkflow_selected_tags')
# Dropping ManyToManyField 'WGWorkflow.selected_states'
db.delete_table('ietfworkflows_wgworkflow_selected_states')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']"}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

119
ietf/ietfworkflows/migrations/0003_add_person_to_history.py
View file

@ -1,119 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding field 'ObjectWorkflowHistoryEntry.person'
db.add_column('ietfworkflows_objectworkflowhistoryentry', 'person', orm['ietfworkflows.objectworkflowhistoryentry:person'])
# Adding field 'ObjectAnnotationTagHistoryEntry.person'
db.add_column('ietfworkflows_objectannotationtaghistoryentry', 'person', orm['ietfworkflows.objectannotationtaghistoryentry:person'])
def backwards(self, orm):
# Deleting field 'ObjectWorkflowHistoryEntry.person'
db.delete_column('ietfworkflows_objectworkflowhistoryentry', 'person_id')
# Deleting field 'ObjectAnnotationTagHistoryEntry.person'
db.delete_column('ietfworkflows_objectannotationtaghistoryentry', 'person_id')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'symmetrical': 'False'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'symmetrical': 'False'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

132
ietf/ietfworkflows/migrations/0004_add_object_state_dates.py
View file

@ -1,132 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding model 'StateObjectRelationMetadata'
db.create_table('ietfworkflows_stateobjectrelationmetadata', (
('id', orm['ietfworkflows.stateobjectrelationmetadata:id']),
('relation', orm['ietfworkflows.stateobjectrelationmetadata:relation']),
('from_date', orm['ietfworkflows.stateobjectrelationmetadata:from_date']),
('estimated_date', orm['ietfworkflows.stateobjectrelationmetadata:estimated_date']),
))
db.send_create_signal('ietfworkflows', ['StateObjectRelationMetadata'])
def backwards(self, orm):
# Deleting model 'StateObjectRelationMetadata'
db.delete_table('ietfworkflows_stateobjectrelationmetadata')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'symmetrical': 'False'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'symmetrical': 'False'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

209
ietf/ietfworkflows/migrations/0005_add_streams.py
View file

@ -1,209 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding model 'StreamedID'
db.create_table('ietfworkflows_streamedid', (
('id', orm['ietfworkflows.streamedid:id']),
('draft', orm['ietfworkflows.streamedid:draft']),
('stream', orm['ietfworkflows.streamedid:stream']),
))
db.send_create_signal('ietfworkflows', ['StreamedID'])
# Adding model 'Stream'
db.create_table('ietfworkflows_stream', (
('id', orm['ietfworkflows.stream:id']),
('name', orm['ietfworkflows.stream:name']),
('with_groups', orm['ietfworkflows.stream:with_groups']),
('group_model', orm['ietfworkflows.stream:group_model']),
('group_chair_model', orm['ietfworkflows.stream:group_chair_model']),
('workflow', orm['ietfworkflows.stream:workflow']),
))
db.send_create_signal('ietfworkflows', ['Stream'])
def backwards(self, orm):
# Deleting model 'StreamedID'
db.delete_table('ietfworkflows_streamedid')
# Deleting model 'Stream'
db.delete_table('ietfworkflows_stream')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']"})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

198
ietf/ietfworkflows/migrations/0006_add_group_to_streamed_id.py
View file

@ -1,198 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding field 'StreamedID.content_type'
db.add_column('ietfworkflows_streamedid', 'content_type', orm['ietfworkflows.streamedid:content_type'])
# Adding field 'StreamedID.content_id'
db.add_column('ietfworkflows_streamedid', 'content_id', orm['ietfworkflows.streamedid:content_id'])
def backwards(self, orm):
# Deleting field 'StreamedID.content_type'
db.delete_column('ietfworkflows_streamedid', 'content_type_id')
# Deleting field 'StreamedID.content_id'
db.delete_column('ietfworkflows_streamedid', 'content_id')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'streamed_id'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']"})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

194
ietf/ietfworkflows/migrations/0007_do_stream_optional.py
View file

@ -1,194 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Changing field 'StreamedID.stream'
# (to signature: django.db.models.fields.related.ForeignKey(to=orm['ietfworkflows.Stream'], null=True, blank=True))
db.alter_column('ietfworkflows_streamedid', 'stream_id', orm['ietfworkflows.streamedid:stream'])
def backwards(self, orm):
# Changing field 'StreamedID.stream'
# (to signature: django.db.models.fields.related.ForeignKey(to=orm['ietfworkflows.Stream']))
db.alter_column('ietfworkflows_streamedid', 'stream_id', orm['ietfworkflows.streamedid:stream'])
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'change_date': ('django.db.models.fields.DateTimeField', [], {}),
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transition_date': ('django.db.models.fields.DateTimeField', [], {})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'streamed_id'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

267
ietf/ietfworkflows/migrations/0008_refactor_history_entries.py
View file

@ -1,267 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Deleting model 'objectworkflowhistoryentry'
db.delete_table('ietfworkflows_objectworkflowhistoryentry')
# Deleting model 'objectannotationtaghistoryentry'
db.delete_table('ietfworkflows_objectannotationtaghistoryentry')
# Adding model 'ObjectAnnotationTagHistoryEntry'
db.create_table('ietfworkflows_objectannotationtaghistoryentry', (
('objecthistoryentry_ptr', orm['ietfworkflows.objectannotationtaghistoryentry:objecthistoryentry_ptr']),
('setted', orm['ietfworkflows.objectannotationtaghistoryentry:setted']),
('unsetted', orm['ietfworkflows.objectannotationtaghistoryentry:unsetted']),
))
db.send_create_signal('ietfworkflows', ['ObjectAnnotationTagHistoryEntry'])
# Adding model 'ObjectHistoryEntry'
db.create_table('ietfworkflows_objecthistoryentry', (
('id', orm['ietfworkflows.objecthistoryentry:id']),
('content_type', orm['ietfworkflows.objecthistoryentry:content_type']),
('content_id', orm['ietfworkflows.objecthistoryentry:content_id']),
('date', orm['ietfworkflows.objecthistoryentry:date']),
('comment', orm['ietfworkflows.objecthistoryentry:comment']),
('person', orm['ietfworkflows.objecthistoryentry:person']),
))
db.send_create_signal('ietfworkflows', ['ObjectHistoryEntry'])
# Adding model 'ObjectStreamHistoryEntry'
db.create_table('ietfworkflows_objectstreamhistoryentry', (
('objecthistoryentry_ptr', orm['ietfworkflows.objectstreamhistoryentry:objecthistoryentry_ptr']),
('from_stream', orm['ietfworkflows.objectstreamhistoryentry:from_stream']),
('to_stream', orm['ietfworkflows.objectstreamhistoryentry:to_stream']),
))
db.send_create_signal('ietfworkflows', ['ObjectStreamHistoryEntry'])
# Adding model 'ObjectWorkflowHistoryEntry'
db.create_table('ietfworkflows_objectworkflowhistoryentry', (
('objecthistoryentry_ptr', orm['ietfworkflows.objectworkflowhistoryentry:objecthistoryentry_ptr']),
('from_state', orm['ietfworkflows.objectworkflowhistoryentry:from_state']),
('to_state', orm['ietfworkflows.objectworkflowhistoryentry:to_state']),
))
db.send_create_signal('ietfworkflows', ['ObjectWorkflowHistoryEntry'])
def backwards(self, orm):
# Deleting model 'ObjectAnnotationTagHistoryEntry'
db.delete_table('ietfworkflows_objectannotationtaghistoryentry')
# Deleting model 'ObjectHistoryEntry'
db.delete_table('ietfworkflows_objecthistoryentry')
# Deleting model 'ObjectStreamHistoryEntry'
db.delete_table('ietfworkflows_objectstreamhistoryentry')
# Deleting model 'ObjectWorkflowHistoryEntry'
db.delete_table('ietfworkflows_objectworkflowhistoryentry')
# Adding model 'objectworkflowhistoryentry'
db.create_table('ietfworkflows_objectworkflowhistoryentry', (
('comment', orm['ietfworkflows.objectworkflowhistoryentry:comment']),
('from_state', orm['ietfworkflows.objectworkflowhistoryentry:from_state']),
('to_state', orm['ietfworkflows.objectworkflowhistoryentry:to_state']),
('content_type', orm['ietfworkflows.objectworkflowhistoryentry:content_type']),
('person', orm['ietfworkflows.objectworkflowhistoryentry:person']),
('content_id', orm['ietfworkflows.objectworkflowhistoryentry:content_id']),
('id', orm['ietfworkflows.objectworkflowhistoryentry:id']),
('transition_date', orm['ietfworkflows.objectworkflowhistoryentry:transition_date']),
))
db.send_create_signal('ietfworkflows', ['objectworkflowhistoryentry'])
# Adding model 'objectannotationtaghistoryentry'
db.create_table('ietfworkflows_objectannotationtaghistoryentry', (
('comment', orm['ietfworkflows.objectannotationtaghistoryentry:comment']),
('person', orm['ietfworkflows.objectannotationtaghistoryentry:person']),
('unsetted', orm['ietfworkflows.objectannotationtaghistoryentry:unsetted']),
('content_type', orm['ietfworkflows.objectannotationtaghistoryentry:content_type']),
('change_date', orm['ietfworkflows.objectannotationtaghistoryentry:change_date']),
('setted', orm['ietfworkflows.objectannotationtaghistoryentry:setted']),
('content_id', orm['ietfworkflows.objectannotationtaghistoryentry:content_id']),
('id', orm['ietfworkflows.objectannotationtaghistoryentry:id']),
))
db.send_create_signal('ietfworkflows', ['objectannotationtaghistoryentry'])
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'streamed_id'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

197
ietf/ietfworkflows/migrations/0009_allow_null_in_from_date.py
View file

@ -1,197 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Changing field 'StateObjectRelationMetadata.from_date'
# (to signature: django.db.models.fields.DateTimeField(null=True, blank=True))
db.alter_column('ietfworkflows_stateobjectrelationmetadata', 'from_date', orm['ietfworkflows.stateobjectrelationmetadata:from_date'])
def backwards(self, orm):
# Changing field 'StateObjectRelationMetadata.from_date'
# (to signature: django.db.models.fields.DateTimeField())
db.alter_column('ietfworkflows_stateobjectrelationmetadata', 'from_date', orm['ietfworkflows.stateobjectrelationmetadata:from_date'])
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'streamed_id'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

207
ietf/ietfworkflows/migrations/0010_add_state_definitions.py
View file

@ -1,207 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding model 'StateDescription'
db.create_table('ietfworkflows_statedescription', (
('id', orm['ietfworkflows.statedescription:id']),
('state', orm['ietfworkflows.statedescription:state']),
('definition', orm['ietfworkflows.statedescription:definition']),
('order', orm['ietfworkflows.statedescription:order']),
))
db.send_create_signal('ietfworkflows', ['StateDescription'])
def backwards(self, orm):
# Deleting model 'StateDescription'
db.delete_table('ietfworkflows_statedescription')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']", 'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.statedescription': {
'definition': ('django.db.models.fields.TextField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.PositiveIntegerField', [], {}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'streamed_id'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

205
ietf/ietfworkflows/migrations/0011_remove_group_from_stream.py
View file

@ -1,205 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Deleting field 'StreamedID.content_type'
db.delete_column('ietfworkflows_streamedid', 'content_type_id')
# Deleting field 'StreamedID.content_id'
db.delete_column('ietfworkflows_streamedid', 'content_id')
def backwards(self, orm):
# Adding field 'StreamedID.content_type'
db.add_column('ietfworkflows_streamedid', 'content_type', orm['ietfworkflows.streamedid:content_type'])
# Adding field 'StreamedID.content_id'
db.add_column('ietfworkflows_streamedid', 'content_id', orm['ietfworkflows.streamedid:content_id'])
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.PersonOrOrgInfo']"], {'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.statedescription': {
'definition': ('django.db.models.fields.TextField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.PositiveIntegerField', [], {}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'group_chair_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'group_model': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'with_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

222
ietf/ietfworkflows/migrations/0012_refactor_stream_group_descrition.py
View file

@ -1,222 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding field 'Stream.group_chair_attribute'
db.add_column('ietfworkflows_stream', 'group_chair_attribute', orm['ietfworkflows.stream:group_chair_attribute'])
# Adding field 'Stream.document_group_attribute'
db.add_column('ietfworkflows_stream', 'document_group_attribute', orm['ietfworkflows.stream:document_group_attribute'])
# Deleting field 'Stream.group_chair_model'
db.delete_column('ietfworkflows_stream', 'group_chair_model')
# Deleting field 'Stream.with_groups'
db.delete_column('ietfworkflows_stream', 'with_groups')
# Deleting field 'Stream.group_model'
db.delete_column('ietfworkflows_stream', 'group_model')
def backwards(self, orm):
# Deleting field 'Stream.group_chair_attribute'
db.delete_column('ietfworkflows_stream', 'group_chair_attribute')
# Deleting field 'Stream.document_group_attribute'
db.delete_column('ietfworkflows_stream', 'document_group_attribute')
# Adding field 'Stream.group_chair_model'
db.add_column('ietfworkflows_stream', 'group_chair_model', orm['ietfworkflows.stream:group_chair_model'])
# Adding field 'Stream.with_groups'
db.add_column('ietfworkflows_stream', 'with_groups', orm['ietfworkflows.stream:with_groups'])
# Adding field 'Stream.group_model'
db.add_column('ietfworkflows_stream', 'group_model', orm['ietfworkflows.stream:group_model'])
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.PersonOrOrgInfo']"], {'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.statedescription': {
'definition': ('django.db.models.fields.TextField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.PositiveIntegerField', [], {}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'document_group_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'group_chair_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamedid': {
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

208
ietf/ietfworkflows/migrations/0013_add_stream_delegates.py
View file

@ -1,208 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
def forwards(self, orm):
# Adding model 'StreamDelegate'
db.create_table('ietfworkflows_streamdelegate', (
('id', orm['ietfworkflows.streamdelegate:id']),
('stream', orm['ietfworkflows.streamdelegate:stream']),
('person', orm['ietfworkflows.streamdelegate:person']),
))
db.send_create_signal('ietfworkflows', ['StreamDelegate'])
def backwards(self, orm):
# Deleting model 'StreamDelegate'
db.delete_table('ietfworkflows_streamdelegate')
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.PersonOrOrgInfo']"], {'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.statedescription': {
'definition': ('django.db.models.fields.TextField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.PositiveIntegerField', [], {}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'document_group_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'group_chair_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamdelegate': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']"})
},
'ietfworkflows.streamedid': {
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
}
}
complete_apps = ['ietfworkflows']

234
ietf/ietfworkflows/migrations/0014_change_alt_streams_states.py
View file

@ -1,234 +0,0 @@
from south.db import db
from django.db import models
from ietf.ietfworkflows.models import *
class Migration:
no_dry_run = True
def forwards(self, orm):
# Remove all 'Published RFC' status
for state in orm['workflows.state'].objects.filter(name='Published RFC'):
state.delete()
def backwards(self, orm):
"Write your backwards migration here"
models = {
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'idtracker.acronym': {
'Meta': {'db_table': "'acronym'"},
'acronym': ('django.db.models.fields.CharField', [], {'max_length': '12'}),
'acronym_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name_key': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'idtracker.idintendedstatus': {
'Meta': {'db_table': "'id_intended_status'"},
'intended_status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'intended_status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.idstatus': {
'Meta': {'db_table': "'id_status'"},
'status': ('django.db.models.fields.CharField', [], {'max_length': '25', 'db_column': "'status_value'"}),
'status_id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'idtracker.internetdraft': {
'Meta': {'db_table': "'internet_drafts'"},
'abstract': ('django.db.models.fields.TextField', [], {}),
'b_approve_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_discussion_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'b_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'comments': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'dunn_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True'}),
'expired_tombstone': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'extension_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'file_type': ('django.db.models.fields.CharField', [], {'max_length': '20'}),
'filename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.Acronym']", 'db_column': "'group_acronym_id'"}),
'id_document_key': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'id_document_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'intended_status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDIntendedStatus']"}),
'last_modified_date': ('django.db.models.fields.DateField', [], {}),
'lc_changes': ('django.db.models.fields.CharField', [], {'max_length': '3', 'null': 'True'}),
'lc_expiration_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'lc_sent_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'local_path': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'replaced_by': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.InternetDraft']"], {'related_name': "'replaces_set'", 'null': 'True', 'db_column': "'replaced_by'", 'blank': 'True'}),
'review_by_rfc_editor': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'revision': ('django.db.models.fields.CharField', [], {'max_length': '2'}),
'revision_date': ('django.db.models.fields.DateField', [], {}),
'rfc_number': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'shepherd': ('django.db.models.fields.related.ForeignKey', ["orm['idtracker.PersonOrOrgInfo']"], {'null': 'True', 'blank': 'True'}),
'start_date': ('django.db.models.fields.DateField', [], {}),
'status': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.IDStatus']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_column': "'id_document_name'"}),
'txt_page_count': ('django.db.models.fields.IntegerField', [], {}),
'wgreturn_date': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'})
},
'idtracker.personororginfo': {
'Meta': {'db_table': "'person_or_org_info'"},
'address_type': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'created_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'date_created': ('django.db.models.fields.DateField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
'date_modified': ('django.db.models.fields.DateField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'first_name_key': ('django.db.models.fields.CharField', [], {'max_length': '20', 'blank': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'last_name_key': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'middle_initial': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'middle_initial_key': ('django.db.models.fields.CharField', [], {'max_length': '4', 'null': 'True', 'blank': 'True'}),
'modified_by': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'}),
'name_prefix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'name_suffix': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
'person_or_org_tag': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'record_type': ('django.db.models.fields.CharField', [], {'max_length': '8', 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.annotationtag': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'annotation_tags'", 'to': "orm['workflows.Workflow']"})
},
'ietfworkflows.annotationtagobjectrelation': {
'annotation_tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.AnnotationTag']"}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'annotation_tags'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'ietfworkflows.objectannotationtaghistoryentry': {
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'setted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'unsetted': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objecthistoryentry': {
'comment': ('django.db.models.fields.TextField', [], {}),
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_history'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"})
},
'ietfworkflows.objectstreamhistoryentry': {
'from_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_stream': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'})
},
'ietfworkflows.objectworkflowhistoryentry': {
'from_state': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'objecthistoryentry_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['ietfworkflows.ObjectHistoryEntry']", 'unique': 'True', 'primary_key': 'True'}),
'to_state': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'ietfworkflows.statedescription': {
'definition': ('django.db.models.fields.TextField', [], {}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.PositiveIntegerField', [], {}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'ietfworkflows.stateobjectrelationmetadata': {
'estimated_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'from_date': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'relation': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.StateObjectRelation']"})
},
'ietfworkflows.stream': {
'document_group_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'group_chair_attribute': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.WGWorkflow']"})
},
'ietfworkflows.streamdelegate': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['idtracker.PersonOrOrgInfo']"}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']"})
},
'ietfworkflows.streamedid': {
'draft': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['idtracker.InternetDraft']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'stream': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['ietfworkflows.Stream']", 'null': 'True', 'blank': 'True'})
},
'ietfworkflows.wgworkflow': {
'selected_states': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.State']", 'null': 'True', 'blank': 'True'}),
'selected_tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['ietfworkflows.AnnotationTag']", 'null': 'True', 'blank': 'True'}),
'workflow_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['workflows.Workflow']", 'unique': 'True', 'primary_key': 'True'})
},
'permissions.permission': {
'codename': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'content_types': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'permissions.role': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'})
},
'workflows.state': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'transitions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['workflows.Transition']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'states'", 'to': "orm['workflows.Workflow']"})
},
'workflows.stateinheritanceblock': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']"}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.stateobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id', 'state'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'state_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.statepermissionrelation': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']"}),
'role': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Role']"}),
'state': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.State']"})
},
'workflows.transition': {
'condition': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
'destination': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'destination_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['permissions.Permission']", 'null': 'True', 'blank': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'transitions'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflow': {
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'initial_state': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_state'", 'null': 'True', 'to': "orm['workflows.State']"}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['permissions.Permission']", 'symmetrical': 'False'})
},
'workflows.workflowmodelrelation': {
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']", 'unique': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'wmrs'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflowobjectrelation': {
'Meta': {'unique_together': "(('content_type', 'content_id'),)"},
'content_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'workflow_object'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'wors'", 'to': "orm['workflows.Workflow']"})
},
'workflows.workflowpermissionrelation': {
'Meta': {'unique_together': "(('workflow', 'permission'),)"},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'permission': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'permissions'", 'to': "orm['permissions.Permission']"}),
'workflow': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['workflows.Workflow']"})
}
}
complete_apps = ['ietfworkflows', 'workflows']

0
ietf/ietfworkflows/migrations/__init__.py
View file

268
ietf/ietfworkflows/models.py
View file

@ -1,268 +0,0 @@
from django.contrib.contenttypes import generic
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.conf import settings
from ietf.idtracker.models import PersonOrOrgInfo, InternetDraft, Role, IRTF
from ietf.utils.admin import admin_link
from workflows.models import Workflow, State, StateObjectRelation
from permissions.models import Permission
class ObjectHistoryEntry(models.Model):
content_type = models.ForeignKey(ContentType, verbose_name=_(u"Content type"), related_name="workflow_history", blank=True, null=True)
content_id = models.PositiveIntegerField(_(u"Content id"), blank=True, null=True)
content = generic.GenericForeignKey(ct_field="content_type", fk_field="content_id")
date = models.DateTimeField(_('Date'), auto_now_add=True)
comment = models.TextField(_('Comment'))
person = models.ForeignKey(PersonOrOrgInfo)
class Meta:
ordering = ('-date', )
def get_real_instance(self):
if hasattr(self, '_real_instance'):
return self._real_instance
for i in ('objectworkflowhistoryentry', 'objectannotationtaghistoryentry', 'objectstreamhistoryentry'):
try:
real_instance = getattr(self, i, None)
if real_instance:
self._real_instance = real_instance
return real_instance
except models.ObjectDoesNotExist:
continue
self._real_instance = self
return self
class ObjectWorkflowHistoryEntry(ObjectHistoryEntry):
from_state = models.CharField(_('From state'), max_length=100)
to_state = models.CharField(_('To state'), max_length=100)
def describe_change(self):
html = '<p class="describe_state_change">'
html += 'Changed state <i>%s</i> to <b>%s</b>' % (self.from_state, self.to_state)
html += '</p>'
return html
class ObjectAnnotationTagHistoryEntry(ObjectHistoryEntry):
setted = models.TextField(_('Setted tags'), blank=True, null=True)
unsetted = models.TextField(_('Unsetted tags'), blank=True, null=True)
def describe_change(self):
html = ''
if self.setted:
html += '<p class="describe_tags_set">'
html += 'Annotation tags set: '
html += self.setted
html += '</p>'
if self.unsetted:
html += '<p class="describe_tags_reset">'
html += 'Annotation tags reset: '
html += self.unsetted
html += '</p>'
return html
class ObjectStreamHistoryEntry(ObjectHistoryEntry):
from_stream = models.TextField(_('From stream'), blank=True, null=True)
to_stream = models.TextField(_('To stream'), blank=True, null=True)
def describe_change(self):
html = '<p class="describe_stream_change">'
html += 'Changed doc from stream <i>%s</i> to <b>%s</b>' % (self.from_stream, self.to_stream)
html += '</p>'
return html
class StateDescription(models.Model):
state = models.ForeignKey(State)
definition = models.TextField()
order = models.PositiveIntegerField()
class Meta:
ordering = ('order', )
def __unicode__(self):
return unicode(self.state)
class AnnotationTag(models.Model):
name = models.CharField(_(u"Name"), max_length=100)
workflow = models.ForeignKey(Workflow, verbose_name=_(u"Workflow"), related_name="annotation_tags")
permission = models.ForeignKey(Permission, verbose_name=_(u"Permission"), blank=True, null=True)
class Meta:
ordering = ('name', )
def __unicode__(self):
return self.name
class AnnotationTagObjectRelation(models.Model):
content_type = models.ForeignKey(ContentType, verbose_name=_(u"Content type"), related_name="annotation_tags", blank=True, null=True)
content_id = models.PositiveIntegerField(_(u"Content id"), blank=True, null=True)
content = generic.GenericForeignKey(ct_field="content_type", fk_field="content_id")
annotation_tag = models.ForeignKey(AnnotationTag, verbose_name=_(u"Annotation tag"))
class StateObjectRelationMetadata(models.Model):
relation = models.ForeignKey(StateObjectRelation)
from_date = models.DateTimeField(_('Initial date'), blank=True, null=True)
estimated_date = models.DateTimeField(_('Estimated date'), blank=True, null=True)
class WGWorkflow(Workflow):
selected_states = models.ManyToManyField(State, blank=True, null=True)
selected_tags = models.ManyToManyField(AnnotationTag, blank=True, null=True)
class Meta:
verbose_name = 'IETF Workflow'
verbose_name_plural = 'IETF Workflows'
def get_tags(self):
tags = self.annotation_tags.all()
if tags.count():
return tags
else:
return self.selected_tags.all()
def get_states(self):
states = self.states.all()
if states.count():
return states
else:
return self.selected_states.all()
class Stream(models.Model):
name = models.CharField(_(u"Name"), max_length=100)
document_group_attribute = models.CharField(_(u'Document group attribute'), max_length=255, blank=True, null=True)
group_chair_attribute = models.CharField(_(u'Group chair attribute'), max_length=255, blank=True, null=True)
workflow = models.ForeignKey(WGWorkflow)
def __unicode__(self):
return u'%s stream' % self.name
workflow_link = admin_link('workflow')
def _irtf_group(self, document):
filename = document.filename.split('-')
if len(filename) > 2 and filename[0] == 'draft' and filename[1] == 'irtf':
try:
return IRTF.objects.get(acronym=filename[2])
except IRTF.DoesNotExist:
return None
return None
def _irtf_chairs_for_document(self, document):
group = self._irtf_group(document)
if not group:
return []
chairs = [i.person for i in group.chairs()]
chairs.append(Role.objects.get(pk=Role.IRTF_CHAIR).person)
return chairs
def _ietf_delegates_for_document(self, document):
group = self.get_group_for_document(document)
if not group:
return False
return [i.person for i in group.wgdelegate_set.all()]
def get_group_for_document(self, document):
if hasattr(self, '_%s_group' % self.name.lower()):
return getattr(self, '_%s_group' % self.name.lower())(document)
if not self.document_group_attribute:
return None
attr = None
obj = document
for attr_name in self.document_group_attribute.split('.'):
attr = getattr(obj, attr_name, None)
if not attr:
return None
if callable(attr):
attr = attr()
obj = attr
return attr
def get_chairs_for_document(self, document):
if hasattr(self, '_%s_chairs_for_document' % self.name.lower()):
return getattr(self, '_%s_chairs_for_document' % self.name.lower())(document)
group = self.get_group_for_document(document)
if not group or not self.group_chair_attribute:
return []
attr = None
obj = group
for attr_name in self.group_chair_attribute.split('.'):
attr = getattr(obj, attr_name, None)
if not attr:
return None
if callable(attr):
attr = attr()
obj = attr
return attr
def get_delegates_for_document(self, document):
delegates = []
if hasattr(self, '_%s_delegates_for_document' % self.name.lower()):
delegates = getattr(self, '_%s_delegates_for_document' % self.name.lower())(document)
delegates += [i.person for i in self.streamdelegate_set.all()]
return delegates
def _ise_chairs_for_document(self, document):
return self._ise_stream_chairs()
def _ise_stream_chairs(self):
chairs = []
try:
chairs.append(Role.objects.get(role_name='ISE').person)
except Role.DoesNotExist:
pass
return chairs
def get_chairs(self):
chairs = []
if hasattr(self, '_%s_stream_chairs' % self.name.lower()):
chairs += list(getattr(self, '_%s_stream_chairs' % self.name.lower())())
role_key = getattr(Role, '%s_CHAIR' % self.name.upper(), None)
if role_key:
try:
chairs.append(Role.objects.get(pk=role_key).person)
except Role.DoesNotExist:
pass
return list(set(chairs))
def get_delegates(self):
delegates = []
if hasattr(self, '_%s_stream_delegates' % self.name.lower()):
delegates += list(getattr(self, '_%s_stream_delegates' % self.name.lower())())
delegates += [i.person for i in StreamDelegate.objects.filter(stream=self)]
return list(set(delegates))
def check_chair(self, person):
return person in self.get_chairs()
def check_delegate(self, person):
return person in self.get_delegates()
class StreamedID(models.Model):
draft = models.OneToOneField(InternetDraft)
stream = models.ForeignKey(Stream, blank=True, null=True)
def get_group(self):
return self.stream.get_group_for_document(self.draft)
class StreamDelegate(models.Model):
stream = models.ForeignKey(Stream)
person = models.ForeignKey(PersonOrOrgInfo)
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.name.proxy import StreamProxy as Stream

102
ietf/ietfworkflows/streams.py
View file

@ -1,102 +0,0 @@
from django.db import models
from django.conf import settings
from ietf.idtracker.models import InternetDraft
from ietf.idrfc.idrfc_wrapper import IdRfcWrapper, IdWrapper
from ietf.ietfworkflows.models import StreamedID, Stream
def get_streamed_draft(draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
class Dummy: pass
o = Dummy()
o.draft = draft
o.stream = super(InternetDraft, draft).stream
o.group = draft.group
o.get_group = lambda: draft.group
return o
if not draft:
return None
try:
return draft.streamedid
except StreamedID.DoesNotExist:
return None
def get_stream_from_draft(draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
s = super(InternetDraft, draft).stream
if s:
s.with_groups = s.slug in ["ietf", "irtf"]
return s
streamedid = get_streamed_draft(draft)
if streamedid:
return streamedid.stream
return False
def get_stream_by_name(stream_name):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
raise NotImplementedError
try:
return Stream.objects.get(name=stream_name)
except Stream.DoesNotExist:
return None
def get_stream_from_id(stream_id):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
raise NotImplementedError
try:
return Stream.objects.get(id=stream_id)
except Stream.DoesNotExist:
return None
def _set_stream_automatically(draft, stream):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
raise NotImplementedError
(streamed, created) = StreamedID.objects.get_or_create(draft=draft)
if created:
streamed.stream = stream
streamed.save()
return
def get_stream_from_wrapper(idrfc_wrapper):
idwrapper = None
if isinstance(idrfc_wrapper, IdRfcWrapper):
idwrapper = idrfc_wrapper.id
elif isinstance(idrfc_wrapper, IdWrapper):
idwrapper = idrfc_wrapper
if not idwrapper:
return None
draft = idwrapper._draft
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return super(InternetDraft, draft).stream
stream = get_stream_from_draft(draft)
if stream == False:
stream_id = idwrapper.stream_id()
stream = get_stream_from_id(stream_id)
_set_stream_automatically(draft, stream)
return stream
else:
return stream
return None
def set_stream_for_draft(draft, stream):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
raise NotImplementedError
(streamed, created) = StreamedID.objects.get_or_create(draft=draft)
if streamed.stream != stream:
streamed.stream = stream
streamed.group = None
streamed.save()
return streamed.stream

1
ietf/ietfworkflows/templatetags/.gitignore vendored
View file

@ -1 +0,0 @@
/*.pyc

0
ietf/ietfworkflows/templatetags/__init__.py
View file

114
ietf/ietfworkflows/templatetags/ietf_streams.py
View file

@ -1,114 +0,0 @@
from django import template
from django.conf import settings
from django.core.urlresolvers import reverse as urlreverse
from ietf.idrfc.idrfc_wrapper import IdRfcWrapper, IdWrapper
from ietf.ietfworkflows.utils import (get_workflow_for_draft,
get_state_for_draft)
from ietf.wgchairs.accounts import (can_manage_shepherd_of_a_document,
can_manage_writeup_of_a_document)
from ietf.ietfworkflows.streams import get_stream_from_wrapper
from ietf.ietfworkflows.models import Stream
from ietf.ietfworkflows.accounts import (can_edit_state, can_edit_stream,
is_chair_of_stream, can_adopt)
register = template.Library()
@register.inclusion_tag('ietfworkflows/stream_state.html', takes_context=True)
def stream_state(context, doc):
data = {}
stream = get_stream_from_wrapper(doc)
data.update({'stream': stream})
if not stream:
return data
idwrapper = None
if isinstance(doc, IdRfcWrapper):
idwrapper = doc.id
elif isinstance(doc, IdWrapper):
idwrapper = doc
if not idwrapper:
return data
draft = getattr(idwrapper, '_draft', None)
if not draft:
return data
workflow = get_workflow_for_draft(draft)
state = get_state_for_draft(draft)
data.update({'workflow': workflow,
'draft': draft,
'state': state,
'milestones': draft.groupmilestone_set.filter(state="active")
})
return data
@register.inclusion_tag('ietfworkflows/workflow_history_entry.html', takes_context=True)
def workflow_history_entry(context, entry):
real_entry = entry.get_real_instance()
return {'entry': real_entry,
'entry_class': real_entry.__class__.__name__.lower()}
@register.inclusion_tag('ietfworkflows/edit_actions.html', takes_context=True)
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)
class StreamListNode(template.Node):
def __init__(self, user, var_name):
self.user = user
self.var_name = var_name
def render(self, context):
user = self.user.resolve(context)
streams = []
for i in Stream.objects.all():
if "Legacy" in i.name:
continue
if is_chair_of_stream(user, i):
streams.append(i)
context.update({self.var_name: streams})
return ''
@register.tag
def get_user_managed_streams(parser, token):
firstbits = token.contents.split(None, 2)
if len(firstbits) != 3:
raise template.TemplateSyntaxError("'get_user_managed_streams' tag takes three arguments")
user = parser.compile_filter(firstbits[1])
lastbits_reversed = firstbits[2][::-1].split(None, 2)
if lastbits_reversed[1][::-1] != 'as':
raise template.TemplateSyntaxError("next-to-last argument to 'get_user_managed_stream' tag must"
" be 'as'")
var_name = lastbits_reversed[0][::-1]
return StreamListNode(user, var_name)

104
ietf/ietfworkflows/templatetags/ietf_streams_redesign.py
View file

@ -1,104 +0,0 @@
from django import template
from django.conf import settings
from django.core.urlresolvers import reverse as urlreverse
from ietf.idrfc.idrfc_wrapper import IdRfcWrapper, IdWrapper
from ietf.ietfworkflows.utils import (get_workflow_for_draft,
get_state_for_draft)
from ietf.wgchairs.accounts import (can_manage_shepherd_of_a_document,
can_manage_writeup_of_a_document)
from ietf.ietfworkflows.streams import get_stream_from_wrapper
from ietf.ietfworkflows.models import Stream
from ietf.ietfworkflows.accounts import (can_edit_state, can_edit_stream,
is_chair_of_stream, can_adopt)
register = template.Library()
@register.inclusion_tag('ietfworkflows/stream_state_redesign.html', takes_context=True)
def stream_state(context, doc):
data = {}
stream = doc.stream
data.update({'stream': stream})
if not stream:
return data
if doc.type.slug != 'draft':
return data
state = get_state_for_draft(doc)
data.update({
'state': state,
'doc': doc,
})
return data
@register.inclusion_tag('ietfworkflows/workflow_history_entry.html', takes_context=True)
def workflow_history_entry(context, entry):
real_entry = entry.get_real_instance()
return {'entry': real_entry,
'entry_class': real_entry.__class__.__name__.lower()}
@register.inclusion_tag('ietfworkflows/edit_actions.html', takes_context=True)
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 can_edit_stream(user, draft):
actions.append(("Change stream", urlreverse('edit_stream', kwargs=dict(name=doc.draft_name))))
return dict(actions=actions)
class StreamListNode(template.Node):
def __init__(self, user, var_name):
self.user = user
self.var_name = var_name
def render(self, context):
user = self.user.resolve(context)
streams = []
for i in Stream.objects.all():
if "Legacy" in i.name:
continue
if is_chair_of_stream(user, i):
streams.append(i)
context.update({self.var_name: streams})
return ''
@register.tag
def get_user_managed_streams(parser, token):
firstbits = token.contents.split(None, 2)
if len(firstbits) != 3:
raise template.TemplateSyntaxError("'get_user_managed_streams' tag takes three arguments")
user = parser.compile_filter(firstbits[1])
lastbits_reversed = firstbits[2][::-1].split(None, 2)
if lastbits_reversed[1][::-1] != 'as':
raise template.TemplateSyntaxError("next-to-last argument to 'get_user_managed_stream' tag must"
" be 'as'")
var_name = lastbits_reversed[0][::-1]
return StreamListNode(user, var_name)

189
ietf/ietfworkflows/tests.py
View file

@ -1,189 +0,0 @@
import datetime, os, shutil
from django.conf import settings
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse as urlreverse
from StringIO import StringIO
from pyquery import PyQuery
from ietf.utils.test_utils import login_testing_unauthorized
from ietf.utils.test_data import make_test_data
from ietf.utils.mail import outbox
from ietf.utils import TestCase
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.person.models import Person, Email
from ietf.group.models import Group, Role
from ietf.doc.models import Document, State
from ietf.doc.utils import *
from ietf.name.models import DocTagName
class EditStreamInfoTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
def test_adopt_document(self):
draft = make_test_data()
draft.stream = None
draft.group = Group.objects.get(type="individ")
draft.save()
draft.unset_state("draft-stream-ietf")
url = urlreverse('edit_adopt', kwargs=dict(name=draft.name))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
self.assertEquals(len(q('form input[type=submit][value*=adopt]')), 1)
self.assertEquals(len(q('form select[name="group"] option')), 1) # we can only select "mars"
# adopt in mars WG
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
r = self.client.post(url,
dict(comment="some comment",
group=Group.objects.get(acronym="mars").pk,
weeks="10"))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEquals(draft.group.acronym, "mars")
self.assertEquals(draft.stream_id, "ietf")
self.assertEquals(draft.docevent_set.count() - events_before, 4)
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("state changed" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))
def test_set_tags(self):
draft = make_test_data()
draft.tags = DocTagName.objects.filter(slug="w-expert")
draft.group.unused_tags.add("w-refdoc")
url = urlreverse('edit_state', kwargs=dict(name=draft.name))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
# make sure the unused tags are hidden
unused = draft.group.unused_tags.values_list("slug", flat=True)
for t in q("input[name=tags]"):
self.assertTrue(t.attrib["value"] not in unused)
# set tags
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
r = self.client.post(url,
dict(comment="some comment",
weeks="10",
tags=["need-aut", "sheph-u"],
only_tags="1",
# unused but needed for validation
new_state=draft.get_state("draft-stream-%s" % draft.stream_id).pk,
))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEquals(draft.tags.count(), 2)
self.assertEquals(draft.tags.filter(slug="w-expert").count(), 0)
self.assertEquals(draft.tags.filter(slug="need-aut").count(), 1)
self.assertEquals(draft.tags.filter(slug="sheph-u").count(), 1)
self.assertEquals(draft.docevent_set.count() - events_before, 2)
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("tags changed" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))
self.assertTrue("plain@example.com" in unicode(outbox[-1]))
def test_set_state(self):
draft = make_test_data()
url = urlreverse('edit_state', kwargs=dict(name=draft.name))
login_testing_unauthorized(self, "marschairman", url)
# get
r = self.client.get(url)
self.assertEquals(r.status_code, 200)
q = PyQuery(r.content)
# make sure the unused states are hidden
unused = draft.group.unused_states.values_list("pk", flat=True)
for t in q("select[name=new_state]").find("option[name=tags]"):
self.assertTrue(t.attrib["value"] not in unused)
self.assertEquals(len(q('select[name=new_state]')), 1)
old_state = draft.get_state("draft-stream-%s" % draft.stream_id )
new_state = State.objects.get(used=True, type="draft-stream-%s" % draft.stream_id, slug="parked")
self.assertTrue(old_state!=new_state)
mailbox_before = len(outbox)
events_before = draft.docevent_set.count()
# First make sure cancel doesn't change anything
r = self.client.post(url,
dict(comment="some comment",
weeks="10",
tags=[x.pk for x in draft.tags.filter(slug__in=get_tags_for_stream_id(draft.stream_id))],
new_state=new_state.pk,
cancel="1",
))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEquals(draft.get_state("draft-stream-%s" % draft.stream_id), old_state)
# Set new state
r = self.client.post(url,
dict(comment="some comment",
weeks="10",
tags=[x.pk for x in draft.tags.filter(slug__in=get_tags_for_stream_id(draft.stream_id))],
new_state=new_state.pk,
))
self.assertEquals(r.status_code, 302)
draft = Document.objects.get(pk=draft.pk)
self.assertEquals(draft.get_state("draft-stream-%s" % draft.stream_id), new_state)
self.assertEquals(draft.docevent_set.count() - events_before, 2)
reminder = DocReminder.objects.filter(event__doc=draft, type="stream-s")
self.assertEquals(len(reminder), 1)
due = datetime.datetime.now() + datetime.timedelta(weeks=10)
self.assertTrue(due - datetime.timedelta(days=1) <= reminder[0].due <= due + datetime.timedelta(days=1))
self.assertEquals(len(outbox), mailbox_before + 1)
self.assertTrue("state changed" in outbox[-1]["Subject"].lower())
self.assertTrue("wgchairman@ietf.org" in unicode(outbox[-1]))
self.assertTrue("wgdelegate@ietf.org" in unicode(outbox[-1]))
def test_manage_stream_delegates(self):
make_test_data()
url = urlreverse('stream_delegates', kwargs=dict(stream_name="IETF"))
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('input[type=submit][value*=Add]')), 1)
delegate = Email.objects.get(address="plain@example.com")
# add delegate
r = self.client.post(url,
dict(email=delegate.address))
self.assertEquals(r.status_code, 200)
self.assertEquals(Role.objects.filter(group__acronym="ietf", name="delegate", person__email__address=delegate.address).count(), 1)
# remove delegate again
r = self.client.post(url,
dict(remove_delegate=[delegate.person.pk],
delete="1"))
self.assertEquals(r.status_code, 200)
self.assertEquals(Role.objects.filter(group__acronym="ietf", name="delegate", person__email__address=delegate.address).count(), 0)
if not settings.USE_DB_REDESIGN_PROXY_CLASSES:
# the above tests only work with the new schema
del EditStreamInfoTestCase

13
ietf/ietfworkflows/urls.py
View file

@ -1,13 +0,0 @@
# Copyright The IETF Trust 2008, All Rights Reserved
from django.conf.urls.defaults import patterns, url
from django.views.generic.simple import redirect_to
urlpatterns = patterns('ietf.ietfworkflows.views',
url(r'^(?P<name>[^/]+)/history/$', 'stream_history', name='stream_history'),
url(r'^(?P<name>[^/]+)/edit/adopt/$', 'edit_adopt', name='edit_adopt'),
# FIXME: the name edit_state is far too generic
url(r'^(?P<name>[^/]+)/edit/state/$', 'edit_state', name='edit_state'),
url(r'^(?P<name>[^/]+)/edit/stream/$', redirect_to, { 'url': '/doc/%(name)s/edit/info/'}) ,
url(r'^delegates/(?P<stream_name>[^/]+)/$', 'stream_delegates', name='stream_delegates'),
)

471
ietf/ietfworkflows/utils.py
View file

@ -1,471 +0,0 @@
import copy
import datetime
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.core.mail import EmailMessage
from django.template.loader import render_to_string
from django.template.defaultfilters import pluralize
from workflows.models import State, StateObjectRelation
from workflows.utils import (get_workflow_for_object, set_workflow_for_object,
get_state, set_state)
from ietf.ietfworkflows.streams import (get_streamed_draft, get_stream_from_draft,
set_stream_for_draft)
from ietf.ietfworkflows.models import (WGWorkflow, AnnotationTagObjectRelation,
AnnotationTag, ObjectAnnotationTagHistoryEntry,
ObjectHistoryEntry, StateObjectRelationMetadata,
ObjectWorkflowHistoryEntry, ObjectStreamHistoryEntry)
from ietf.idtracker.models import InternetDraft
from ietf.utils.mail import send_mail
from ietf.doc.models import Document, DocEvent, save_document_in_history, DocReminder, DocReminderTypeName
from ietf.group.models import Role
WAITING_WRITEUP = 'WG Consensus: Waiting for Write-Up'
FOLLOWUP_TAG = 'Doc Shepherd Follow-up Underway'
def get_default_workflow_for_wg():
try:
workflow = WGWorkflow.objects.get(name='Default WG Workflow')
return workflow
except WGWorkflow.DoesNotExist:
return None
def clone_transition(transition):
new = copy.copy(transition)
new.pk = None
new.save()
# Reference original initial states
for state in transition.states.all():
new.states.add(state)
return new
def clone_workflow(workflow, name):
new = WGWorkflow.objects.create(name=name, initial_state=workflow.initial_state)
# Reference default states
for state in workflow.states.all():
new.selected_states.add(state)
# Reference default annotation tags
for tag in workflow.annotation_tags.all():
new.selected_tags.add(tag)
# Reference cloned transitions
for transition in workflow.transitions.all():
new.transitions.add(clone_transition(transition))
return new
def get_workflow_for_wg(wg, default=None):
workflow = get_workflow_for_object(wg)
try:
workflow = workflow and workflow.wgworkflow
except WGWorkflow.DoesNotExist:
workflow = None
if not workflow:
if default:
workflow = default
else:
workflow = get_default_workflow_for_wg()
if not workflow:
return None
workflow = clone_workflow(workflow, name='%s workflow' % wg)
set_workflow_for_object(wg, workflow)
return workflow
def get_workflow_for_draft(draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return True if get_streamed_draft(draft) else None
workflow = get_workflow_for_object(draft)
try:
workflow = workflow and workflow.wgworkflow
except WGWorkflow.DoesNotExist:
workflow = None
if not workflow:
streamed_draft = get_streamed_draft(draft)
if not streamed_draft or not streamed_draft.stream:
return None
stream = streamed_draft.stream
if stream.document_group_attribute:
group = streamed_draft.get_group()
if not group:
return None
else:
workflow = get_workflow_for_wg(group, streamed_draft.stream.workflow)
else:
workflow = stream.workflow
set_workflow_for_object(draft, workflow)
return workflow
def get_workflow_history_for_draft(draft, entry_type=None):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.doc.proxy import ObjectHistoryEntryProxy
return ObjectHistoryEntryProxy.objects.filter(doc=draft).order_by('-time', '-id').select_related('by')
ctype = ContentType.objects.get_for_model(draft)
filter_param = {'content_type': ctype,
'content_id': draft.pk}
if entry_type:
filter_param.update({'%s__isnull' % entry_type: False})
history = ObjectHistoryEntry.objects.filter(**filter_param).\
select_related('objectworkflowhistoryentry', 'objectannotationtaghistoryentry',
'objectstreamhistoryentry')
return history
def get_annotation_tags_for_draft(draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
from ietf.name.proxy import AnnotationTagObjectRelationProxy
from ietf.doc.utils import get_tags_for_stream_id
return AnnotationTagObjectRelationProxy.objects.filter(document=draft.pk, slug__in=get_tags_for_stream_id(draft.stream_id))
ctype = ContentType.objects.get_for_model(draft)
tags = AnnotationTagObjectRelation.objects.filter(content_type=ctype, content_id=draft.pk)
return tags
def get_state_for_draft(draft):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
return draft.get_state("draft-stream-%s" % draft.stream_id)
return get_state(draft)
def get_state_by_name(state_name):
try:
return State.objects.get(used=True, name=state_name)
except State.DoesNotExist:
return None
def get_annotation_tag_by_name(tag_name):
try:
return AnnotationTag.objects.get(name=tag_name)
except AnnotationTag.DoesNotExist:
return None
def set_tag(obj, tag):
ctype = ContentType.objects.get_for_model(obj)
(relation, created) = AnnotationTagObjectRelation.objects.get_or_create(
content_type=ctype,
content_id=obj.pk,
annotation_tag=tag)
return relation
def set_tag_by_name(obj, tag_name):
try:
tag = AnnotationTag.objects.get(name=tag_name)
return set_tag(obj, tag)
except AnnotationTag.DoesNotExist:
return None
def reset_tag(obj, tag):
ctype = ContentType.objects.get_for_model(obj)
try:
tag_relation = AnnotationTagObjectRelation.objects.get(
content_type=ctype,
content_id=obj.pk,
annotation_tag=tag)
tag_relation.delete()
return True
except AnnotationTagObjectRelation.DoesNotExist:
return False
def reset_tag_by_name(obj, tag_name):
try:
tag = AnnotationTag.objects.get(name=tag_name)
return reset_tag(obj, tag)
except AnnotationTag.DoesNotExist:
return False
def set_state_for_draft(draft, state, estimated_date=None):
workflow = get_workflow_for_draft(draft)
if state in workflow.get_states():
set_state(draft, state)
relation = StateObjectRelation.objects.get(
content_type=ContentType.objects.get_for_model(draft),
content_id=draft.pk)
metadata = StateObjectRelationMetadata.objects.get_or_create(relation=relation)[0]
metadata.from_date = datetime.date.today()
metadata.to_date = estimated_date
metadata.save()
return state
return False
def notify_entry(entry, template, extra_notify=[]):
doc = entry.content
wg = doc.group.ietfwg
mail_list = set(['%s <%s>' % i.person.email() for i in wg.wgchair_set.all() if i.person.email()])
mail_list = mail_list.union(['%s <%s>' % i.person.email() for i in wg.wgdelegate_set.all() if i.person.email()])
mail_list = mail_list.union(['%s <%s>' % i.person.email() for i in doc.authors.all() if i.person.email()])
mail_list = mail_list.union(extra_notify)
mail_list = list(mail_list)
subject = 'Annotation tags have changed for draft %s' % doc
body = render_to_string(template, {'doc': doc,
'entry': entry,
})
mail = EmailMessage(subject=subject,
body=body,
to=mail_list,
from_email=settings.DEFAULT_FROM_EMAIL)
# Only send emails if we are not debug mode
if not settings.DEBUG:
mail.send()
return mail
def notify_tag_entry(entry, extra_notify=[]):
return notify_entry(entry, 'ietfworkflows/annotation_tags_updated_mail.txt', extra_notify)
def notify_state_entry(entry, extra_notify=[]):
return notify_entry(entry, 'ietfworkflows/state_updated_mail.txt', extra_notify)
def notify_stream_entry(entry, extra_notify=[]):
return notify_entry(entry, 'ietfworkflows/stream_updated_mail.txt', extra_notify)
def get_notification_receivers(doc, extra_notify):
persons = set()
res = []
for r in Role.objects.filter(group=doc.group, name__in=("chair", "delegate")):
res.append(u'"%s" <%s>' % (r.person.plain_name(), r.email.address))
persons.add(r.person)
for email in doc.authors.all():
if email.person not in persons:
res.append(email.formatted_email())
persons.add(email.person)
for x in extra_notify:
if not x in res:
res.append(x)
return res
def get_pubreq_receivers(doc, extra_notify):
res = [u'"IESG Secretary" <iesg-secretary@ietf.org>', ]
for r in Role.objects.filter(person=doc.group.ad,name__slug='ad'):
res.append(u'"%s" <%s>' % (r.person.plain_name(), r.email.address))
for x in extra_notify:
if not x in res:
res.append(x)
return res
def get_pubreq_cc_receivers(doc):
res = []
for r in Role.objects.filter(group=doc.group, name__in=("chair", "delegate")):
res.append(u'"%s" <%s>' % (r.person.plain_name(), r.email.address))
return res
def update_tags(request, obj, comment, person, set_tags=[], reset_tags=[], extra_notify=[], send_email=True):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
doc = Document.objects.get(pk=obj.pk)
save_document_in_history(doc)
obj.tags.remove(*reset_tags)
obj.tags.add(*set_tags)
doc.time = datetime.datetime.now()
e = DocEvent(type="changed_document", time=doc.time, by=person, doc=doc)
l = []
if set_tags:
l.append(u"Annotation tag%s %s set." % (pluralize(set_tags), ", ".join(x.name for x in set_tags)))
if reset_tags:
l.append(u"Annotation tag%s %s cleared." % (pluralize(reset_tags), ", ".join(x.name for x in reset_tags)))
e.desc = " ".join(l)
e.save()
if send_email:
receivers = get_notification_receivers(doc, extra_notify)
send_mail(request, receivers, settings.DEFAULT_FROM_EMAIL,
u"Annotations tags changed for draft %s" % doc.name,
'ietfworkflows/annotation_tags_updated_mail.txt',
dict(doc=doc,
entry=dict(setted=", ".join(x.name for x in set_tags),
unsetted=", ".join(x.name for x in reset_tags),
change_date=doc.time,
person=person,
comment=comment)))
return
ctype = ContentType.objects.get_for_model(obj)
setted = []
resetted = []
for tag in set_tags:
if isinstance(tag, basestring):
if set_tag_by_name(obj, tag):
setted.append(tag)
else:
if set_tag(obj, tag):
setted.append(tag.name)
for tag in reset_tags:
if isinstance(tag, basestring):
if reset_tag_by_name(obj, tag):
resetted.append(tag)
else:
if reset_tag(obj, tag):
resetted.append(tag.name)
entry = ObjectAnnotationTagHistoryEntry.objects.create(
content_type=ctype,
content_id=obj.pk,
setted=','.join(setted),
unsetted=','.join(resetted),
date=datetime.datetime.now(),
comment=comment,
person=person)
notify_tag_entry(entry, extra_notify)
def update_state(request, doc, comment, person, to_state, added_tags, removed_tags, estimated_date=None, extra_notify=[]):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
doc = Document.objects.get(pk=doc.pk)
save_document_in_history(doc)
doc.time = datetime.datetime.now()
from_state = doc.get_state("draft-stream-%s" % doc.stream_id)
doc.set_state(to_state)
e = DocEvent(type="changed_document", time=doc.time, by=person, doc=doc)
e.desc = u"%s changed to <b>%s</b> from %s" % (to_state.type.label, to_state, from_state)
e.save()
# reminder
reminder_type = DocReminderTypeName.objects.get(slug="stream-s")
try:
reminder = DocReminder.objects.get(event__doc=doc, type=reminder_type,
active=True)
except DocReminder.DoesNotExist:
reminder = None
if estimated_date:
if not reminder:
reminder = DocReminder(type=reminder_type)
reminder.event = e
reminder.due = estimated_date
reminder.active = True
reminder.save()
elif reminder:
reminder.active = False
reminder.save()
set_tags=", ".join(x.name for x in added_tags)
reset_tags=", ".join(x.name for x in removed_tags)
receivers = get_notification_receivers(doc, extra_notify)
send_mail(request, receivers, settings.DEFAULT_FROM_EMAIL,
u"State changed for draft %s" % doc.name,
'ietfworkflows/state_updated_mail.txt',
dict(doc=doc,
entry=dict(from_state=from_state,
to_state=to_state,
transition_date=doc.time,
person=person,
comment=comment,
set_tags=set_tags,
reset_tags=reset_tags)))
if (to_state.slug=='sub-pub'):
receivers = get_pubreq_receivers(doc, extra_notify)
cc_receivers = get_pubreq_cc_receivers(doc)
send_mail(request, receivers, settings.DEFAULT_FROM_EMAIL,
u"Publication has been requested for draft %s" % doc.name,
'ietfworkflows/state_updated_mail.txt',
dict(doc=doc,
entry=dict(from_state=from_state,
to_state=to_state,
transition_date=doc.time,
person=person,
comment=comment)), cc=cc_receivers)
return
ctype = ContentType.objects.get_for_model(doc)
from_state = get_state_for_draft(doc)
to_state = set_state_for_draft(doc, to_state, estimated_date)
if not to_state:
return False
entry = ObjectWorkflowHistoryEntry.objects.create(
content_type=ctype,
content_id=doc.pk,
from_state=from_state and from_state.name or '',
to_state=to_state and to_state.name or '',
date=datetime.datetime.now(),
comment=comment,
person=person)
notify_state_entry(entry, extra_notify)
def update_stream(request, doc, comment, person, to_stream, extra_notify=[]):
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
doc = Document.objects.get(pk=doc.pk)
save_document_in_history(doc)
doc.time = datetime.datetime.now()
from_stream = doc.stream
doc.stream = to_stream
doc.save()
e = DocEvent(type="changed_stream", time=doc.time, by=person, doc=doc)
e.desc = u"Stream changed to <b>%s</b>" % to_stream.name
if from_stream:
e.desc += u"from %s" % from_stream.name
e.save()
receivers = get_notification_receivers(doc, extra_notify)
send_mail(request, receivers, settings.DEFAULT_FROM_EMAIL,
u"Stream changed for draft %s" % doc.name,
'ietfworkflows/stream_updated_mail.txt',
dict(doc=doc,
entry=dict(from_stream=from_stream,
to_stream=to_stream,
transition_date=doc.time,
person=person,
comment=comment)))
return
ctype = ContentType.objects.get_for_model(doc)
from_stream = get_stream_from_draft(doc)
to_stream = set_stream_for_draft(doc, to_stream)
entry = ObjectStreamHistoryEntry.objects.create(
content_type=ctype,
content_id=doc.pk,
from_stream=from_stream and from_stream.name or '',
to_stream=to_stream and to_stream.name or '',
date=datetime.datetime.now(),
comment=comment,
person=person)
notify_stream_entry(entry, extra_notify)
def get_full_info_for_draft(draft):
return dict(
streamed=get_streamed_draft(draft),
stream=get_stream_from_draft(draft),
workflow=get_workflow_for_draft(draft),
tags=[i.annotation_tag for i in get_annotation_tags_for_draft(draft)],
state=get_state_for_draft(draft),
shepherd=draft.shepherd if draft.shepherd_id else None,
)

150
ietf/ietfworkflows/views.py
View file

@ -1,150 +0,0 @@
from django.http import HttpResponseRedirect, HttpResponseForbidden
from django.shortcuts import get_object_or_404, render_to_response
from django.template import RequestContext
from django.conf import settings
from django.core.urlresolvers import reverse as urlreverse
from ietf.idtracker.models import InternetDraft
from ietf.ietfworkflows.models import Stream, StreamDelegate
from ietf.ietfworkflows.forms import (DraftTagsStateForm,
NoWorkflowStateForm,
StreamDelegatesForm)
from ietf.ietfworkflows.streams import (get_stream_from_draft,
get_streamed_draft)
from ietf.ietfworkflows.utils import (get_workflow_history_for_draft,
get_workflow_for_draft,
get_annotation_tags_for_draft,
get_state_for_draft)
from ietf.ietfworkflows.accounts import (can_edit_state, can_edit_stream,
is_chair_of_stream, can_adopt)
from ietf.doc.utils import get_tags_for_stream_id
from ietf.name.models import DocTagName
from ietf.group.utils import save_group_in_history
from ietf.group.models import Group, Role
REDUCED_HISTORY_LEN = 20
def stream_history(request, name):
draft = get_object_or_404(InternetDraft, filename=name)
streamed = get_streamed_draft(draft)
stream = get_stream_from_draft(draft)
workflow = get_workflow_for_draft(draft)
tags = []
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
used = list(draft.tags.all())
tags = DocTagName.objects.filter(slug__in=get_tags_for_stream_id(draft.stream_id))
for t in tags:
t.setted = t.slug in used
else:
if workflow:
tags_setted = [i.annotation_tag.pk for i in get_annotation_tags_for_draft(draft)]
for tag in workflow.get_tags():
tag.setted = tag.pk in tags_setted
tags.append(tag)
state = get_state_for_draft(draft)
history = get_workflow_history_for_draft(draft)
show_more = False
if len(history) > REDUCED_HISTORY_LEN:
show_more = True
return render_to_response('ietfworkflows/stream_history.html',
{'stream': stream,
'streamed': streamed,
'draft': draft,
'tags': tags,
'state': state,
'workflow': workflow,
'show_more': show_more,
'history': history[:REDUCED_HISTORY_LEN],
},
context_instance=RequestContext(request))
def _edit_draft_stream(request, draft, form_class=DraftTagsStateForm):
user = request.user
workflow = get_workflow_for_draft(draft)
if not workflow and form_class == DraftTagsStateForm:
form_class = NoWorkflowStateForm
if request.method == 'POST':
form = form_class(user=user, draft=draft, data=request.POST)
form.request = request
if request.POST.get("cancel",""):
return HttpResponseRedirect(draft.get_absolute_url())
if form.is_valid():
form.save()
# This behavior surprises folks. Let's try running awhile without it.
#if form_class == NoWorkflowStateForm and settings.USE_DB_REDESIGN_PROXY_CLASSES:
# return HttpResponseRedirect(urlreverse('ietf.ietfworkflows.views.edit_state', kwargs={ 'name': draft.filename } ))
return HttpResponseRedirect(draft.get_absolute_url())
else:
form = form_class(user=user, draft=draft)
form.request = request
state = get_state_for_draft(draft)
stream = get_stream_from_draft(draft)
history = get_workflow_history_for_draft(draft, 'objectworkflowhistoryentry')
tags = get_annotation_tags_for_draft(draft)
milestones = draft.groupmilestone_set.all()
return render_to_response('ietfworkflows/state_edit.html',
{'draft': draft,
'state': state,
'stream': stream,
'workflow': workflow,
'history': history,
'tags': tags,
'form': form,
'milestones': milestones,
},
context_instance=RequestContext(request))
# these three views are reusing the same view really, which apart from
# being somewhat obscure means that there are subtle bugs (like the
# title being wrong) - would probably be better to switch to a model
# where each part is edited on its own, we come from an overview page
# anyway, so there's not a big win in putting in a common
# overview/edit page here
def edit_adopt(request, name):
draft = get_object_or_404(InternetDraft, filename=name)
if not can_adopt(request.user, draft):
return HttpResponseForbidden("You don't have permission to access this view")
return _edit_draft_stream(request, draft, NoWorkflowStateForm)
def edit_state(request, name):
draft = get_object_or_404(InternetDraft, filename=name, stream__isnull=False)
if not can_edit_state(request.user, draft, ):
return HttpResponseForbidden("You don't have permission to access this view")
return _edit_draft_stream(request, draft, DraftTagsStateForm)
def stream_delegates(request, stream_name):
stream = get_object_or_404(Stream, name=stream_name)
if not is_chair_of_stream(request.user, stream):
return HttpResponseForbidden('You have no permission to access this view')
chairs = stream.get_chairs()
form = StreamDelegatesForm(stream=stream)
if request.method == 'POST':
if request.POST.get('delete', False):
pk_list = request.POST.getlist('remove_delegate')
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
stream_group = Group.objects.get(acronym=stream.slug)
save_group_in_history(stream_group)
Role.objects.filter(person__in=pk_list, group=stream_group, name="delegate").delete()
else:
StreamDelegate.objects.filter(stream=stream, person__pk__in=pk_list).delete()
else:
form = StreamDelegatesForm(request.POST, stream=stream)
if form.is_valid():
form.save()
form = StreamDelegatesForm(stream=stream)
delegates = stream.get_delegates()
return render_to_response('ietfworkflows/stream_delegates.html',
{'stream': stream,
'chairs': chairs,
'delegates': delegates,
'form': form,
},
context_instance=RequestContext(request))

5
ietf/liaisons/tests.py
View file

@ -91,10 +91,7 @@ def make_liaison_models():
return l
class LiaisonManagementTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
class LiaisonManagementTests(TestCase):
def setUp(self):
self.liaison_dir = os.path.abspath("tmp-liaison-dir")
try:

12
ietf/meeting/tests/view.py
View file

@ -13,12 +13,12 @@ from ietf.meeting.views import edit_agenda
class ViewTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = [ 'names.xml', # ietf/names/fixtures/names.xml for MeetingTypeName, and TimeSlotTypeName
'meeting83.json',
'constraint83.json',
'workinggroups.json',
'groupgroup.json',
'person.json', 'users.json' ]
perma_fixtures = [ 'names', # ietf/names/fixtures/names.xml for MeetingTypeName, and TimeSlotTypeName
'meeting83',
'constraint83',
'workinggroups',
'groupgroup',
'person', 'users' ]
def test_nameOfClueWg(self):
clue_session = Session.objects.get(pk=2194)

3756
ietf/name/fixtures/names.json Normal file
View file

File diff suppressed because it is too large Load diff

2280
ietf/name/fixtures/names.xml
View file

File diff suppressed because it is too large Load diff

13
ietf/name/generate_fixtures.py
View file

@ -17,8 +17,8 @@ from django.db.models import Q
def output(name, qs):
try:
f = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "fixtures/%s.xml" % name), 'w')
f.write(serialize("xml", qs, indent=4))
f = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), "fixtures/%s.json" % name), 'w')
f.write(serialize("json", qs, indent=1))
f.close()
except:
from django.db import connection
@ -29,12 +29,13 @@ def output(name, qs):
# pick all name models directly out of the module
objects = []
import inspect
import ietf.name.models
for n in dir(ietf.name.models):
if n[:1].upper() == n[:1] and n.endswith("Name"):
model = getattr(ietf.name.models, n)
if not model._meta.abstract:
objects.extend(model.objects.all())
symbol = getattr(ietf.name.models, n)
if inspect.isclass(symbol) and issubclass(symbol, ietf.name.models.NameModel):
if not symbol._meta.abstract:
objects.extend(symbol.objects.all())
import ietf.doc.models # also pick some other name-like types while we're at it

214
ietf/name/migrations/0018_auto__add_draftsubmissionstatename.py Normal file
View file

@ -0,0 +1,214 @@
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'DraftSubmissionStateName'
db.create_table('name_draftsubmissionstatename', (
('slug', self.gf('django.db.models.fields.CharField')(max_length=8, primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(max_length=255)),
('desc', self.gf('django.db.models.fields.TextField')(blank=True)),
('used', self.gf('django.db.models.fields.BooleanField')(default=True)),
('order', self.gf('django.db.models.fields.IntegerField')(default=0)),
))
db.send_create_signal('name', ['DraftSubmissionStateName'])
# Adding M2M table for field next_states on 'DraftSubmissionStateName'
db.create_table('name_draftsubmissionstatename_next_states', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('from_draftsubmissionstatename', models.ForeignKey(orm['name.draftsubmissionstatename'], null=False)),
('to_draftsubmissionstatename', models.ForeignKey(orm['name.draftsubmissionstatename'], null=False))
))
db.create_unique('name_draftsubmissionstatename_next_states', ['from_draftsubmissionstatename_id', 'to_draftsubmissionstatename_id'])
def backwards(self, orm):
# Deleting model 'DraftSubmissionStateName'
db.delete_table('name_draftsubmissionstatename')
# Removing M2M table for field next_states on 'DraftSubmissionStateName'
db.delete_table('name_draftsubmissionstatename_next_states')
models = {
'name.ballotpositionname': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotPositionName'},
'blocking': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.constraintname': {
'Meta': {'ordering': "['order']", 'object_name': 'ConstraintName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'penalty': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.dbtemplatetypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DBTemplateTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docrelationshipname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocRelationshipName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'revname': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docremindertypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocReminderTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctagname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTagName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.draftsubmissionstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'DraftSubmissionStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'next_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'previous_states'", 'blank': 'True', 'to': "orm['name.DraftSubmissionStateName']"}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.feedbacktype': {
'Meta': {'ordering': "['order']", 'object_name': 'FeedbackType'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupmilestonestatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupMilestoneStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.grouptypename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.intendedstdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'IntendedStdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.liaisonstatementpurposename': {
'Meta': {'ordering': "['order']", 'object_name': 'LiaisonStatementPurposeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.meetingtypename': {
'Meta': {'ordering': "['order']", 'object_name': 'MeetingTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.nomineepositionstate': {
'Meta': {'ordering': "['order']", 'object_name': 'NomineePositionState'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.rolename': {
'Meta': {'ordering': "['order']", 'object_name': 'RoleName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.sessionstatusname': {
'Meta': {'ordering': "['order']", 'object_name': 'SessionStatusName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.stdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'StdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.streamname': {
'Meta': {'ordering': "['order']", 'object_name': 'StreamName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.timeslottypename': {
'Meta': {'ordering': "['order']", 'object_name': 'TimeSlotTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
}
}
complete_apps = ['name']

204
ietf/name/migrations/0019_populate_draftsubmissionstate.py Normal file
View file

@ -0,0 +1,204 @@
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import DataMigration
from django.db import models
class Migration(DataMigration):
def forwards(self, orm):
uploaded, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="uploaded", order=1, name="Uploaded")
submitter, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="auth", order=2, name="Awaiting Submitter Authentication")
author_approval, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="aut-appr", order=3, name="Awaiting Approval from Previous Version Authors'")
group_approval, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="grp-appr", order=4, name="Awaiting Initial Version Approval")
manual_post, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="manual", order=5, name="Awaiting Manual Post")
cancel, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="cancel", order=6, name="Cancelled")
posted, _ = orm.DraftSubmissionStateName.objects.get_or_create(slug="posted", order=7, name="Posted")
uploaded.next_states = [submitter, author_approval, group_approval, manual_post, cancel]
submitter.next_states = [cancel, posted]
author_approval.next_states = [cancel, posted]
group_approval.next_states = [cancel, posted]
manual_post.next_states = [cancel, posted]
def backwards(self, orm):
"Write your backwards methods here."
models = {
'name.ballotpositionname': {
'Meta': {'ordering': "['order']", 'object_name': 'BallotPositionName'},
'blocking': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.constraintname': {
'Meta': {'ordering': "['order']", 'object_name': 'ConstraintName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'penalty': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.dbtemplatetypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DBTemplateTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docrelationshipname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocRelationshipName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'revname': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.docremindertypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocReminderTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctagname': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTagName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.doctypename': {
'Meta': {'ordering': "['order']", 'object_name': 'DocTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.draftsubmissionstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'DraftSubmissionStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'next_states': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'previous_states'", 'blank': 'True', 'to': "orm['name.DraftSubmissionStateName']"}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.feedbacktype': {
'Meta': {'ordering': "['order']", 'object_name': 'FeedbackType'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupmilestonestatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupMilestoneStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.groupstatename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupStateName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.grouptypename': {
'Meta': {'ordering': "['order']", 'object_name': 'GroupTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.intendedstdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'IntendedStdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.liaisonstatementpurposename': {
'Meta': {'ordering': "['order']", 'object_name': 'LiaisonStatementPurposeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.meetingtypename': {
'Meta': {'ordering': "['order']", 'object_name': 'MeetingTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.nomineepositionstate': {
'Meta': {'ordering': "['order']", 'object_name': 'NomineePositionState'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.rolename': {
'Meta': {'ordering': "['order']", 'object_name': 'RoleName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.sessionstatusname': {
'Meta': {'ordering': "['order']", 'object_name': 'SessionStatusName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.stdlevelname': {
'Meta': {'ordering': "['order']", 'object_name': 'StdLevelName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.streamname': {
'Meta': {'ordering': "['order']", 'object_name': 'StreamName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
},
'name.timeslottypename': {
'Meta': {'ordering': "['order']", 'object_name': 'TimeSlotTypeName'},
'desc': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '8', 'primary_key': 'True'}),
'used': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
}
}
complete_apps = ['name']

5
ietf/name/models.py
View file

@ -66,3 +66,8 @@ class FeedbackType(NameModel):
"""Type of feedback: questionnaires, nominations, comments"""
class DBTemplateTypeName(NameModel):
"""reStructuredText, Plain, Django"""
class DraftSubmissionStateName(NameModel):
"""Uploaded, Awaiting Submitter Authentication, Awaiting Approval from
Previous Version Authors, Awaiting Initial Version Approval, Awaiting
Manual Post, Cancelled, Posted"""
next_states = models.ManyToManyField('DraftSubmissionStateName', related_name="previous_states", blank=True)

2
ietf/nomcom/models.py
View file

@ -1,4 +1,4 @@
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
import os
from django.db import models

2
ietf/nomcom/templatetags/nomcom_tags.py
View file

@ -25,7 +25,7 @@ def is_chair(user, year):
nomcom = get_nomcom_by_year(year=year)
if has_role(user, "Secretariat"):
return True
return nomcom.group.is_chair(user)
return nomcom.group.has_role(user, "chair")
@register.filter

8
ietf/nomcom/tests.py
View file

@ -30,7 +30,7 @@ from ietf.nomcom.management.commands.send_reminders import Command, is_time_to_s
class NomcomViewsTest(TestCase):
"""Tests to create a new nomcom"""
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names', 'nomcom_templates']
perma_fixtures = ['nomcom_templates']
def check_url_status(self, url, status):
response = self.client.get(url)
@ -595,7 +595,7 @@ class NomcomViewsTest(TestCase):
class NomineePositionStateSaveTest(TestCase):
"""Tests for the NomineePosition save override method"""
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names', 'nomcom_templates']
perma_fixtures = ['nomcom_templates']
def setUp(self):
nomcom_test_data()
@ -627,7 +627,7 @@ class NomineePositionStateSaveTest(TestCase):
class FeedbackTest(TestCase):
perma_fixtures = ['names', 'nomcom_templates']
perma_fixtures = ['nomcom_templates']
def setUp(self):
nomcom_test_data()
@ -659,7 +659,7 @@ class FeedbackTest(TestCase):
os.unlink(self.cert_file.name)
class ReminderTest(TestCase):
perma_fixtures = ['names', 'nomcom_templates']
perma_fixtures = ['nomcom_templates']
def setUp(self):
nomcom_test_data()

12
ietf/nomcom/utils.py
View file

@ -84,18 +84,6 @@ def get_user_email(user):
pass
return user._email_cache
def is_nomcom_member(user, nomcom):
is_group_member = nomcom.group.is_member(user)
if not is_group_member:
raise PermissionDenied("Must be nomcom member")
def is_nomcom_chair(user, nomcom):
is_group_chair = nomcom.group.is_chair(user)
if not is_group_chair:
raise PermissionDenied("Must be nomcom chair")
def get_hash_nominee_position(date, nominee_position_id):
return hashlib.md5('%s%s%s' % (settings.SECRET_KEY, date, nominee_position_id)).hexdigest()

4
ietf/nomcom/views.py
View file

@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
import datetime
@ -101,7 +101,7 @@ def private_key(request, year):
def private_index(request, year):
nomcom = get_nomcom_by_year(year)
all_nominee_positions = NomineePosition.objects.get_by_nomcom(nomcom).not_duplicated()
is_chair = nomcom.group.is_chair(request.user)
is_chair = nomcom.group.has_role(request.user, "chair")
message = None
if is_chair and request.method == 'POST':
action = request.POST.get('action')

3
ietf/secr/announcement/forms.py
View file

@ -7,7 +7,6 @@ from ietf.secr.utils.group import current_nomcom
from ietf.message.models import Message
from ietf.ietfauth.decorators import has_role
from ietf.wgchairs.accounts import get_person_for_user
# ---------------------------------------------
# Globals
@ -185,7 +184,7 @@ class AnnounceForm(forms.ModelForm):
def save(self, *args, **kwargs):
user = kwargs.pop('user')
message = super(AnnounceForm, self).save(commit=False)
message.by = get_person_for_user(user)
message.by = user.get_profile()
if self.cleaned_data['to'] == 'Other...':
message.to = self.cleaned_data['to_custom']
if kwargs['commit']:

7
ietf/secr/announcement/tests.py
View file

@ -22,9 +22,6 @@ AD_USER=''
class MainTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
# ------- Test View -------- #
def test_main(self):
"Main Test"
@ -37,8 +34,6 @@ class DummyCase(TestCase):
name = connection.settings_dict['NAME']
class UnauthorizedCase(TestCase):
perma_fixtures = ['names']
def test_unauthorized(self):
"Unauthorized Test"
draft = make_test_data()
@ -48,8 +43,6 @@ class UnauthorizedCase(TestCase):
self.assertEquals(r.status_code, 403)
class SubmitCase(TestCase):
perma_fixtures = ['names']
def test_invalid_submit(self):
"Invalid Submit"
draft = make_test_data()

3
ietf/secr/announcement/views.py
View file

@ -6,7 +6,6 @@ from django.template import RequestContext
from ietf.ietfauth.decorators import has_role
from ietf.utils.mail import send_mail_text
from ietf.wgchairs.accounts import get_person_for_user
from ietf.group.models import Group
from ietf.secr.utils.group import current_nomcom
from ietf.secr.utils.decorators import check_for_cancel
@ -111,4 +110,4 @@ def confirm(request):
'message': data,
'to': to},
RequestContext(request, {}),
)
)

2
ietf/secr/areas/tests.py
View file

@ -22,7 +22,7 @@ def augment_data():
class MainTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names', 'persons', 'groupgroup', 'groupevents']
perma_fixtures = ['persons', 'groupgroup', 'groupevents']
def test_main(self):
"Main Test"

13
ietf/secr/drafts/email.py
View file

@ -78,19 +78,6 @@ def get_abbr_authors(draft):
return result
def get_authors_email(draft):
"""
Takes a draft object and returns a string of authors suitable for an email to or cc field
"""
authors = []
for a in draft.authors.all():
initial = ''
if a.person.first_name:
initial = a.person.first_name[0] + '. '
entry = '%s%s <%s>' % (initial,a.person.last_name,a.person.email())
authors.append(entry)
return ', '.join(authors)
def get_last_revision(filename):
"""
This function takes a filename, in the same form it appears in the InternetDraft record,

2
ietf/secr/drafts/forms.py
View file

@ -375,7 +375,7 @@ class UploadForm(forms.Form):
# ensure that the basename is unique
base = splitext(txt.name)[0]
if Document.objects.filter(name=base[:-3]):
raise forms.ValidationError, "This doucment filename already exists: %s" % base[:-3]
raise forms.ValidationError, "This document filename already exists: %s" % base[:-3]
# ensure that rev is 00
if base[-2:] != '00':

5
ietf/secr/drafts/tests.py
View file

@ -9,9 +9,6 @@ from pyquery import PyQuery
SECR_USER='secretary'
class MainTestCase(TestCase):
# See ietf.utils.test_utils.TestCase for the use of perma_fixtures vs. fixtures
perma_fixtures = ['names']
def test_main(self):
"Main Test"
draft = make_test_data()
@ -25,4 +22,4 @@ class MainTestCase(TestCase):
drafts = Document.objects.filter(type='draft')
url = reverse('drafts_view', kwargs={'id':drafts[0].name})
response = self.client.get(url, REMOTE_USER=SECR_USER)
self.assertEquals(response.status_code, 200)
self.assertEquals(response.status_code, 200)

50
ietf/secr/drafts/views.py
View file

@ -17,7 +17,7 @@ from ietf.meeting.models import Meeting
from ietf.name.models import StreamName
from ietf.doc.models import Document, DocumentAuthor
from ietf.doc.utils import augment_with_start_time
from ietf.submit.models import IdSubmissionDetail, Preapproval
from ietf.submit.models import Submission, Preapproval, DraftSubmissionStateName, SubmissionEvent
from ietf.utils.draft import Draft
from ietf.secr.proceedings.proc_utils import get_progress_stats
from ietf.secr.sreq.views import get_meeting
@ -107,7 +107,7 @@ def process_files(request,draft):
the basename, revision number and a list of file types. Basename and revision
are assumed to be the same for all because this is part of the validation process.
It also creates the IdSubmissionDetail record WITHOUT saving, and places it in the
It also creates the Submission record WITHOUT saving, and places it in the
session for saving in the final action step.
'''
files = request.FILES
@ -124,29 +124,37 @@ def process_files(request,draft):
wrapper = Draft(file.read(),file.name)
handle_uploaded_file(file)
# create IdSubmissionDetail record, leaved unsaved
idsub = IdSubmissionDetail(
id_document_name=draft.title,
filename=basename,
revision=revision,
txt_page_count=draft.pages,
filesize=txt_size,
creation_date=wrapper.get_creation_date(),
# create Submission record, leaved unsaved
idsub = Submission(
name=basename,
title=draft.title,
rev=revision,
pages=draft.pages,
file_size=txt_size,
document_date=wrapper.get_creation_date(),
submission_date=datetime.date.today(),
idnits_message='idnits bypassed by manual posting',
temp_id_document_tag=None,
group_acronym_id=draft.group.id,
group_id=draft.group.id,
remote_ip=request.META['REMOTE_ADDR'],
first_two_pages=''.join(wrapper.pages[:2]),
status_id=-2,
state=DraftSubmissionStateName.objects.get(slug="posted"),
abstract=draft.abstract,
file_type=','.join(file_type_list),
man_posted_date=datetime.date.today(),
man_posted_by=request.user.get_profile())
file_types=','.join(file_type_list),
)
request.session['idsub'] = idsub
return (filename,revision,file_type_list)
def post_submission(request):
submission = request.session['idsub']
submission.save()
SubmissionEvent.objects.create(
submission=submission,
by=request.user.person,
desc="Submitted and posted manually")
def promote_files(draft, types):
'''
This function takes one argument, a draft object. It then moves the draft files from
@ -307,8 +315,8 @@ def do_revision(draft, request):
promote_files(new_draft, request.session['file_type'])
# save the submission record
request.session['idsub'].save()
post_submission(request)
# send announcement if we are in IESG process
if new_draft.get_state('draft-iesg'):
announcement_from_form(request.session['email'],by=request.user.get_profile())
@ -355,8 +363,8 @@ def do_update(draft,request):
promote_files(new_draft, request.session['file_type'])
# save the submission record
request.session['idsub'].save()
post_submission(request)
# send announcement
announcement_from_form(request.session['email'],by=request.user.get_profile())
@ -580,7 +588,7 @@ def add(request):
promote_files(draft, file_type_list)
# save the submission record
request.session['idsub'].save()
post_submission(request)
request.session['action'] = 'add'

Some files were not shown because too many files have changed in this diff Show more