views.py 28.1 KB
Newer Older
1 2 3 4 5 6 7 8 9
from django.views.generic import (TemplateView, UpdateView, DeleteView,
                                  CreateView)
from django.core.urlresolvers import reverse_lazy
from django.shortcuts import render, redirect
from django.http import HttpResponse

from django_tables2 import SingleTableView

from firewall.models import (Host, Vlan, Domain, Group, Record, Blacklist,
10
                             Rule, VlanGroup, SwitchPort, EthernetDevice)
11
from vm.models import Interface
12 13 14
from .tables import (HostTable, VlanTable, SmallHostTable, DomainTable,
                     GroupTable, RecordTable, BlacklistTable, RuleTable,
                     VlanGroupTable, SmallRuleTable, SmallGroupRuleTable,
15
                     SmallRecordTable, SwitchPortTable)
16
from .forms import (HostForm, VlanForm, DomainForm, GroupForm, RecordForm,
17
                    BlacklistForm, RuleForm, VlanGroupForm, SwitchPortForm)
18 19 20 21

from django.contrib import messages
from django.views.generic.edit import FormMixin
from django.utils.translation import ugettext_lazy as _
22
from braces.views import LoginRequiredMixin, SuperuserRequiredMixin
23 24
# from django.db.models import Q
from operator import itemgetter
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
from itertools import chain
import json


class SuccessMessageMixin(FormMixin):
    """
    Adds a success message on successful form submission.
    From django/contrib/messages/views.py@9a85ad89
    """
    success_message = ''

    def form_valid(self, form):
        response = super(SuccessMessageMixin, self).form_valid(form)
        success_message = self.get_success_message(form.cleaned_data)
        if success_message:
            messages.success(self.request, success_message)
        return response

    def get_success_message(self, cleaned_data):
        return self.success_message % cleaned_data


47
class IndexView(LoginRequiredMixin, SuperuserRequiredMixin, TemplateView):
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
    template_name = "network/index.html"

    def get_context_data(self, **kwargs):
        context = super(IndexView, self).get_context_data(**kwargs)

        size = 13
        blacklists = Blacklist.objects.all().order_by('-modified_at')[:size]
        domains = Domain.objects.all().order_by('-modified_at')[:size]
        groups = Group.objects.all().order_by('-modified_at')[:size]
        hosts = Host.objects.all().order_by('-modified_at')[:size]
        records = Record.objects.all().order_by('-modified_at')[:size]
        vlans = Vlan.objects.all().order_by('-modified_at')[:size]
        vlangroups = VlanGroup.objects.all().order_by('-modified_at')[:size]
        rules = Rule.objects.all().order_by('-modified_at')[:size]

        result_list = []
        for i in (sorted(chain(domains, groups, hosts, records, vlans,
                               vlangroups, rules),
                         key=lambda x: x.modified_at, reverse=True)[:size]):
            result_list.append(
                {
                    'class_name': unicode(i.__class__.__name__),
                    'modified_at': i.modified_at,
                    'created_at': i.created_at,
                    'name': unicode(i),
                    'link': i.get_absolute_url()
                })

        context['latest_blacklists'] = blacklists
        context['latest'] = result_list
        return context


81 82
class BlacklistList(LoginRequiredMixin, SuperuserRequiredMixin,
                    SingleTableView):
83 84 85 86 87 88
    model = Blacklist
    table_class = BlacklistTable
    template_name = "network/blacklist-list.html"
    table_pagination = False


89 90
class BlacklistDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                      SuccessMessageMixin, UpdateView):
91 92 93
    model = Blacklist
    template_name = "network/blacklist-edit.html"
    form_class = BlacklistForm
94
    success_message = _(u'Successfully modified blacklist '
95 96 97 98 99 100 101 102 103 104 105 106
                        '%(ipv4)s - %(type)s!')

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.blacklist', kwargs=self.kwargs)

    def get_context_data(self, **kwargs):
        context = super(BlacklistDetail, self).get_context_data(**kwargs)
        context['blacklist_pk'] = self.object.pk
        return context


107 108
class BlacklistCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                      SuccessMessageMixin, CreateView):
109 110 111
    model = Blacklist
    template_name = "network/blacklist-create.html"
    form_class = BlacklistForm
