1.一对多跨表查询获取数据的三种形式：对象、字典、元组

　　例：有host与business两张表，host与business的id字段关联，business在host表中的对象名是b，  通过查询host表获取的querySet中的b来查询business表。

　　以下两种方式都是操作host表：

　　a.以对象的形式跨表查询，查询business表的数据：row.b.caption，row.b.id

　　b.以字典和元组的形式跨表查询，查询business表的数据，跨表查询的时候要用双下划线  'b__id'，'b__caption'， # 这里caption是关联表business的字段

views.py

  1. def host(request):
  2.     #三种形式的跨表查询（这里有host与business两张表，host与business的id字段关联，business在host表中的对象名是b，
  3.     # 通过查询host表获取的querySet来查询business表）
  4.     v1 = models.Host.objects.filter(nid__gt=0)
  5.     for row in v1:
  6.         #v1以对象的形式跨表查询row.b.caption，       ,row.b.id
  7.         print(row.nid,row.hostname,row.ip,row.port,row.b.caption,row.b.id)
  8.  
  9.     v2 = models.Host.objects.all().values('nid','hostname','b_id','b__caption',)
  10.     for row2 in v2:
  11.         # v2以字典的形式跨表查询，跨表查询（即查询另一个关联表的数据）的时候要用双下划线'b__caption'，这里caption是关联表的字段
  12.         print(row2)  #结果是字典  {'nid': 8, 'hostname': 'ee', 'b_id': 5, 'b__caption': '运维'}
  13.         print(row2['nid'],row2['hostname'],row2['b_id'],row2['b__caption'])
  14.  
  15.     v3 = models.Host.objects.all().values_list('nid','hostname','b_id','b__caption')
  16.     for row3 in v3:
  17.         # v3以元组的形式跨表查询，跨表查询（即查询另一个关联表的数据）的时候要用双下划线'b__caption'，这里caption是关联表的字段
  18.         print(row3)#结果是元组  (7, 'wt', 6, '开发')
  19.         print(row3[0],row3[1],row3[2],row3[3])
  20.  
  21.     if request.method == 'GET':
  22.         v1 = models.Host.objects.filter(nid__gt=0)
  23.         v2 = models.Host.objects.all().values('nid', 'hostname', 'b_id', 'b__caption', )
  24.         v3 = models.Host.objects.all().values_list('nid', 'hostname', 'b_id', 'b__caption')
  25.         b_list = models.Business.objects.all()
  26.         return render(request, 'host.html', {'v1':v1, 'v2':v2, 'v3':v3,'b_list':b_list})
  27.     elif request.method == 'POST':
  28.         h = request.POST.get('hostname')
  29.         i = request.POST.get('ip')
  30.         p = request.POST.get('port')
  31.         b = request.POST.get('b_id')
  32.         models.Host.objects.create(hostname=h,
  33.                                    ip=i,
  34.                                    port=p,
  35.                                    b_id=b,)
  36.         return redirect('/host')

