Changeset 6324


Ignore:
Timestamp:
Oct 2, 2008, 3:09:43 PM (16 years ago)
Author:
RIck van der Zwet
Message:

Mamma, without bloat code! Finally got rid of all the different interfaces and all extra lines. Still needs removeing lots of old code, done incommit

Location:
trunk/exodus
Files:
2 added
4 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/exodus/models.py

    r6323 r6324  
    5252    Latitude = models.DecimalField(max_digits=8,decimal_places=6)
    5353
     54    class Meta:
     55        verbose_name = 'Location'
     56
    5457    def __str__(self):
    5558        return self.description
    … …  
    6972        netmask = models.IntegerField()
    7073
     74    class Meta:
     75        verbose_name = 'Network'
     76
    7177        def __str__(self):
    7278                return self.name
    … …  
    8187 
    8288    class Meta:
    83          ordering = ['name']
     89        ordering = ['name']
     90        verbose_name = 'Node'
    8491
    8592    def __str__(self):
    … …  
    103110        class Meta:
    104111                unique_together = ('node', 'iface')
     112                verbose_name = 'Interface'
    105113       
    106114        def __str__(self):
    … …  
    145153    PublicAP = models.ForeignKey(PublicAP)
    146154
     155    class Meta:
     156        verbose_name = "Static host"
     157
    147158    def __str__(self):
    148159        return self.hostname

  • trunk/exodus/templates/exodus-template.html

    r6320 r6324  
    1616          &nbsp;&nbsp;<A class="menu" href="{% url root %}">Exodus</a><br>
    1717          &nbsp;&nbsp;<A class="menu" href="{% url nodelist %}">Node List</a><br>
    18           &nbsp;&nbsp;<A class="menu" href="{% url exodus.views.addLocation %}">Add Location</a><br>
    19           &nbsp;&nbsp;<A class="menu" href="{% url exodus.views.addNode %}">Add Node</a><br>
     18          &nbsp;&nbsp;<A class="menu" href="{% url exodus.views.genericLocation "add" "new" %}">Add Location</a><br>
     19          &nbsp;&nbsp;<A class="menu" href="{% url exodus.views.genericNode "add" "new" %}">Add Node</a><br>
    2020          </div>
    2121        </td>

  • trunk/exodus/templates/genericForm.html

    r6322 r6324  
    99
    1010<form method="post" action=".">
    11 {# On delete, make sure not to enable editing #}
     11{# On delete, make sure not to enable editing, and view detail instead #}
    1212{% ifequal mode "delete" %}
     13<table>
     14{% for key, value in object.as_list %}
     15<tr><th>{{ key }}</th><td>:</td><td>{{ value }}</td><tr>
     16{% endfor %}
     17</table>
    1318{% include delInclude %}
    14 
    1519<h3>Are you sure you want to <b>DELETE</b> this data <b>PERMANENTLY</b>?</h3>
    1620{% else %}
    17 <table>{{ form.as_table }}</table>
     21        {# Include custom code, like the javascript code #}
     22        {% ifequal mode "add" %}
     23                {% include addInclude %}
     24        {% else %}
     25                {% include editInclude %}
     26        {% endifequal %}
     27        <table>{{ form.as_table }}</table>
    1828{% endifequal %}
    1929<input type="submit" name="cancel" value="NO, cancel">

  • trunk/exodus/templates/node-detail.html

    r6322 r6324  
    1212
    1313Master ip: {{ node.masterip }} <br>
    14 <a href="{% url exodus.views.editNode node %}">EDIT</a>
    15 <a href="{% url exodus.views.delNode node %}">DELETE</a>
     14<a href="{% url exodus.views.genericNode "edit" node.name %}">EDIT</a>
     15<a href="{% url exodus.views.genericNode "delete" node.name %}">DELETE</a>
    1616</div>
    1717
    1818<h2>Interfaces</h2>
    19 <a href="{% url exodus.views.addInterface %}?node={{ node.name }}">Add new interface</a><p />
     19<a href="{% url exodus.views.genericInterface "add" node.name "new" %}">Add new interface</a><p />
    2020
    2121{% for nic in node.interface_set.all %}
    … …  
    2323        <div style="border:1px solid #000000;">
    2424        <h3>iface: {{ nic.iface }} </h3>
    25         <a href="{% url exodus.views.genericPublicAP "add" node nic.iface "new" %}">Add new public access point</a><p />
     25        <a href="{% url exodus.views.genericPublicAP "add" node.name nic.iface "new" %}">Add new public access point</a><p />
    2626        type: {{ nic.type }} <br>
    2727        description: {{ nic.shortdesc }} <br>
    … …  
    3535                Mode: {{ nic.mode }} <br>
    3636        {% endifnotequal %}
    37         <a href="{% url exodus.views.editInterface nic %}">EDIT</a>
    38         <a href="{% url exodus.views.delInterface nic %}">DELETE</a>
     37        <a href="{% url exodus.views.genericInterface "edit" node.name nic.iface %}">EDIT</a>
     38        <a href="{% url exodus.views.genericInterface "delete" node.name nic.iface %}">DELETE</a>
    3939        </div>
    4040

  • trunk/exodus/urls.py

    r6322 r6324  
    3939
    4040
    41         # add urls
    42         (r'^add/location/$', 'exodus.views.addLocation'),
    43         (r'^add/node/$', 'exodus.views.addNode'),
    44         (r'^add/nic/$', 'exodus.views.addInterface'),
    4541
    46         # add urls
    47         (r'^edit/location/(?P<object_id>.+)/$', 'exodus.views.addLocation'),
    48         (r'^edit/node/(?P<objectId>.+)/$', 'exodus.views.editNode'),
    49         (r'^edit/nic/(?P<objectId>.+)/$', 'exodus.views.editInterface'),
    5042        (r'^edit/link/(?P<object_id>.+)/$', 'exodus.views.addLink'),
    51         (r'^(?P<mode>(add|edit|delete))/dhcp/(?P<node>.+)/(?P<interface>.+)/(?P<publicAP>.+)/$', 'exodus.views.genericPublicAP'),
    5243
    53         # delete/remove urls
    54         (r'^del/node/(?P<objectId>.+)/$', 'exodus.views.delNode'),
    55         (r'^del/nic/(?P<objectId>.+)/$', 'exodus.views.delInterface'),
     44        # Generic urls
     45        (r'^location/(?P<mode>(add|edit|delete))/(?P<location>.+)/$', 'exodus.views.genericLocation'),
     46        (r'^node/(?P<mode>(add|edit|delete))/(?P<node>.+)/$', 'exodus.views.genericNode'),
     47        (r'^nic/(?P<mode>(add|edit|delete))/(?P<node>.+)/(?P<interface>.+)/$', 'exodus.views.genericInterface'),
     48        (r'^dhcp/(?P<mode>(add|edit|delete))/(?P<node>.+)/(?P<interface>.+)/(?P<publicAP>.+)/$', 'exodus.views.genericPublicAP'),
     49
    5650)
    5751

  • trunk/exodus/views.py

    r6323 r6324  
    1313from exodus.wllogic import freeMasterIP, newSSIDName, addInterlinkIP, freeInterlinkIP, freePublicAPIP
    1414
    15 class AddLocationForm(forms.ModelForm):
    16         class Meta:
    17                 model = Location
    18 
    19 def addLocation(request):
    20         if request.POST:
    21                 form = AddLocationForm(request.POST)
    22                 if form.is_valid():
    23                         form.save()
    24                         return HttpResponseRedirect(reverse('exodus.views.addNode') + "?location=" + request.POST['description'])
    25         else:
    26                 form = AddLocationForm()
    27         return render_to_response('addlocation.html', {'form': form })
    28 
    29 class AddNodeForm(forms.ModelForm):
    30         class Meta:
    31                 model = Node
    32                 exclude = ( 'masterip' )
     15
    3316
    3417def node(request, node):
    … …  
    3619        return render_to_response('node-detail.html', {'node': object})
    3720
    38 def addNode(request):
    39         if request.POST:
    40                 form = AddNodeForm(request.POST)
    41                 if form.is_valid():
    42                         # input a valid master ip into new_data
    43                         instance  = form.save(commit=False)
    44                         instance.masterip = freeMasterIP(instance)
    45                         instance.save()
    46                         return HttpResponseRedirect(reverse('node-detail', args=[instance.name]))
    47         else:
    48                 if 'location' in request.GET:
    49                         newNode = Node()
    50                         newNode.location = Location.objects.get(description=request.GET['location'])
    51                         form = AddNodeForm(instance=newNode)
    52                 else:
    53                         form = AddNodeForm()
    54         return render_to_response('addnode.html', {'form': form })
    55 
    56 def editNode(request, objectId):
    57         node = Node.objects.get(name=objectId)
    58         if request.POST:
    59                 form = AddNodeForm(request.POST, instance=node)
    60                 if form.is_valid():
    61                         form.save()
    62                         #Properly redirect to view/<Node> needed
    63                         message = 'Node Updated succesfully'
    64                         return HttpResponseRedirect(reverse('node-detail', args=[objectId]))
    65                 else:
    66                         message = 'Form error, please edit and resubmit'
    67         else:
    68                 message = 'Please edit and submit'
    69                 form = AddNodeForm(instance=node)
    70         return render_to_response('addnode.html', {'form': form, 'message' : message })
    71 
    72 
    73 def delNode(request, objectId):
    74         node = Node.objects.get(name=objectId)
    75         if request.POST.has_key('cancel'):
    76                 return HttpResponseRedirect(reverse('node-detail', args=[objectId]))
    77         elif request.POST.has_key('proceed'):
    78                 for master in Interface.objects.filter(node=node):
    79                         if master.link == master:
    80                                 for makeMaster in Interface.objects.filter(link=master):
    81                                         makeMaster.link = makeMaster
    82                                         makeMaster.save()
    83                 node.delete()
    84                 return HttpResponseRedirect(reverse('nodelist'))
    85         else:
    86                 return render_to_response('delnode.html', {'object': node })
    87 
    88 def delInterface(request, objectId):
    89         if request.POST:
    90                 form = AddNodeForm(request.POST)
    91                 if form.is_valid():
    92                         # input a valid master ip into new_data
    93                         instance  = form.save(commit=False)
    94                         instance.masterip = freeMasterIP(instance)
    95                         instance.save()
    96                         return HttpResponseRedirect(reverse('nodelist'))
    97         else:
    98                 form = AddNodeForm()
    99         return render_to_response('delnode.html', {'form': form })
    100 
    101 class addInterfaceForm(forms.ModelForm):
    102         class Meta:
    103                 model = Interface
    104                 exclude = ( 'ip', 'ssid', 'mode', 'channel', 'shortdesc' )
    105 
    106 def saveInterface(form):
    107         #XXX: Should have checking wether form has actually been changed to avoid creation of IPs every time
    108         instance  = form.save(commit=False)
    109         if str(instance.type) != "eth":
    110                 instance.ssid = newSSIDName(instance.node, instance.iface, 'unused')
    111                 instance.channel = '1'
    112                 instance.mode = 1 # set to master
    113         if not instance.link:
    114                 instance.ip = freeInterlinkIP(instance)
    115         else:
    116                 instance.ip = addInterlinkIP(instance.link)
    117         instance.save()
    118         #Dirty to hack to get reference to self working
    119         if not instance.link:
    120                 instance.link = instance
    121                 instance.save()
    122 
    123 def addInterface(request):
    124         if request.POST:
    125                 form = addInterfaceForm(request.POST)
    126                 if form.is_valid():
    127                         saveInterface(form)
    128                         nodeName = Node.objects.get(pk=request.POST['node' ]).name
    129                         return HttpResponseRedirect(reverse('node-detail', args=[nodeName]))
    130         else:
    131                 #XXX: Link, master interfaces only
    132                 if 'node' in request.GET:
    133                         newInterface = Interface()
    134                         newInterface.node = Node.objects.get(name=request.GET['node'])
    135                         form = addInterfaceForm(instance=newInterface)
    136                 else:
    137                         form = addInterfaceForm()
    138         return render_to_response('addnic.html', {'form': form })
    139 
    140 def editInterface(request, objectId):
    141         nodeName, interfaceName = objectId.split(':')
    142         interface = Interface.objects.get(iface=interfaceName, node=nodename2id(nodeName))
    143         if request.POST:
    144                 form = addInterfaceForm(request.POST, instance=interface)
    145                 if form.is_valid():
    146                         saveInterface(form)
    147                         return HttpResponseRedirect(reverse('node-detail', args=[nodeName]))
    148         else:
    149                 #XXX: Link, master interfaces only
    150                 form = addInterfaceForm(instance = interface)
    151         return render_to_response('addnic.html', {'form': form })
    15221
    15322class addLinkForm(forms.Form):
    … …  
    20473        return render_to_response('addinterlink.html',{'form': form})
    20574
    206 class PublicAPForm(forms.ModelForm):
    207         class Meta:
    208                 model = PublicAP
    209                 exclude = ('shortdesc', 'desc', 'ip', 'dhcpstart', 'dhcpstop')
    21075
    21176class GenericHandler():
    21277        """Conventions used: type has to to the same name as the dependency object, delet template is named delete<type>.html"""
    213         def __init__(self, request, node, interface, publicAP, mode, type):
    214                 # Find dependencies
    215                 node = Node.objects.get(name=node)
    216                 iface = Interface.objects.get(node=node, iface=interface)
    217                 publicAP = PublicAP(iface=iface) if mode == 'add' else PublicAP.objects.get(iface=iface, pk=publicAP)
    218                
    219                 delInclude = 'delete' + type + '.html'
    220                
     78        def __init__(self, request, mode):
     79                # Strip 'Handler' of name
     80                type = self.__class__.__name__[:-7:]
    22181                formClass = eval(type + 'Form')
    222                 self.object = eval(type[0].lower() + type[1::])
    223                 title = self.object._meta.verbose_name
     82
     83                self.object = eval('self.' + type[0].lower() + type[1::])
     84                self.title = self.object._meta.verbose_name
     85                self.request = request
    22486               
    22587                if request.POST.has_key('cancel'):
    226                         self.response = HttpResponseRedirect(reverse('node-detail', args=[node]))
     88                        self.response = HttpResponseRedirect(reverse('node-detail', args=[self.node.name]))
    22789                elif request.POST.has_key('proceed'):
    22890                        if mode == 'delete':
    229                                 self._delete()
    230                                 self.response = HttpResponseRedirect(reverse('node-detail', args=[node]))
     91                                self._deleteete()
     92                                self.response = HttpResponseRedirect(reverse('node-detail', args=[self.node.name]))
    23193                        else:
    23294                                # First checking whether form is valid, then add/edit actions
    23395                                self.form = formClass(request.POST, instance=self.object)
    23496                                if self.form.is_valid():
     97                                        # Set response on forehand, to allow override in procedure
     98                                        self.response = HttpResponseRedirect(reverse('node-detail', args=[self.node.name]))
    23599                                        if mode == 'add':
    236100                                                self._add()
    237101                                        elif mode == 'edit':
    238102                                                self._edit()
    239                                         self.response = HttpResponseRedirect(reverse('node-detail', args=[node]))
    240103                                else:
    241104                                        message = 'Form error, please edit and resubmit'
    242105                                        self.response = render_to_response('genericForm.html', {'form': self.form,
    243                                                 'message' : message, 'title' : title, 'mode' : mode,
    244                                                 'delInclude' : delInclude, 'object': self.object })
     106                                                'message' : message, 'title' : self.title, 'mode' : mode,
     107                                                'type' : type, 'object': self.object })
    245108                else:
    246109                        message = 'Please edit and submit'
    247                         self.form = formClass(instance=self.object)
    248                         self.response = render_to_response('genericForm.html', {'form': self.form,
    249                                 'message' : message, 'title' : title, 'mode' : mode,
    250                                 'delInclude' : delInclude, 'object': self.object })
     110                       
     111                        # Dirty? hack to allow initial form to be filled with date for GET request, no errors raised
     112                        if request.GET and mode == 'add':
     113                                self.form = formClass(request.GET, instance=self.object)
     114                                self.form._errors = {}
     115                        else:
     116                                self.form = formClass(instance=self.object)
     117
     118                        self.response = render_to_response('genericForm.html', {
     119                                'form': self.form, 'message' : message, 'title' : self.title,
     120                                'mode' : mode, 'type' : type, 'object': self.object,
     121                                'delInclude' : "delete" + type.capitalize() + ".html",
     122                                'addInclude' : "add" + type.capitalize() + ".html",
     123                                'editInclude' : "edit" + type.capitalize() + ".html" })
     124
     125        def _add(self):
     126                self.form.save()
     127
     128        def _edit(self):
     129                self.form.save()
     130
     131        def _deleteete(self):
     132                self.object.delete()
     133       
     134        def render_to_response(self):
     135                return self.response
     136
     137
     138#
     139# PublicAP
     140class PublicAPForm(forms.ModelForm):
     141        class Meta:
     142                model = PublicAP
     143                exclude = ('shortdesc', 'desc', 'ip', 'dhcpstart', 'dhcpstop')
     144
     145class PublicAPHandler(GenericHandler):
     146        def __init__(self, request, node, interface, publicAP, mode):
     147                self.node = Node.objects.get(name=node)
     148                self.interface = Interface.objects.get(node=self.node, iface=interface)
     149                if mode == 'add':
     150                        self.publicAP = PublicAP(iface=self.interface)
     151                else:
     152                        self.publicAP =  PublicAP.objects.get(iface=self.interface, pk=publicAP)
     153                GenericHandler.__init__(self, request, mode)
     154
    251155
    252156        def _add(self):
    … …  
    260164                _instance.save()
    261165
     166def genericPublicAP(request, node, interface, publicAP, mode):
     167        handler = PublicAPHandler(request, node, interface, publicAP, mode)
     168        return handler.render_to_response()
     169
     170
     171
     172#
     173# Interface
     174class InterfaceForm(forms.ModelForm):
     175        class Meta:
     176                model = Interface
     177                exclude = ( 'ip', 'ssid', 'mode', 'channel', 'shortdesc' )
     178
     179class InterfaceHandler(GenericHandler):
     180        def __init__(self, request, node, interface, mode):
     181                self.node = Node.objects.get(name=node)
     182                if mode == 'add':
     183                        self.interface = Interface(node=self.node)
     184                else:
     185                        self.interface = Interface.objects.get(node=self.node, iface=interface)
     186                GenericHandler.__init__(self, request, mode)
     187
     188        def _add(self):
     189                self._saveInterface()
     190
    262191        def _edit(self):
    263                 self.form.save()
     192                self._saveInterface()
     193
     194        def _saveInterface(self):
     195                #XXX: Should have checking wether form has actually been changed to avoid creation of IPs every time
     196                _instance  = self.form.save(commit=False)
     197                if str(_instance.type) != "eth":
     198                        _instance.ssid = newSSIDName(_instance.node, _instance.iface, 'unused')
     199                        _instance.channel = '1'
     200                        _instance.mode = 1 # set to master
     201                if not _instance.link:
     202                        _instance.ip = freeInterlinkIP(_instance)
     203                else:
     204                        _instance.ip = addInterlinkIP(_instance.link)
     205                _instance.save()
     206                #Dirty to hack to get reference to self working
     207                if not _instance.link:
     208                        _instance.link = _instance
     209                        _instance.save()
     210
     211
     212def genericInterface(request, node, interface, mode):
     213        handler = InterfaceHandler(request, node, interface, mode)
     214        return handler.render_to_response()
     215
     216#
     217# Node
     218class NodeForm(forms.ModelForm):
     219        class Meta:
     220                model = Node
     221                exclude = ( 'masterip' )
     222
     223class NodeHandler(GenericHandler):
     224        def __init__(self, request, node, mode):
     225                if mode == 'add':
     226                        self.node = Node()
     227                else:
     228                        self.node = Node.objects.get(name=node)
     229                GenericHandler.__init__(self, request, mode)
     230
     231        def _add(self):
     232                # input a valid master ip into new_data
     233                _instance  = self.form.save(commit=False)
     234                _instance.masterip = freeMasterIP(_instance)
     235                _instance.save()
     236
     237        def _delete(self):
     238                for _master in Interface.objects.filter(node=_instance):
     239                        if _master.link == _master:
     240                                for _makeMaster in Interface.objects.filter(link=_master):
     241                                        _makeMaster.link = _makeMaster
     242                                        _makeMaster.save()
     243                _instance.delete()
     244                # As node is deleted, goto overview page
     245                self.response = HttpResponseRedirect(reverse('node-overview'))
     246
     247def genericNode(request, node, mode):
     248        handler = NodeHandler(request, node, mode)
     249        return handler.render_to_response()
     250
     251#
     252# Location
     253class LocationForm(forms.ModelForm):
     254        class Meta:
     255                model = Location
     256
     257class LocationHandler(GenericHandler):
     258        def __init__(self, request, location, mode):
     259                if mode == 'add':
     260                        self.location = Location()
     261                else:
     262                        self.location = Location.objects.get(description=location)
     263                GenericHandler.__init__(self, request, mode)
     264
     265        def _add(self):
     266                self._saveInterface()
     267                # After adding a location, allow adding a Node with this location
     268                self.response = HttpResponseRedirect(reverse('exodus.views.genericNode', args=["add", "new"]) + "?location=%i" % self._instance.pk)
    264269
    265270        def _delete(self):
    266271                self.object.delete()
    267        
    268         def render_to_response(self):
    269                 return self.response
    270 
    271 def genericPublicAP(request, node, interface, publicAP, mode):
    272         handler = GenericHandler(request, node, interface, publicAP, mode, 'PublicAP')
     272                self.response = HttpResponseRedirect(reverse('node-overview'))
     273
     274def genericLocation(request, location, mode):
     275        handler = LocationHandler(request, location, mode)
    273276        return handler.render_to_response()
     277
     278
     279
    274280
    275281def nodename2id(node):
Note: See TracChangeset for help on using the changeset viewer.