112
    success_message = _(u'Successfully created blacklist '
113 114 115
                        '%(ipv4)s - %(type)s!')


116
class BlacklistDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
    model = Blacklist
    template_name = "network/confirm/base_delete.html"

    def get_context_data(self, **kwargs):
        """ display more information about the object """
        context = super(BlacklistDelete, self).get_context_data(**kwargs)
        if 'pk' in self.kwargs:
            to_delete = Blacklist.objects.get(pk=self.kwargs['pk'])
            context['object'] = "%s - %s - %s" % (to_delete.ipv4,
                                                  to_delete.reason,
                                                  to_delete.type)
            return context

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return self.request.POST['next']
        else:
            return reverse_lazy('network.blacklist_list')


138
class DomainList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
139 140 141 142 143 144
    model = Domain
    table_class = DomainTable
    template_name = "network/domain-list.html"
    table_pagination = False


145 146
class DomainDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                   SuccessMessageMixin, UpdateView):
147 148 149
    model = Domain
    template_name = "network/domain-edit.html"
    form_class = DomainForm
150
    success_message = _(u'Successfully modified domain %(name)s!')
151 152 153 154 155 156 157

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.domain', kwargs=self.kwargs)

    def get_context_data(self, *args, **kwargs):
        context = super(DomainDetail, self).get_context_data(**kwargs)
158 159 160 161 162 163 164 165 166 167
        self.object = self.get_object()
        context['domain_pk'] = self.object.pk

        q = Record.objects.filter(
            domain=self.object,
            host__in=Host.objects.filter(
                interface__in=Interface.objects.filter(
                    instance__destroyed=None)
            )
        )
168 169 170 171
        context['record_list'] = SmallRecordTable(q)
        return context


172 173
class DomainCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                   SuccessMessageMixin, CreateView):
174 175 176
    model = Domain
    template_name = "network/domain-create.html"
    form_class = DomainForm
177
    success_message = _(u'Successfully created domain %(name)s!')
178 179


180
class DomainDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
181 182 183 184 185 186 187 188 189 190 191 192 193
    model = Domain
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return self.request.POST['next']
        else:
            return reverse_lazy('network.domain_list')

    def delete(self, request, *args, **kwargs):
        self.object = self.get_object()
        if unicode(self.object) != request.POST.get('confirm'):
194
            messages.error(request, _(u"Object name does not match!"))
195 196 197
            return self.get(request, *args, **kwargs)

        response = super(DomainDelete, self).delete(request, *args, **kwargs)
198
        messages.success(request, _(u"Domain successfully deleted!"))
199 200 201 202 203
        return response

    def get_context_data(self, **kwargs):
        context = super(DomainDelete, self).get_context_data(**kwargs)

204
        records_from_hosts = _(u'Records from hosts')
205 206 207 208 209
        deps = []
        # vlans
        vlans = Vlan.objects.filter(domain=self.object).all()
        if len(vlans) > 0:
            deps.append({
210
                'name': _('Vlans'),
211 212 213 214 215 216 217
                'data': vlans
            })

            # hosts
            hosts = Host.objects.filter(vlan__in=deps[0]['data'])
            if len(hosts) > 0:
                deps.append({
218
                    'name': _('Hosts'),
219 220 221 222 223
                    'data':  hosts
                })

                # records
                records = Record.objects.filter(
224 225
                    host__in=deps[1]['data']
                    # Q(domain=self.object) | (host__in=deps[1]['data'])
226 227 228
                )
                if len(records) > 0:
                    deps.append({
229
                        'name': records_from_hosts,
230 231 232
                        'data': records
                    })

233 234 235 236
        records = Record.objects.filter(domain=self.object)
        if len(records) > 0:
            # to filter out doubles (records from hosts and domains)
            indexes = map(itemgetter('name'), deps)
237
            n = indexes.index(records_from_hosts) if len(indexes) > 0 else 0
238
            deps.append({
239
                'name': u'Records only from the domain',
240 241 242 243
                'data': records.exclude(pk__in=deps[n]['data']) if n > 0
                else records
            })

