392 lines
18 KiB
Python
392 lines
18 KiB
Python
# Copyright The IETF Trust 2007, All Rights Reserved
|
|
|
|
import re
|
|
import models
|
|
import ietf.utils
|
|
from django import forms
|
|
|
|
from datetime import datetime
|
|
from django.shortcuts import render_to_response as render, get_object_or_404
|
|
from django.template import RequestContext
|
|
from django.http import Http404
|
|
from django.conf import settings
|
|
from ietf.utils import log
|
|
from ietf.utils.mail import send_mail
|
|
from ietf.ipr.view_sections import section_table
|
|
from ietf.idtracker.models import Rfc, InternetDraft
|
|
|
|
# ----------------------------------------------------------------
|
|
# Create base forms from models
|
|
# ----------------------------------------------------------------
|
|
|
|
phone_re = re.compile(r'^\+?[0-9 ]*(\([0-9]+\))?[0-9 -]+( ?x ?[0-9]+)?$')
|
|
phone_error_message = """Phone numbers may have a leading "+", and otherwise only contain numbers [0-9]; dash, period or space; parentheses, and an optional extension number indicated by 'x'."""
|
|
|
|
from django.forms import ModelForm
|
|
|
|
class BaseIprForm(ModelForm):
|
|
licensing_option = forms.IntegerField(widget=forms.RadioSelect(choices=models.LICENSE_CHOICES), required=False)
|
|
is_pending = forms.IntegerField(widget=forms.RadioSelect(choices=((1, "YES"), (2, "NO"))), required=False)
|
|
applies_to_all = forms.IntegerField(widget=forms.RadioSelect(choices=((1, "YES"), (2, "NO"))), required=False)
|
|
class Meta:
|
|
model = models.IprDetail
|
|
exclude = ('rfc_document', 'id_document_tag') # 'legacy_url_0','legacy_url_1','legacy_title_1','legacy_url_2','legacy_title_2')
|
|
|
|
class BaseContactForm(ModelForm):
|
|
telephone = forms.RegexField(phone_re, error_message=phone_error_message)
|
|
fax = forms.RegexField(phone_re, error_message=phone_error_message, required=False)
|
|
class Meta:
|
|
model = models.IprContact
|
|
exclude = ('ipr', 'contact_type')
|
|
|
|
# Some subclassing:
|
|
|
|
# The contact form will be part of the IprForm, so it needs a widget.
|
|
# Define one.
|
|
class MultiformWidget(forms.Widget):
|
|
def value_from_datadict(self, data, name):
|
|
return data
|
|
|
|
class ContactForm(BaseContactForm):
|
|
widget = MultiformWidget()
|
|
|
|
def add_prefix(self, field_name):
|
|
return self.prefix and ('%s_%s' % (self.prefix, field_name)) or field_name
|
|
|
|
|
|
# ----------------------------------------------------------------
|
|
# Form processing
|
|
# ----------------------------------------------------------------
|
|
|
|
def new(request, type, update=None, submitter=None):
|
|
"""Make a new IPR disclosure.
|
|
|
|
This is a big function -- maybe too big. Things would be easier if we didn't have
|
|
one form containing fields from 4 tables -- don't build something like this again...
|
|
|
|
"""
|
|
debug = ""
|
|
|
|
section_list = section_table[type].copy()
|
|
section_list.update({"title":False, "new_intro":False, "form_intro":True,
|
|
"form_submit":True, "form_legend": True, })
|
|
|
|
class IprForm(BaseIprForm):
|
|
holder_contact = None
|
|
rfclist = forms.CharField(required=False)
|
|
draftlist = forms.CharField(required=False)
|
|
stdonly_license = forms.BooleanField(required=False)
|
|
hold_contact_is_submitter = forms.BooleanField(required=False)
|
|
ietf_contact_is_submitter = forms.BooleanField(required=False)
|
|
if section_list.get("holder_contact", False):
|
|
holder_contact = ContactForm(prefix="hold")
|
|
if section_list.get("ietf_contact", False):
|
|
ietf_contact = ContactForm(prefix="ietf")
|
|
if section_list.get("submitter", False):
|
|
submitter = ContactForm(prefix="subm")
|
|
def __init__(self, *args, **kw):
|
|
contact_type = {1:"holder_contact", 2:"ietf_contact", 3:"submitter"}
|
|
contact_initial = {}
|
|
if update:
|
|
for contact in update.contact.all():
|
|
contact_initial[contact_type[contact.contact_type]] = contact.__dict__
|
|
if submitter:
|
|
if type == "third-party":
|
|
contact_initial["ietf_contact"] = submitter
|
|
else:
|
|
contact_initial["submitter"] = submitter
|
|
kwnoinit = kw.copy()
|
|
kwnoinit.pop('initial', None)
|
|
for contact in ["holder_contact", "ietf_contact", "submitter"]:
|
|
if section_list.get(contact, False):
|
|
setattr(self, contact, ContactForm(prefix=contact[:4], initial=contact_initial.get(contact, {}), *args, **kwnoinit))
|
|
rfclist_initial = ""
|
|
if update:
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
from ietf.ipr.models import IprDocAlias
|
|
rfclist_initial = " ".join(a.doc_alias.name.upper() for a in IprDocAlias.objects.filter(doc_alias__name__startswith="rfc", ipr=update))
|
|
else:
|
|
rfclist_initial = " ".join(["RFC%d" % rfc.document_id for rfc in update.rfcs.all()])
|
|
self.base_fields["rfclist"] = forms.CharField(required=False, initial=rfclist_initial)
|
|
draftlist_initial = ""
|
|
if update:
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
from ietf.ipr.models import IprDocAlias
|
|
draftlist_initial = " ".join(a.doc_alias.name + ("-%s" % a.rev if a.rev else "") for a in IprDocAlias.objects.filter(ipr=update).exclude(doc_alias__name__startswith="rfc"))
|
|
else:
|
|
draftlist_initial = " ".join([draft.document.filename + (draft.revision and "-%s" % draft.revision or "") for draft in update.drafts.all()])
|
|
self.base_fields["draftlist"] = forms.CharField(required=False, initial=draftlist_initial)
|
|
if section_list.get("holder_contact", False):
|
|
self.base_fields["hold_contact_is_submitter"] = forms.BooleanField(required=False)
|
|
if section_list.get("ietf_contact", False):
|
|
self.base_fields["ietf_contact_is_submitter"] = forms.BooleanField(required=False)
|
|
self.base_fields["stdonly_license"] = forms.BooleanField(required=False)
|
|
|
|
BaseIprForm.__init__(self, *args, **kw)
|
|
# Special validation code
|
|
def clean(self):
|
|
if section_list.get("ietf_doc", False):
|
|
# would like to put this in rfclist to get the error
|
|
# closer to the fields, but clean_data["draftlist"]
|
|
# isn't set yet.
|
|
rfclist = self.cleaned_data.get("rfclist", None)
|
|
draftlist = self.cleaned_data.get("draftlist", None)
|
|
other = self.cleaned_data.get("other_designations", None)
|
|
if not rfclist and not draftlist and not other:
|
|
raise forms.ValidationError("One of the Document fields below must be filled in")
|
|
return self.cleaned_data
|
|
def clean_rfclist(self):
|
|
rfclist = self.cleaned_data.get("rfclist", None)
|
|
if rfclist:
|
|
rfclist = re.sub("(?i) *[,;]? *rfc[- ]?", " ", rfclist)
|
|
rfclist = rfclist.strip().split()
|
|
for rfc in rfclist:
|
|
try:
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
from ietf.doc.models import DocAlias
|
|
DocAlias.objects.get(name="rfc%s" % int(rfc))
|
|
else:
|
|
Rfc.objects.get(rfc_number=int(rfc))
|
|
except:
|
|
raise forms.ValidationError("Unknown RFC number: %s - please correct this." % rfc)
|
|
rfclist = " ".join(rfclist)
|
|
return rfclist
|
|
def clean_draftlist(self):
|
|
draftlist = self.cleaned_data.get("draftlist", None)
|
|
if draftlist:
|
|
draftlist = re.sub(" *[,;] *", " ", draftlist)
|
|
draftlist = draftlist.strip().split()
|
|
drafts = []
|
|
for draft in draftlist:
|
|
if draft.endswith(".txt"):
|
|
draft = draft[:-4]
|
|
if re.search("-[0-9][0-9]$", draft):
|
|
filename = draft[:-3]
|
|
rev = draft[-2:]
|
|
else:
|
|
filename = draft
|
|
rev = None
|
|
try:
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
from ietf.doc.models import DocAlias
|
|
id = DocAlias.objects.get(name=filename)
|
|
# proxy attribute for code below
|
|
id.revision = id.document.rev
|
|
else:
|
|
id = InternetDraft.objects.get(filename=filename)
|
|
except Exception, e:
|
|
log("Exception: %s" % e)
|
|
raise forms.ValidationError("Unknown Internet-Draft: %s - please correct this." % filename)
|
|
if rev and id.revision != rev:
|
|
raise forms.ValidationError("Unexpected revision '%s' for draft %s - the current revision is %s. Please check this." % (rev, filename, id.revision))
|
|
drafts.append("%s-%s" % (filename, id.revision))
|
|
return " ".join(drafts)
|
|
return ""
|
|
def clean_licensing_option(self):
|
|
licensing_option = self.cleaned_data['licensing_option']
|
|
if section_list.get('licensing', False):
|
|
if licensing_option in (None, ''):
|
|
raise forms.ValidationError, 'This field is required.'
|
|
return licensing_option
|
|
def is_valid(self):
|
|
if not BaseIprForm.is_valid(self):
|
|
return False
|
|
for contact in ["holder_contact", "ietf_contact", "submitter"]:
|
|
if hasattr(self, contact) and getattr(self, contact) != None and not getattr(self, contact).is_valid():
|
|
return False
|
|
return True
|
|
|
|
# If we're POSTed, but we got passed a submitter, it was the
|
|
# POST of the "get updater" form, so we don't want to validate
|
|
# this one. When we're posting *this* form, submitter is None,
|
|
# even when updating.
|
|
if (request.method == 'POST' or '_testpost' in request.REQUEST) and not submitter:
|
|
if request.method == 'POST':
|
|
data = request.POST.copy()
|
|
else:
|
|
data = request.GET.copy()
|
|
data["submitted_date"] = datetime.now().strftime("%Y-%m-%d")
|
|
data["third_party"] = section_list["third_party"]
|
|
data["generic"] = section_list["generic"]
|
|
data["status"] = "0"
|
|
data["comply"] = "1"
|
|
|
|
for src in ["hold", "ietf"]:
|
|
if "%s_contact_is_submitter" % src in data:
|
|
for subfield in ["name", "title", "department", "address1", "address2", "telephone", "fax", "email"]:
|
|
try:
|
|
data[ "subm_%s" % subfield ] = data[ "%s_%s" % (src,subfield) ]
|
|
except Exception, e:
|
|
#log("Caught exception: %s"%e)
|
|
pass
|
|
form = IprForm(data)
|
|
if form.is_valid():
|
|
# Save data :
|
|
# IprDetail, IprUpdate, IprContact+, IprDraft+, IprRfc+, IprNotification
|
|
|
|
# Save IprDetail
|
|
instance = form.save(commit=False)
|
|
|
|
legal_name_genitive = data['legal_name'] + "'" if data['legal_name'].endswith('s') else data['legal_name'] + "'s"
|
|
if type == "generic":
|
|
instance.title = legal_name_genitive + " General License Statement"
|
|
if type == "specific":
|
|
data["ipr_summary"] = get_ipr_summary(form.cleaned_data)
|
|
instance.title = legal_name_genitive + """ Statement about IPR related to %(ipr_summary)s""" % data
|
|
if type == "third-party":
|
|
data["ipr_summary"] = get_ipr_summary(form.cleaned_data)
|
|
ietf_name_genitive = data['ietf_name'] + "'" if data['ietf_name'].endswith('s') else data['ietf_name'] + "'s"
|
|
instance.title = ietf_name_genitive + """ Statement about IPR related to %(ipr_summary)s belonging to %(legal_name)s""" % data
|
|
|
|
# A long document list can create a too-long title;
|
|
# saving a too-long title raises an exception,
|
|
# so prevent truncation in the database layer by
|
|
# performing it explicitly.
|
|
if len(instance.title) > 255:
|
|
instance.title = instance.title[:252] + "..."
|
|
|
|
instance.save()
|
|
|
|
if update:
|
|
updater = models.IprUpdate(ipr=instance, updated=update, status_to_be=1, processed=0)
|
|
updater.save()
|
|
contact_type = {"hold":1, "ietf":2, "subm": 3}
|
|
|
|
# Save IprContact(s)
|
|
for prefix in ["hold", "ietf", "subm"]:
|
|
# cdata = {"ipr": instance.ipr_id, "contact_type":contact_type[prefix]}
|
|
cdata = {"ipr": instance, "contact_type":contact_type[prefix]}
|
|
for item in data:
|
|
if item.startswith(prefix+"_"):
|
|
cdata[item[5:]] = data[item]
|
|
try:
|
|
del cdata["contact_is_submitter"]
|
|
except KeyError:
|
|
pass
|
|
contact = models.IprContact(**dict([(str(a),b) for a,b in cdata.items()]))
|
|
contact.save()
|
|
# store this contact in the instance for the email
|
|
# similar to what views.show() does
|
|
if prefix == "hold":
|
|
instance.holder_contact = contact
|
|
elif prefix == "ietf":
|
|
instance.ietf_contact = contact
|
|
elif prefix == "subm":
|
|
instance.submitter = contact
|
|
# contact = ContactForm(cdata)
|
|
# if contact.is_valid():
|
|
# contact.save()
|
|
# else:
|
|
# log("Invalid contact: %s" % contact)
|
|
|
|
# Save IprDraft(s)
|
|
for draft in form.cleaned_data["draftlist"].split():
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
name = draft[:-3]
|
|
rev = draft[-2:]
|
|
|
|
from ietf.doc.models import DocAlias
|
|
models.IprDocAlias.objects.create(
|
|
doc_alias=DocAlias.objects.get(name=name),
|
|
ipr=instance,
|
|
rev=rev)
|
|
else:
|
|
id = InternetDraft.objects.get(filename=draft[:-3])
|
|
iprdraft = models.IprDraft(document=id, ipr=instance, revision=draft[-2:])
|
|
iprdraft.save()
|
|
|
|
# Save IprRfc(s)
|
|
for rfcnum in form.cleaned_data["rfclist"].split():
|
|
if settings.USE_DB_REDESIGN_PROXY_CLASSES:
|
|
from ietf.doc.models import DocAlias
|
|
models.IprDocAlias.objects.create(
|
|
doc_alias=DocAlias.objects.get(name="rfc%s" % int(rfcnum)),
|
|
ipr=instance,
|
|
rev="")
|
|
else:
|
|
rfc = Rfc.objects.get(rfc_number=int(rfcnum))
|
|
iprrfc = models.IprRfc(document=rfc, ipr=instance)
|
|
iprrfc.save()
|
|
|
|
send_mail(request, settings.IPR_EMAIL_TO, ('IPR Submitter App', 'ietf-ipr@ietf.org'), 'New IPR Submission Notification', "ipr/new_update_email.txt", {"ipr": instance, "update": update})
|
|
return render("ipr/submitted.html", {"update": update}, context_instance=RequestContext(request))
|
|
else:
|
|
if 'ietf_contact_is_submitter' in data:
|
|
form.ietf_contact_is_submitter_checked = True
|
|
if 'hold_contact_is_submitter' in data:
|
|
form.hold_contact_is_submitter_checked = True
|
|
|
|
for error in form.errors:
|
|
log("Form error for field: %s: %s"%(error, form.errors[error]))
|
|
# Fall through, and let the partially bound form, with error
|
|
# indications, be rendered again.
|
|
pass
|
|
else:
|
|
if update:
|
|
form = IprForm(initial=update.__dict__)
|
|
else:
|
|
form = IprForm()
|
|
form.unbound_form = True
|
|
|
|
# ietf.utils.log(dir(form.ietf_contact_is_submitter))
|
|
return render("ipr/details_edit.html", {"ipr": form, "section_list":section_list, "debug": debug}, context_instance=RequestContext(request))
|
|
|
|
def update(request, ipr_id=None):
|
|
"""Update a specific IPR disclosure"""
|
|
ipr = get_object_or_404(models.IprDetail, ipr_id=ipr_id)
|
|
if not ipr.status in [1,3]:
|
|
raise Http404
|
|
type = "specific"
|
|
if ipr.generic:
|
|
type = "generic"
|
|
if ipr.third_party:
|
|
type = "third-party"
|
|
# We're either asking for initial permission or we're in
|
|
# the general ipr form. If the POST argument has the first
|
|
# field of the ipr form, then we must be dealing with that,
|
|
# so just pass through - otherwise, collect the updater's
|
|
# info first.
|
|
submitter = None
|
|
if not(request.POST.has_key('legal_name')):
|
|
class UpdateForm(BaseContactForm):
|
|
def __init__(self, *args, **kwargs):
|
|
super(UpdateForm, self).__init__(*args, **kwargs)
|
|
self.fields["update_auth"] = forms.BooleanField()
|
|
|
|
if request.method == 'POST':
|
|
form = UpdateForm(request.POST)
|
|
elif '_testpost' in request.REQUEST:
|
|
form = UpdateForm(request.GET)
|
|
else:
|
|
form = UpdateForm()
|
|
|
|
if not(form.is_valid()):
|
|
for error in form.errors:
|
|
log("Form error for field: %s: %s"%(error, form.errors[error]))
|
|
return render("ipr/update.html", {"form": form, "ipr": ipr, "type": type}, context_instance=RequestContext(request))
|
|
else:
|
|
submitter = form.cleaned_data
|
|
|
|
return new(request, type, ipr, submitter)
|
|
|
|
|
|
def get_ipr_summary(data):
|
|
|
|
rfc_ipr = [ "RFC %s" % item for item in data["rfclist"].split() ]
|
|
draft_ipr = data["draftlist"].split()
|
|
ipr = rfc_ipr + draft_ipr
|
|
if data["other_designations"]:
|
|
ipr += [ data["other_designations"] ]
|
|
|
|
if len(ipr) == 1:
|
|
ipr = ipr[0]
|
|
elif len(ipr) == 2:
|
|
ipr = " and ".join(ipr)
|
|
else:
|
|
ipr = ", ".join(ipr[:-1]) + ", and " + ipr[-1]
|
|
|
|
return ipr
|
|
|
|
# changes done by convert-096.py:changed newforms to forms
|
|
# cleaned_data
|