host.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h1>对象</h1>
  9.     <table border="1" style="border-collapse: collapse;">
  10.         <thead>
  11.             <tr>
  12.                 <th>主机名</th>
  13.                 <th>IP</th>
  14.                 <th>端口</th>
  15.                 <th>业务线名称</th>
  16.             </tr>
  17.         </thead>
  18.         <tbody>
  19.             {% for row in v1 %}
  20.                 <tr hid="{{ row.nid }}" bid="{{ row.b_id }}">
  21.                     <td>{{ row.hostname }}</td>
  22.                     <td>{{ row.ip }}</td>
  23.                     <td>{{ row.port }}</td>
  24. {#                    查关联表的其他字段caption，这里b是关联表的对象名#}
  25.                     <td>{{ row.b.caption }}</td>
  26.                 </tr>
  27.             {% endfor %}
  28.         </tbody>
  29.  
  30.     </table>
  31.     <h1>字典</h1>
  32.     <table border="1" style="border-collapse: collapse;">
  33.         <thead>
  34.             <tr>
  35.                 <th>主机名</th>
  36.                 <th>业务线名称</th>
  37.             </tr>
  38.         </thead>
  39.         <tbody>
  40.             {% for row in v2 %}
  41.                 <tr hid="{{ row.nid }}" bid="{{ row.b_id }}">
  42.                     <td>{{ row.hostname }}</td>
  43. {#                    查关联表的其他字段caption，这里b是关联表的对象名#}
  44.                     <td>{{ row.b__caption }}</td>
  45.                 </tr>
  46.             {% endfor %}
  47.         </tbody>
  48.  
  49.     </table>
  50.     <h1>元组</h1>
  51.     <table border="1" style="border-collapse: collapse;">
  52.         <thead>
  53.             <tr>
  54.                 <th>主机名</th>
  55.                 <th>业务线名称</th>
  56.             </tr>
  57.         </thead>
  58.         <tbody>
  59.             {% for row in v3 %}
  60.                 <tr hid="{{ row.0 }}" bid="{{ row.2 }}">
  61.                     <td>{{ row.1 }}</td>
  62.                     <td>{{ row.3 }}</td>
  63.  
  64. {#                    查关联表的其他字段caption，这里b是关联表的对象名#}
  65.                     <td>{{ row.b.caption }}</td>
  66.                 </tr>
  67.             {% endfor %}
  68.         </tbody>
  69.  
  70.     </table>
  71. </body>
  72. </html>

2.模板语言显示序号用forloop，只有for循环里有。

  1.  <tbody>
  2.                  {% for row in v1 %}
  3.                      <tr hid="{{ row.nid }}" bid="{{ row.b_id }}">
  4.                          <td>{{ forloop.counter  }}</td>
  5.  　　　　　　　　　　　　　　{#在for循环里才有forloop，forloop.counter自动加序号，从1开始#}
  6.  　　　　　　　　　　　　　　{#forloop.counter0自动加序号，从0开始#}
  7.  　　　　　　　　　　　　　　{#forloop.revcounter自动加序号，倒数#}
  8.                          <td>{{ row.hostname }}</td>
  9.                          <td>{{ row.ip }}</td>
  10.                          <td>{{ row.port }}</td>
  11.                          <td>{{ row.b.caption }}</td>
  12.                      </tr>
  13.                  {% endfor %}
  14.          </tbody>

3.后端接收前端多选框、Ctrl多选的数据用method.getlist()

views.py

  1.      elif request.method == "POST":
  2.          app_name = request.POST.get('app_name')
  3.          host_list = request.POST.getlist('host_list')#当前端是多选传过来的数据时，用getlist接收，生成列表
  4.          print(app_name,host_list)
  5.  
  6.          obj = models.Application.objects.create(name=app_name)
  7.          obj.r.add(*host_list)  #多对多跨表添加数据：*列表名
  8.  
  9.          return redirect('/app')

html多选

  1.              <div class="group">
  2.                  <select id="host_list" name="host_list" multiple>
  3.                   #multiple是多选的意思
  4.                      {% for op in host_list %}
  5.                          <option value="{{ op.nid }}">{{ op.hostname }}</option>
  6.                      {% endfor %}
  7.                  </select>
  8.              </div>

4.编辑框的实现和ajax提交表单数据
d20-host.html

  1. {#    下边是编辑框展示#}
  2.     <div class="shade hide"></div>
  3.     <div class="add-modal hide">
  4.         <form id="add_form" method="POST" action="/host">
  5.             <div class="group">
  6.                 <input id="host" type="text" placeholder="主机名" name="hostname" />
  7.             </div>
  8.  
  9.             <div class="group">
  10.                 <input id="ip" type="text" placeholder="IP" name="ip" />
  11.             </div>
  12.  
  13.             <div class="group">
  14.                 <input id="port" type="text" placeholder="端口" name="port" />
  15.             </div>
  16.  
  17.             <div class="group">
  18.                 <select id="sel" name="b_id">
  19.                     {% for op in b_list %}
  20. {#                        生成下拉框#}
  21.                     <option value="{{ op.id }}">{{ op.caption }}</option>
  22.                     {% endfor %}
  23.                 </select>
  24.             </div>
  25.  
  26.             <input type="submit" value="提交" />
  27.             <a id="ajax_submit" >悄悄提交</a>
  28.             <input id="cancel" type="button" value="取消" />
  29.             <span id="erro_msg" style="color: red"></span>
  30.                  提交失败，错误信息显示
  31.         </form>
  32.  
  33. $('#ajax_submit').click(function(){
  34.                 $.ajax({
  35.                     url: "/test_ajax",
  36.                     type: 'POST',
  37.                     //data: {'hostname': $('#host').val(), 'ip': $('#ip').val(), 'port': $('#port').val(), 'b_id': $('#sel').val()},
  38.                     data: $('#add_form').serialize(), //serialize()是ajax方法，它能自动找到表单中的name和value数据并提交给后台，跟上边的效果相同
  39.                     success: function(data){
  40.                         var obj = JSON.parse(data);
  41.                         if(obj.status){
  42.                             location.reload();//提交成功自动刷新页面
  43.                         }else{
  44.                             $('#erro_msg').text(obj.error);//提交失败显示错误信息
  45.                         }
  46.                     }
  47.                 })
  48.             });

views.py
后台数据接收

  1.      elif request.method == "POST":
  2.  
  3.          h = request.POST.get('hostname')
  4.          i = request.POST.get('ip')
  5.          p = request.POST.get('port')
  6.          b = request.POST.get('b_id')
  7.          models.Host.objects.create(hostname=h,
  8.                                                 ip=i,
  9.                                                 port=p,
  10.                                                 b_id=b,
  11.                                                 )
  12.          return redirect('/host')

5.初识ajax，ajax发送普通数据与发送列表

重要：在html中写ajax

  1. ajax操作要点：
  2. 1. <form id='ajax_text'action='/yy.html' method='post'>  #id='ajax_text'方便ajax获取数据；action='/yy.html'点击取消后
  3.                                                          跳转到的页面；
  4.  
  5. 2.    <input  id="ajax_submit" type="button" value="提交" /> #id="ajax_submit" ：方便ajax进行绑定
  6.    </form>
  7. 3.       <span id="error_msg" style="color: white"></span>  #显示提示信息
  8.  
  9. 4.            $('#ajax_submit').click(function(){
  10.                 $.ajax({
  11.                     url: "/test_ajax",
  12.                     type: 'POST',
  13.                     dataType:'JSON',  #自动转换json数据
  14.                     traditional:true,
  15.                     data: $('#add_form').serialize(),//ajax用serialize()提交表单数据，serialize()能自动获取表单中的
  16.                                                        name和value并提交给后台
  17.                     success: function(data){
  18.                         if(data.status){
  19.                             location.reload();  //自动刷新页面
  20.                         }else{
  21.                             $('#error_msg').text(data.error); //在模态对话框里显示错误信息
  22.                         }
  23.                     }
  24.                 })
  25.             });
  26.

ajax格式：

  1.  Ajax格式：在html的script中
            A.发送数据格式为普通数据data: {'k1': 123,'k2': "root"},
  2.  
  3.          $.ajax({
  4.              url: '/host',    //数据提交的url
  5.              type: "POST",    //数据提交方式，除了post还有get
  6.              data: {'k1': 123,'k2': "root"},  //要给后端发送提交的数据，data只能是字典
                   dataType:'JSON',   //写上这句，就不用再在下边做字符串与字典转换了，ajax内部自动转换
  7.              success: function(data){    //success里写函数
  8.                  // data是服务器端返回的字符串
  9.                  var obj = JSON.parse(data); //有了上边的dataType:'JSON',这里就不用做字符串转换成字典了
  10.              }
  11.          })
  12.     B.发送数据格式为列表：data: {'user': 123,'host_list': [1,2,3,4]},
  1. 　　　　　　$.ajax({
    　　　　　　     url: '/ajax_add_app',  
    　　　　　　     data: {'user': 123,'host_list': [1,2,3,4]},或
    　　　　　　     data: $('#add_form').serialize(),  //这里serialize()会找到id=add_form的表单，（这里id必须为表单<form>的id）并且自动获取form表单中的name和value，
    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　因此不用再写成data: {'user': 123,'host_list': [1,2,3,4]}这样了
    　　　　      type: "POST",
    　　　　        dataType: 'JSON',// 内部 自动将字符串转换为字典
    　　　　　　 traditional: true,  //要发送列表必须要加traditional: true参数，否则发送为空
                   success: function(obj){  //请求成功，要发送的数据
    　　               console.log(obj);
    　　　　　　     },
    　　　　　　     error: function () {    //请求失败，要发送的数据
        }
    })
  1.    建议：永远让服务器端返回一个字典 15 16 return HttpResponse(json.dumps(字典))

后端views.py，后端一定要永远给前端返回一个字典，而且return一定要返回HttpResponse

  1.  def test_ajax(request):
  2.      ret = {'status': True, 'error': None, 'data': None}  #初始化一个字典
  3.      try:      #获取ajax请求
  4.          h = request.POST.get('hostname')
  5.          i = request.POST.get('ip')
  6.          p = request.POST.get('port')
  7.          b = request.POST.get('b_id')
  8.          if h and len(h) > 5:   #判断用户名的长度是否大于5，如果小于5则返回error值
  9.              models.Host.objects.create(hostname=h,
  10.                                             ip=i,
  11.                                             port=p,
  12.                                             b_id=b)
  13.          else:
  14.              ret['status'] = False
  15.              ret['error'] = "太短了"
  16.      except Exception as e:
  17.          ret['status'] = False
  18.          ret['error'] = '请求错误'
  19.      return HttpResponse(json.dumps(ret))  #这里只能用HttpResponse，而且HttpResponse里边只能写字符串，所以往前端传输字典的时候要将字典序列化成字符串

前端html,在js里，通过var obj = JSON.parse(data); 将后端发过来的字符串转换为字典

  1.  <div class="add-modal hide">
  2.          <form id="add_form" method="POST" action="/host">
  3.              <div class="group">
  4.                  <input id="host" type="text" placeholder="主机名" name="hostname" />
  5.              </div>
  6.              <div class="group">
  7.                  <input id="ip" type="text" placeholder="IP" name="ip" />
  8.              </div>
  9.  
  10.              <div class="group">
  11.                  <input id="port" type="text" placeholder="端口" name="port" />
  12.              </div>
  13.  
  14.              <div class="group">
  15.                  <select id="sel" name="b_id">
  16.                      {% for op in b_list %}
  17.                      <option value="{{ op.id }}">{{ op.caption }}</option>
  18.                      {% endfor %}
  19.                  </select>
  20.              </div>
  21.  
  22.              <input type="submit" value="提交" />
  23.              <a id="ajax_submit" >悄悄提交</a>
  24.              <input id="cancel" type="button" value="取消" />
  25.              <span id="erro_msg" style="color: red"></span>
  26.              {#  span显示错误信息#}
  27.          </form>
  28.  
  29.   <script>
  30.  $('#ajax_submit').click(function(){
  31.                  $.ajax({
  32.                      url: "/test_ajax",
  33.                      type: 'POST',
  34.                      //data: {'hostname': $('#host').val(), 'ip': $('#ip').val(), 'port': $('#port').val(), 'b_id': $('#sel').val()},
  35.                      data: $('#add_form').serialize(),//ajax用serialize()提交表单数据，serialize()能自动获取表单中的name和value并提交给后台，效果跟上边这句一样
  36.                      success: function(data){
  37.                          var obj = JSON.parse(data);   //js将字符串转换为字典
  38.                          var dd = JSON.stringify(obj) //js将字典转换为字符串
  39.                          if(obj.status){
  40.                              location.reload();  //自动刷新页面
  41.                          }else{
  42.                              $('#erro_msg').text(obj.error); //在模态对话框里显示错误信息
  43.                          }
  44.                      }
  45.                  })
  46.              });
  47.   </script>

6.多对多创建关系表   有2种方式
   方式一：自定义关系表。推荐用这种方式创建

  1.             class Host(models.Model):
  2.                 nid = models.AutoField(primary_key=True)
  3.                 hostname = models.CharField(max_length=32,db_index=True)
  4.                 ip = models.GenericIPAddressField(protocol="ipv4",db_index=True)
  5.                 port = models.IntegerField()
  6.                 b = models.ForeignKey(to="Business", to_field='id')
  7.  
  8.             class Application(models.Model):
  9.                 name = models.CharField(max_length=32)
  10.  
  11.             class HostToApp(models.Model):#生成hosttoapp关联表，该表有三列，分别是id、hobj_nid、aobj_id，还可以自定义增加其他列名
  12.                 hobj = models.ForeignKey(to='Host',to_field='nid')
  13.                 aobj = models.ForeignKey(to='Application',to_field='id')

在往方式一创建的关系表hosttoapp表中插入数据的时候，直接用普通的orm语句即可：

  1. HostToApp.objects.create(hobj_id=1,aobj_id=2)

方式二：自动创建关系表。这种方式通过两个类可以创建三张表

  1.             class Host(models.Model):
  2.                 nid = models.AutoField(primary_key=True)
  3.                 hostname = models.CharField(max_length=32,db_index=True)
  4.                 ip = models.GenericIPAddressField(protocol="ipv4",db_index=True)
  5.                 port = models.IntegerField()
  6.                 b = models.ForeignKey(to="Business", to_field='id')
  7.  
  8.             class Application(models.Model):
  9.                 name = models.CharField(max_length=32)
  10.                 r = models.ManyToManyField("Host") #这里用ManyToManyField关键字，可以自动创建第三张表----即host与application表之间的关联表，表名是：app01_application_r;
                                                        其中app01是项目名，该表中含有三列，分别是：id、application_id、host_id，但该表不能自定义增加其他列

通过方式二创建的关系表app01_application_r表，是无法直接向该表插入数据的。要操作数据必须用以下方式：

  1.  
  2.             obj = Application.objects.get(id=1) #获取application表application_id=1所有数据的对象
    　　　　　　　　查
  3.             obj.name  #获取application_id=1对应所有数据的应用名
  4.             # 第三张表（关系表）操作
    　　　　　　　　增
    　　　　　　　　添加数据操作，有三种方式：
  5.             1、obj.r.add(1)  添加数据。这里的1是另一列host_id的数值，即在application表中添加application_id=1，host_id=1
  6.               obj.r.add(2)
  7.             2、obj.r.add(2,3,4) 添加数据。这里的2，3,4是另一列host_id的数值，即在application表中添加application_id=1，host_id=2；application_id=1，host_id=3；
                                 application_id=1，host_id=4的数值
  8.  
  9.             3、obj.r.add(*[1,2,3,4]) 添加数据。这里的1,2，3,4是另一列host_id 的数值，即在application表中添加application_id=1，host_id=1；application_id=1，host_id=2；
    application_id=1，host_id=3；application_id=1，host_id=4的数值 
                 删
  10.             obj.r.remove(1)   删除数据
  11.             obj.r.remove(2,4)
  12.             obj.r.remove(*[1,2,3])
  13.  
  14.             obj.r.clear()    清除数据。清除application表中application_id=1所对应的所有host_id的值
  15.             改
  16.             obj.r.set([3,5,7]) 修改数据。列表不加*，将application表中application_id=1所对应的所有host_id的值修改为3，5，7，即表中application_id=1所对应的所有host_id的值只剩下3，5，7
  17.  
  18.             # 通过关系表app01_application_r查询host表
    　　　　　　　obj = Application.objects.get(id=1)
  19.             ss = obj.r.all() 这里ss是querySet，这个querySet里存放的是application_id=1包括的所有host_id对应host表的一行行数据对象，也就是说ss就是host表中相应host_id所在行的数据对象集合，
                                 要获取每个host行对象的详细信息，要用for循环
                                 for h in ss:
    　　　　　　　　　　　　　　　　　　  print(h.hostname,h.id,h.port)

7.多对多增加、编辑示例，用ajax,详见d20-12

views.py

  1. from django.shortcuts import render,HttpResponse,redirect
  2. from app01 import models
  3. import json
  4. # Create your views here.
  5.  
  6. def business(request):
  7.     v1 = models.Business.objects.all()
  8.     # QuerySet
  9.     # [obj(id,caption,code),obj(id,caption,code),obj(id,caption,code) ]
  10.  
  11.     v2 = models.Business.objects.all().values('id','caption')
  12.     # QuerySet
  13.     # [{'id':1,'caption': '����'},{'id':1,'caption': '����'},...]
  14.  
  15.     v3 = models.Business.objects.all().values_list('id','caption')
  16.     # QuerySet
  17.     # [(1������),(2,����)]
  18.     return render(request, 'business.html', {'v1': v1,'v2': v2, 'v3': v3})
  19.  
  20. # def host(request):
  21. #     v1 = models.Host.objects.filter(nid__gt=0)
  22. #     # QuerySet [hostobj(ip.host,����һ������(..)),]
  23. #     # for row in v1:
  24. #     #     print(row.nid,row.hostname,row.ip,row.port,row.b_id,row.b.caption,row.b.code,row.b.id,sep='\t')
  25. #     #     print(row.b.fk.name)
  26. #     # return HttpResponse("Host")
  27. #     v2 = models.Host.objects.filter(nid__gt=0).values('nid','hostname','b_id','b__caption')
  28. #     # QuerySet: [ {} ]
  29. #     # print(v2)
  30. #     # for row in v2:
  31. #     #     print(row['nid'],row['hostname'],row['b_id'],row['b__caption'])
  32. #
  33. #     v3 = models.Host.objects.filter(nid__gt=0).values_list('nid','hostname','b_id','b__caption')
  34. #     # QuerySet: [ {} ]
  35. #     # print(v2)
  36. #     return render(request, 'host.html', {'v1': v1,'v2': v2,'v3': v3})
  37.  
  38. def host(request):
  39.     if request.method == "GET":
  40.         v1 = models.Host.objects.filter(nid__gt=0)
  41.         v2 = models.Host.objects.filter(nid__gt=0).values('nid','hostname','b_id','b__caption')
  42.         v3 = models.Host.objects.filter(nid__gt=0).values_list('nid','hostname','b_id','b__caption')
  43.  
  44.         b_list = models.Business.objects.all()
  45.  
  46.         return render(request, 'host.html', {'v1': v1,'v2': v2,'v3': v3,'b_list':b_list})
  47.  
  48.     elif request.method == "POST":
  49.  
  50.         h = request.POST.get('hostname')
  51.         i = request.POST.get('ip')
  52.         p = request.POST.get('port')
  53.         b = request.POST.get('b_id')
  54.         # models.Host.objects.create(hostname=h,
  55.         #                            ip=i,
  56.         #                            port=p,
  57.         #                            b=models.Business.objects.get(id=b)
  58.         #                            )
  59.         models.Host.objects.create(hostname=h,
  60.                                    ip=i,
  61.                                    port=p,
  62.                                    b_id=b
  63.                                    )
  64.         return redirect('/host')
  65.  
  66. def test_ajax(request):
  67.     ret = {'status': True, 'error': None, 'data': None}  #初始化一个字典
  68.     try:      #获取ajax请求
  69.         h = request.POST.get('hostname')
  70.         i = request.POST.get('ip')
  71.         p = request.POST.get('port')
  72.         b = request.POST.get('b_id')
  73.         if h and len(h) > 5:   #判断用户名的长度是否大于5，如果小于5则返回error值
  74.             models.Host.objects.create(hostname=h,
  75.                                            ip=i,
  76.                                            port=p,
  77.                                            b_id=b)
  78.         else:
  79.             ret['status'] = False
  80.             ret['error'] = "太短了"
  81.     except Exception as e:
  82.         ret['status'] = False
  83.         ret['error'] = '请求错误'
  84.     return HttpResponse(json.dumps(ret))  #HttpResponse里边只能写字符串，所以往前端传输字典的时候要将字典序列化成字符串
  85.  
  86. def app(request):
  87.     if request.method == "GET":
  88.         app_list = models.Application.objects.all()
  89.         # for row in app_list:
  90.         #     print(row.name,row.r.all())
  91.  
  92.         host_list = models.Host.objects.all()  #从host表取host数据，来生成host列表下拉框
  93.         return render(request,'app.html',{"app_list": app_list,'host_list': host_list})
  94.     elif request.method == "POST":
  95.         app_name = request.POST.get('app_name')
  96.         host_list = request.POST.getlist('host_list')#  后端获取列表数据用getlist
  97.         print(app_name,host_list)
  98.  
  99.         obj = models.Application.objects.create(name=app_name)
  100.         obj.r.add(*host_list)  #往关系表中添加数据，这里的host_list是列表，所以要加*号
  101.  
  102.         return redirect('/app')
  103.  
  104. def ajax_add_app(request):
  105.     ret = {'status':True, 'error':None, 'data': None}
  106.  
  107.     app_name = request.POST.get('app_name')
  108.     host_list = request.POST.getlist('host_list')
  109.     obj = models.Application.objects.create(name=app_name)
  110.     obj.r.add(*host_list)
  111.     return HttpResponse(json.dumps(ret))

app.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         .host-tag{
  8.             display: inline-block;
  9.             padding: 3px;
  10.             border: 1px solid red;
  11.             background-color: palevioletred;
  12.         }
  13.         .hide{
  14.             display: none;
  15.         }
  16.         .shade{
  17.             position: fixed;
  18.             top: 0;
  19.             right: 0;
  20.             left: 0;
  21.             bottom: 0;
  22.             background: black;
  23.             opacity: 0.6;
  24.             z-index: 100;
  25.         }
  26.         .add-modal,.edit-modal{
  27.             position: fixed;
  28.             height: 300px;
  29.             width: 400px;
  30.             top:100px;
  31.             left: 50%;
  32.             z-index: 101;
  33.             border: 1px solid red;
  34.             background: white;
  35.             margin-left: -200px;
  36.         }
  37.     </style>
  38. </head>
  39. <body>
  40.  
  41.     <h1>应用列表</h1>
  42.      <div>
  43.         <input id="add_app" type="button" value="添加" />
  44.     </div>
  45.     <table border="1">
  46.         <thead>
  47.             <tr>
  48.                 <td>应用名称</td>
  49.                 <td>应用主机列表</td>
  50.             </tr>
  51.         </thead>
  52.         <tbody>
  53.             {% for app in app_list %}
  54.                 <tr aid="{{ app.id }}">
  55.                     <td>{{ app.name }}</td>
  56.                     <td>
  57.                         {% for host in app.r.all %}
  58.                             <span class="host-tag" hid="{{ host.nid }}"> {{ host.hostname }} </span>
  59.                         {% endfor %}
  60.                     </td>
  61.                     <td>
  62.                         <a class="edit">编辑</a>
  63.                     </td>
  64.                 </tr>
  65.             {% endfor %}
  66.         </tbody>
  67.     </table>
  68.  
  69.     <div class="shade hide"></div>
  70.     <div class="add-modal hide">
  71.         <form id="add_form" method="POST" action="/app">
  72.             <div class="group">
  73.                 <input id="app_name" type="text" placeholder="应用名称" name="app_name" />
  74.             </div>
  75.             <div class="group">
  76.                 <select id="host_list" name="host_list" multiple>
  77.                     multiple是按住Ctrl多选，这里做一个下拉框，来进行多选选择
  78.                     {% for op in host_list %}
  79.                         <option value="{{ op.nid }}">{{ op.hostname }}</option>
  80.                         这里的op.nid就是每个hostname对应的id，提交的时候，就会将这些选中的op.nid以列表的形式提交给后端
  81.                     {% endfor %}
  82.                 </select>
  83.             </div>
  84.  
  85.             <input type="submit" value="提交" />
  86.             <input id="add_submit_ajax" type="button" value="Ajax提交" />
  87.         </form>
  88.  
  89.     </div>
  90.  
  91.     <div class="edit-modal hide">
  92.         <form id="edit_form" method="POST" action="/host">
  93.                 <input type="text" name="nid" style="display:none" />
  94.                 <input type="text" placeholder="应用名称" name="app" />
  95.                 <select name="host_list" multiple>
  96.                     multiple是按住Ctrl多选，这里做一个下拉框，来进行多选选择
  97.                     {% for op in host_list %}
  98.                         <option value="{{ op.nid }}">{{ op.hostname }}</option>
  99.                     {% endfor %}
  100.                 </select>
  101.             <a id="ajax_submit_edit" >确认编辑</a>
  102.         </form>
  103.  
  104.     </div>
  105.  
  106.      <script src="/static/jquery-1.12.4.js"></script>
  107.     <script>
  108.         $(function(){
  109.  
  110.             $('#add_app').click(function(){
  111.                 $('.shade,.add-modal').removeClass('hide');
  112.             });
  113.  
  114.             $('#cancel').click(function(){
  115.                 $('.shade,.add-modal').addClass('hide');
  116.             });
  117.  
  118.             $('#add_submit_ajax').click(function(){
  119.                 $.ajax({
  120.                     url: '/ajax_add_app',
  121.                     // data: {'user': 123,'host_list': [1,2,3,4]},
  122.                     data: $('#add_form').serialize(),
  123.                     type: "POST",
  124.                     dataType: 'JSON', // 内部
  125.                     traditional: true,
  126.                     success: function(obj){
  127.                         console.log(obj);
  128.                     },
  129.                     error: function () {
  130.  
  131.                     }
  132.  
  133.                 })
  134.             });
  135.  
  136.             $('.edit').click(function(){
  137.  
  138.                 $('.edit-modal,.shade').removeClass('hide');
  139.  
  140.                 var hid_list = [];
  141.                 $(this).parent().prev().children().each(function(){
  142.                     var hid = $(this).attr('hid');
  143.                     hid_list.push(hid)
  144.                 });
  145.  
  146.                 $('#edit_form').find('select').val(hid_list);
  147.                 // 如果发送到后台
  148.                 //
  149.                 /*
  150.                 obj = models.Application.objects.get(id=ai)
  151.                 obj.name = "新Name"
  152.                 obj.save()
  153.                 obj.r.set([1,2,3,4])
  154.                 */
  155.  
  156.             })
  157.  
  158.         })
  159.  
  160.     </script>
  161. </body>
  162. </html>

django（3） 一对多跨表查询、ajax、多对多的更多相关文章

  1. 基于对象的跨表查询，多对多查询，多对多操作，聚合查询和分组查询，F查询和Q 查询

    基于对象的跨表查询 一对多查询(班级表和学生表) 表结构创建 class Class(models.Model): id = models.AutoField(primary_key=True) cn ...

  2. django orm 基于双下划线的跨表查询

    一..基于双下划线的跨表查询(join实现) key:正向查询按字段,反向查询按表明小写 1.一对多跨表查询 查询在跨表中可以有两种方式,正向查询就是关键字段在你要搜索的表,没有关键字段就是反向查询 ...

  3. Django框架（九）-- 多表操作：一对一、一对多、多对多的增删改，基于对象/双下划线的跨表查询、聚合查询、分组查询、F查询与Q查询

    一.创建多表模型 一对一:OneToOneField 一对多:ForeignKey 多对多:ManyToManyField 创建表时,会自动添加一个nid字段,并且自增,所以id可以不用手动创建 On ...

  4. Django框架第七篇（模型层）--多表操作：一对多/多对多增删改，跨表查询（基于对象、基于双下划线跨表查询），聚合查询，分组查询，F查询与Q查询

    一.多表操作 一对多字段的增删改(book表和publish表是一对多关系,publish_id字段) 增  create publish_id 传数字   (publish_id是数据库显示的字段名 ...

  5. Django框架（十）—— 多表操作：一对一、一对多、多对多的增删改，基于对象/双下划线的跨表查询、聚合查询、分组查询、F查询与Q查询

    目录 多表操作:增删改,基于对象/双下划线的跨表查询.聚合查询.分组查询.F查询与Q查询 一.创建多表模型 二.一对多增删改表记录 1.一对多添加记录 2.一对多删除记录 3.一对多修改记录 三.一对 ...

  6. Django学习——图书相关表关系建立、基于双下划线的跨表查询、聚合查询、分组查询、F查询、Q查询、admin的使用、使用脚本调用Django、Django查看源生sql

    0 图书相关表关系建立 1.5个表 2.书籍表,作者表,作者详情表(垂直分表),出版社表,书籍和作者表(多对多关系) 一对一 多对多 本质都是一对多 外键关系 3.一对一的关系,关联字段可以写在任意一 ...

  7. django models的点查询/跨表查询/双下划线查询

    django models 在日常的编程中,我们需要建立数据库模型 而往往会用到表与表之间的关系,这就比单表取数据要复杂一些 在多表之间发生关系的情形下,我们如何利用models提供的API的特性获得 ...

  8. django之跨表查询及添加记录

    一:创建表 书籍模型: 书籍有书名和出版日期,一本书可能会有多个作者,一个作者也可以写多本书,所以作者和书籍的关系就是多对多的关联关系(many-to-many);     一本书只应该由一个出版商出 ...

  9. django之 使用views.py里面的函数对表进行增删改查 内容（models.py中表的创建、views.py中函数的使用，基于对象的跨表查询）

    models之对于表的创建有以下几种: 一对一:ForeignKey("Author",unique=True),  OneToOneField("Author" ...

随机推荐

  1. Linux之sar命令介绍

    sar(System Activity Reporter系统活动情况报告)是目前 Linux 上最为全面的系统性能分析工具之一,可以从多方面对系统的活动进行报告,包括:文件的读写情况.系统调用的使用情 ...

  2. MongoDBDao 工具类（包含分页取数据）

    mongdb工具类 package e16wifi.statistic.com.mongodb; import java.util.ArrayList; import java.util.List; ...

  3. MySQL数据库创建视图

    视图可以说是一种虚拟表,建立在基本表的基础上,通过关联一个表或者多个表来获取多个表中需要的字段,视图只是用来查询数据并不能用来存储数据信息. 我有以下几张表: -------image表---- -- ...

  4. BFC的布局规则以及触发条件

          1   .BFC的含义 :          Block Formatting Contexts(BFC)                                      块级元 ...

  5. CSS的常见属性

    1. css是cascading style sheet 层叠式样式表的简写."层叠式"的意思,我们将慢慢的去理解. 1                <style type ...

  6. 深入研究HTTP协议以及部分应用

    引言 工作了一段时间,都是在开发网页,自然和http打交道打得最多了,投身工作之后原来理解的东西又变得模糊,所以有必要深入探讨一下http协议的细节,也借此总结一下学习的成果. HTTP相关认识 对H ...

  7. eclipse 快捷键大全（转载）

    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当 ...

  8. 使用GRUB 添加新的启动项 (menu entry)

    GRUB版本: Grub2 基础知识: 相关的文件和目录结构: A./etc/grub.d/ 上图中有一个40_custom的脚本: 可以通过修改40_custom脚本来加入自定义的启动项. B./e ...

  9. MTK MT33xx型GPS的NMEA协议解析实例

    1)解析实现 gps_main.c #include <nmea/nmea.h> #include <string.h> #include <stdio.h> #i ...

  10. 1. web前端开发分享-css,js入门篇

    关注前端这么多年,没有大的成就,就入门期间积累了不少技巧与心得,跟大家分享一下,不一定都适合每个人,毕竟人与人的教育背景与成长环境心理活动都有差别,但就别人的心得再结合自己的特点,然后探索适合自己的学 ...