244 245 246 247 248
        context['deps'] = deps
        context['confirmation'] = True
        return context


249
class GroupList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
250 251 252 253 254 255
    model = Group
    table_class = GroupTable
    template_name = "network/group-list.html"
    table_pagination = False


256 257
class GroupCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                  SuccessMessageMixin, CreateView):
258 259 260
    model = Group
    template_name = "network/group-create.html"
    form_class = GroupForm
261
    success_message = _(u'Successfully created host group %(name)s!')
262 263


264 265
class GroupDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                  SuccessMessageMixin, UpdateView):
266 267 268
    model = Group
    template_name = "network/group-edit.html"
    form_class = GroupForm
269
    success_message = _(u'Successfully modified host group %(name)s!')
270 271 272 273 274

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.group', kwargs=self.kwargs)

275 276 277
    def get_context_data(self, *args, **kwargs):
        context = super(GroupDetail, self).get_context_data(**kwargs)

278 279
        context['group_pk'] = self.object.pk

280 281 282 283 284
        # records
        q = Rule.objects.filter(hostgroup=self.object)
        context['rule_list'] = SmallRuleTable(q)
        return context

285

286
class GroupDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
    model = Group
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return self.request.POST['next']
        else:
            return reverse_lazy('network.group_list')

    def get_context_data(self, *args, **kwargs):
        context = super(GroupDelete, self).get_context_data(**kwargs)
        context['group_pk'] = self.object.pk
        return context


303
class HostList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
304 305 306 307 308 309 310 311 312 313 314 315 316 317
    model = Host
    table_class = HostTable
    template_name = "network/host-list.html"
    table_pagination = False

    def get_context_data(self, **kwargs):
        context = super(HostList, self).get_context_data(**kwargs)
        q = Vlan.objects.all().order_by("name")
        context['vlans'] = q
        return context

    def get_table_data(self):
        vlan_id = self.request.GET.get('vlan')
        if vlan_id:
318
            data = Host.objects.filter(vlan=vlan_id).select_related()
319
        else:
320
            data = Host.objects.select_related()
321 322 323
        return data


324 325
class HostDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, UpdateView):
326 327 328
    model = Host
    template_name = "network/host-edit.html"
    form_class = HostForm
329
    success_message = _(u'Successfully modified host %(hostname)s!')
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

    def get(self, request, *args, **kwargs):
        if request.is_ajax():
            host = Host.objects.get(pk=kwargs['pk'])
            host = {
                'hostname': host.hostname,
                'ipv4': host.ipv4,
                'ipv6': host.ipv6,
                'fqdn': host.get_fqdn()
            }
            return HttpResponse(json.dumps(host),
                                content_type="application/json")
        else:
            self.object = self.get_object()
            return super(HostDetail, self).get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        pk = self.kwargs.get('pk')
        # this is usually not None (well, with curl and whatnot it can be)
        if pk:
            groups = Host.objects.get(pk=pk).groups.all()
            groups = [i.pk for i in groups]
            # request.POST is immutable
            post_copy = request.POST.copy()
            post_copy.setlist('groups', groups)
            request.POST = post_copy
            return super(HostDetail, self).post(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(HostDetail, self).get_context_data(**kwargs)
        # own rules
        q = Rule.objects.filter(host=self.object).all()
        context['rule_list'] = SmallRuleTable(q)

        # rules from host groups
        group_rule_list = []
        for group in self.object.groups.all():
            q = Rule.objects.filter(hostgroup=group).all()
            group_rule_list.append({
                'table': SmallGroupRuleTable(q),
                'name': unicode(group),
                'pk': group.pk
            })
        context['group_rule_list'] = group_rule_list

        # available groups
        rest = Group.objects.exclude(pk__in=self.object.groups.all()).all()
        context['not_used_groups'] = rest

        # set host pk (we need this for URL-s)
        context['host_pk'] = self.kwargs['pk']

        return context

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.host', kwargs=self.kwargs)


389 390
class HostCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, CreateView):
391 392 393
    model = Host
    template_name = "network/host-create.html"
    form_class = HostForm
394
    success_message = _(u'Successfully created host %(hostname)s!')
395 396


