class ProjectForm(forms.Form):
  name = forms.CharField(label='项目名称', max_length=20)

class Form(six.with_metaclass(DeclarativeFieldsMetaclass, BaseForm)):
  "A collection of Fields, plus their associated data."
  # This is a separate class from BaseForm in order to abstract the way
  # self.fields is specified. This class (Form) is the one that does the
  # fancy metaclass stuff purely for the semantic sugar -- it allows one
  # to define a form using declarative syntax.
  # BaseForm itself has no way of designating self.fields.

class BaseForm(object):
  def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
         initial=None, error_class=ErrorList, label_suffix=None,
         empty_permitted=False, field_order=None, use_required_attribute=None):
    #data参数用于接收request.POST字典，如果是GET方法就不传
	self.data = data or {}
	#files用于接收request.FILES，也就是处理上传文件
	self.files = files or {}
	#本篇文章的重点在于多个表单集成到一个form中，此时为防止有同名的field，需要加prefix前缀
    if prefix is not None:
      self.prefix = prefix
	#GET显示表单时，如果要显示初始值，请用initial参数
    self.initial = initial or {}
 
  #模板中显示{{form}}时，默认是以<table></table>显示的
  def __str__(self):
    return self.as_table()
 
  #如果模板中不想写重复代码，只以固定的格式来显示每一个field，那么就用{% for field, val in form %}来遍历处理吧
  def __iter__(self):
    for name in self.fields:
      yield self[name]
 
  #如果传入了prefix参数，html中每个field的name和id里都会加上prefix前缀
  def add_prefix(self, field_name):
    return '%s-%s' % (self.prefix, field_name) if self.prefix else field_name
 
  #模板中以html格式显示form就靠这个方法
  def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):
    "Helper function for outputting HTML. Used by as_table(), as_ul(), as_p()."
    top_errors = self.non_field_errors() # Errors that should be displayed above all fields.
    output, hidden_fields = [], []
 
  #除了默认的table方式显示外，还可以<ul><li>或者<p>方式显示
  def as_table(self):
    "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."
  def as_ul(self):
    "Returns this form rendered as HTML <li>s -- excluding the <ul></ul>."
  def as_p(self):
    "Returns this form rendered as HTML <p>s."

class ProjectForm(ModelForm):
  class Meta:
    model = Project
    fields = ['approvals','manager','name','fund_rource','content','range',]

class ModelForm(six.with_metaclass(ModelFormMetaclass, BaseModelForm)):
  pass

class BaseModelForm(BaseForm):
  def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
         initial=None, error_class=ErrorList, label_suffix=None,
         empty_permitted=False, instance=None, use_required_attribute=None):
    opts = self._meta
	#相比较BaseForm，多了instance参数，它等价于Model模型的一个实例
    if instance is None:
      #不传instance参数，则会新构造model对象
      self.instance = opts.model()
      object_data = {}
    else:
      self.instance = instance
      object_data = model_to_dict(instance, opts.fields, opts.exclude)
	#此时传递了initial也一样可以生效，同时还会设置到Model中
    if initial is not None:
      object_data.update(initial)
 
  def save(self, commit=True):
	#默认commit是True，此时就会保存Model实例到数据库
    if commit:
      self.instance.save()
	#同时保存many-to-many字段对应的关系表
      self._save_m2m()
    else:
	#注意，本篇文章主要用到commit=False这个参数，它会返回Model实例，允许我们在修改instance后，在instance上再调用save方法
      self.save_m2m = self._save_m2m
    return self.instance

class PrimeContract(models.Model):
  address = models.ForeignKey(Address, related_name="prime_contract_address", verbose_name="address")
  project = models.ForeignKey(Project, related_name="prime_contract", verbose_name="project")
class Project(models.Model):
  address = models.ForeignKey(Address, related_name="project_address", verbose_name="project address")
class Address(models.Model):
  pass

class AddressForm(ModelForm):
  class Meta:
    model = Address
 fields = ...
class ProjectForm(ModelForm):
  class Meta:
    model = Project
 fields = ...
class PrimeContractForm(ModelForm):
  class Meta:
    model = PrimeContract
 fields = ...

class PrimeContractAdd(CreateView):
  success_url = ...
  template_name = ...
  form_class = PrimeContractForm
  def get_context_data(self, **kwargs):
    context = super(PrimeContractAdd, self).get_context_data(**kwargs)
    #SingleObjectMixin父类只会处理PrimeContractForm表单，另外三条数据库记录对应的表单我们要自己处理了，此时prefix派上用场了，因为Field重名是百分百的事
    if self.request.method == 'POST':
      contractAddressForm = AddressForm(self.request.POST, prefix='contractAddressForm')
      projectAddressForm = AddressForm(self.request.POST, prefix='projectAddressForm')
      projectForm = ProjectForm(self.request.POST, prefix='projectForm')
    else:
      contractAddressForm = AddressForm(prefix='contractAddressForm')
      projectAddressForm = AddressForm(prefix='projectAddressForm')
      projectForm = ProjectForm(prefix='projectForm')
    #注意要把自己处理的表单放到context上下文中，供模板文件使用
    context['contractAddressForm'] = contractAddressForm
    context['projectAddressForm'] = projectAddressForm
    context['projectForm'] = projectForm
    return context
  
	#重写form_valid，父类ProcessFormView会在PrimeContractForm表单is_valid方法返回True时调用该方法
  def form_valid(self, form):
	  #首先我们要获取到PrimeContractForm表单对应的模型，此时是不能save的，因为外键project和address对应的数据库记录还没有创建，所以commit传为False
    contract = form.save(commit=False)
		#获取上面get_context_data方法中在POST里得到的表单
    context = self.get_context_data()
		#按照四条数据库记录的顺序依次的创建（调用save方法）、主键赋到下一条记录的外键中、下一次记录创建（save）
    projectAddress = context['projectAddressForm'].save()
		#从项目表单中获取到模型，先把地址的id赋到外键上再保存
    project = context['projectForm'].save(commit=False)
    project.address = projectAddress
    project.save()
    contractAddress = context['contractAddressForm'].save()
		#将合同模型中的address和project都设置好后再保存
    contract.address = contractAddress
    contract.project = project
    contract.save()
    
    return super(PrimeContractAdd, self).form_valid(form)

#这三个表单我们手动处理过的
{{ contractAddressForm }}
{{ projectAddressForm }}
{{ projectForm }}
#这是FormMixin父类帮我们生成的
{{ form }}