397
class HostDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
    model = Host
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return self.request.POST['next']
        else:
            return reverse_lazy('network.host_list')

    def get_context_data(self, *args, **kwargs):
        context = super(HostDelete, self).get_context_data(**kwargs)

        deps = []
        records = Record.objects.filter(host=self.object).all()
        if records:
            deps.append({
415
                'name': _('Records'),
416 417 418 419 420 421 422 423 424 425
                'data': records
            })

        context['deps'] = deps
        context['confirmation'] = True
        return context

    def delete(self, request, *args, **kwargs):
        self.object = self.get_object()
        if unicode(self.object) != request.POST.get('confirm'):
426
            messages.error(request, _(u"Object name does not match!"))
427 428 429
            return self.get(request, *args, **kwargs)

        response = super(HostDelete, self).delete(request, *args, **kwargs)
430
        messages.success(request, _(u"Host successfully deleted!"))
431 432 433
        return response


434
class RecordList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
435 436 437 438 439
    model = Record
    table_class = RecordTable
    template_name = "network/record-list.html"
    table_pagination = False

440 441 442 443 444 445 446 447 448 449 450 451 452
    def get_context_data(self, **kwargs):
        context = super(RecordList, self).get_context_data(**kwargs)
        context['types'] = Record.CHOICES_type
        return context

    def get_table_data(self):
        type_id = self.request.GET.get('type')
        if type_id:
            data = Record.objects.filter(type=type_id).select_related()
        else:
            data = Record.objects.select_related()
        return data

453

454 455
class RecordDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                   SuccessMessageMixin, UpdateView):
456 457 458 459
    model = Record
    template_name = "network/record-edit.html"
    form_class = RecordForm
    # TODO fqdn
460
    success_message = _(u'Successfully modified record!')
461 462 463 464 465 466 467 468 469 470 471 472

    def get_context_data(self, **kwargs):
        context = super(RecordDetail, self).get_context_data(**kwargs)
        context['fqdn'] = self.object.fqdn
        context['record_pk'] = self.object.pk
        return context

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.record', kwargs=self.kwargs)


473 474
class RecordCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                   SuccessMessageMixin, CreateView):
475 476 477 478
    model = Record
    template_name = "network/record-create.html"
    form_class = RecordForm
    # TODO fqdn
479
    success_message = _(u'Successfully created record!')
480

481 482 483 484 485 486
    def get_initial(self):
        return {
            # 'owner': 1,
            'domain': self.request.GET.get('domain'),
        }

487

488
class RecordDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
489 490 491 492 493 494 495 496 497 498 499
    model = Record
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return self.request.POST['next']
        else:
            return reverse_lazy('network.record_list')


500
class RuleList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
501 502 503 504 505 506
    model = Rule
    table_class = RuleTable
    template_name = "network/rule-list.html"
    table_pagination = False


507 508
class RuleDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, UpdateView):
509 510 511
    model = Rule
    template_name = "network/rule-edit.html"
    form_class = RuleForm
512
    success_message = _(u'Successfully modified rule!')
513 514 515 516 517 518 519 520 521 522 523 524 525 526

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.rule', kwargs=self.kwargs)

    def get_context_data(self, **kwargs):
        context = super(RuleDetail, self).get_context_data(**kwargs)

        rule = self.get_object()

        context['rule'] = rule
        return context


527 528
class RuleCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, CreateView):
529 530 531
    model = Rule
    template_name = "network/rule-create.html"
    form_class = RuleForm
532
    success_message = _(u'Successfully created rule!')
533

534 535 536 537 538 539 540
    def get_initial(self):
        return {
            # 'owner': 1,
            'host': self.request.GET.get('host'),
            'hostgroup': self.request.GET.get('hostgroup')
        }

541

542
class RuleDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
543 544 545 546 547 548 549 550 551 552 553
    model = Rule
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('network.rule_list')


554 555
class SwitchPortList(LoginRequiredMixin, SuperuserRequiredMixin,
                     SingleTableView):
556 557 558 559 560 561
    model = SwitchPort
    table_class = SwitchPortTable
    template_name = "network/switch-port-list.html"
    table_pagination = False


562 563
class SwitchPortDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                       SuccessMessageMixin, UpdateView):
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    model = SwitchPort
    template_name = "network/switch-port-edit.html"
    form_class = SwitchPortForm
    success_message = _(u'Succesfully modified switch port!')

    def get_success_url(self):
        if 'pk' in self.kwargs:
            return reverse_lazy('network.switch_port', kwargs=self.kwargs)

    def get_context_data(self, **kwargs):
        context = super(SwitchPortDetail, self).get_context_data(**kwargs)
        context['switch_port_pk'] = self.object.pk
        context['devices'] = EthernetDevice.objects.filter(
            switch_port=self.object.pk)
        return context


581 582
class SwitchPortCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                       SuccessMessageMixin, CreateView):
583 584 585 586 587 588
    model = SwitchPort
    template_name = "network/switch-port-create.html"
    form_class = SwitchPortForm
    success_message = _(u'Successfully created switch port!')


589
class SwitchPortDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
590 591 592 593 594 595 596 597 598 599 600
    model = SwitchPort
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('network.switch_port_list')


601
class VlanList(LoginRequiredMixin, SuperuserRequiredMixin, SingleTableView):
602 603 604 605 606 607
    model = Vlan
    table_class = VlanTable
    template_name = "network/vlan-list.html"
    table_pagination = False


608 609
class VlanDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, UpdateView):
610 611 612 613 614
    model = Vlan
    template_name = "network/vlan-edit.html"
    form_class = VlanForm
    slug_field = 'vid'
    slug_url_kwarg = 'vid'
615
    success_message = _(u'Succesfully modified vlan %(name)s!')
616 617 618

    def get_context_data(self, **kwargs):
        context = super(VlanDetail, self).get_context_data(**kwargs)
619 620 621 622 623

        q = Host.objects.filter(interface__in=Interface.objects.filter(
            vlan=self.object, instance__destroyed=None
        ))

624 625 626 627 628 629 630
        context['host_list'] = SmallHostTable(q)
        context['vlan_vid'] = self.kwargs.get('vid')
        return context

    success_url = reverse_lazy('network.vlan_list')


631 632
class VlanCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                 SuccessMessageMixin, CreateView):
633 634 635
    model = Vlan
    template_name = "network/vlan-create.html"
    form_class = VlanForm
636
    success_message = _(u'Successfully created vlan %(name)s!')
637 638


639
class VlanDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
    model = Vlan
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('network.vlan_list')

    def get_object(self, queryset=None):
        """ we identify vlans by vid and not pk """
        return Vlan.objects.get(vid=self.kwargs['vid'])

    def delete(self, request, *args, **kwargs):
        self.object = self.get_object()
        if unicode(self.object) != request.POST.get('confirm'):
657
            messages.error(request, _(u"Object name does not match!"))
658 659 660
            return self.get(request, *args, **kwargs)

        response = super(VlanDelete, self).delete(request, *args, **kwargs)
661
        messages.success(request, _(u"Vlan successfully deleted!"))
662 663 664 665 666 667 668 669 670 671
        return response

    def get_context_data(self, **kwargs):
        context = super(VlanDelete, self).get_context_data(**kwargs)

        deps = []
        # hosts
        hosts = Host.objects.filter(vlan=self.object).all()
        if len(hosts) > 0:
            deps.append({
672
                'name': _('Hosts'),
673 674 675 676 677 678 679
                'data': hosts
            })

            # records
            records = Record.objects.filter(host__in=deps[0]['data'])
            if len(records) > 0:
                deps.append({
680
                    'name': _('Records'),
681 682 683 684 685 686 687 688
                    'data':  records
                })

        context['deps'] = deps
        context['confirmation'] = True
        return context


689 690
class VlanGroupList(LoginRequiredMixin, SuperuserRequiredMixin,
                    SingleTableView):
691 692 693 694 695 696
    model = VlanGroup
    table_class = VlanGroupTable
    template_name = "network/vlan-group-list.html"
    table_pagination = False


697 698
class VlanGroupDetail(LoginRequiredMixin, SuperuserRequiredMixin,
                      SuccessMessageMixin, UpdateView):
699 700 701 702
    model = VlanGroup
    template_name = "network/vlan-group-edit.html"
    form_class = VlanGroupForm
    success_url = reverse_lazy('network.vlan_group_list')
703
    success_message = _(u'Successfully modified vlan group %(name)s!')
704 705 706 707 708 709 710

    def get_context_data(self, *args, **kwargs):
        context = super(VlanGroupDetail, self).get_context_data(**kwargs)
        context['vlangroup_pk'] = self.object.pk
        return context


711 712
class VlanGroupCreate(LoginRequiredMixin, SuperuserRequiredMixin,
                      SuccessMessageMixin, CreateView):
713 714 715
    model = VlanGroup
    template_name = "network/vlan-group-create.html"
    form_class = VlanGroupForm
716
    success_message = _(u'Successfully created vlan group %(name)s!')
717 718


719
class VlanGroupDelete(LoginRequiredMixin, SuperuserRequiredMixin, DeleteView):
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
    model = VlanGroup
    template_name = "network/confirm/base_delete.html"

    def get_success_url(self):
        next = self.request.POST.get('next')
        if next:
            return next
        else:
            return reverse_lazy('network.vlan_group_list')


def remove_host_group(request, **kwargs):
    host = Host.objects.get(pk=kwargs['pk'])
    group = Group.objects.get(pk=kwargs['group_pk'])

    # for get we show the confirmation page
    if request.method == "GET":
        return render(request,
                      'network/confirm/remove_host_group.html',
                      {
                          'group': group.name,
                          'host': host.hostname
                      })

    # for post we actually remove the group from the host
    elif request.method == "POST":
        host.groups.remove(group)
747
        if not request.is_ajax():
748
            messages.success(request, _(u"Successfully removed %(host)s from "
749 750 751 752
                                        "%(group)s group!" % {
                                            'host': host,
                                            'group': group
                                        }))
753 754 755 756 757 758 759 760 761 762
        return redirect(reverse_lazy('network.host',
                                     kwargs={'pk': kwargs['pk']}))


def add_host_group(request, **kwargs):
    group_pk = request.POST.get('group')
    if request.method == "POST" and group_pk:
        host = Host.objects.get(pk=kwargs['pk'])
        group = Group.objects.get(pk=group_pk)
        host.groups.add(group)
763
        if not request.is_ajax():
764
            messages.success(request, _(u"Successfully added %(host)s to group"
765 766 767 768
                                        " %(group)s!" % {
                                            'host': host,
                                            'group': group
                                        }))
769
        return redirect(reverse_lazy('network.host', kwargs=kwargs))
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813


def remove_switch_port_device(request, **kwargs):
    device = EthernetDevice.objects.get(pk=kwargs['device_pk'])
    # for get we show the confirmation page
    if request.method == "GET":
        return render(request, 'network/confirm/base_delete.html',
                      {'object': device})

    # for post we actually remove the group from the host
    elif request.method == "POST":
        device.delete()
        if not request.is_ajax():
            messages.success(request, _(u"Successfully deleted ethernet device"
                                        " %(name)s!" % {
                                            'name': device.name,
                                        }))
        return redirect(reverse_lazy('network.switch_port',
                                     kwargs={'pk': kwargs['pk']}))


def add_switch_port_device(request, **kwargs):
    device_name = request.POST.get('device_name')

    if (request.method == "POST" and device_name and len(device_name) > 0
       and EthernetDevice.objects.filter(name=device_name).count() == 0):

        switch_port = SwitchPort.objects.get(pk=kwargs['pk'])
        new_device = EthernetDevice(name=device_name, switch_port=switch_port)
        new_device.save()
        if not request.is_ajax():
            messages.success(request, _(u"Successfully added %(name)s to this"
                                        " switch port" % {
                                            'name': device_name,
                                        }))
        return redirect(reverse_lazy('network.switch_port', kwargs=kwargs))

    elif not len(device_name) > 0:
        messages.error(request, _("Ethernet device name cannot be empty!"))
        return redirect(reverse_lazy('network.switch_port', kwargs=kwargs))
    elif EthernetDevice.objects.get(name=device_name) is not None:
        messages.error(request, _("There is already an ethernet device with"
                                  " that name!"))
        return redirect(reverse_lazy('network.switch_port', kwargs=kwargs))