def search(request): """Controller for searching for locations""" navpath = get_path() locations = Location.objects.none() titles = navpath if "query" in request.GET: searchform = LocationSearchForm(request.GET, auto_id=False) if searchform.is_valid(): titles.append(("Search for %s" % request.GET['query'], )) locations = process_searchform(searchform) else: searchform = LocationSearchForm() return render( request, "info/location/base.html", { "searchform": searchform, "locations": locations, "navpath": navpath, "title": create_title(titles) }, )
def poegroup_details(request, netbox_sysname, grpindex): """Show detailed view of one IP device power over ethernet group""" poegroup = get_object_or_404( POEGroup.objects.select_related(), netbox__sysname=netbox_sysname, index=grpindex, ) navpath = NAVPATH + [ ( netbox_sysname, reverse('ipdevinfo-details-by-name', kwargs={'name': netbox_sysname}), ), ('PoE Details for ' + poegroup.name, ), ] return render( request, 'ipdevinfo/poegroup-details.html', { 'poegroup': poegroup, 'navpath': navpath, 'heading': navpath[-1][0], 'title': create_title(navpath), }, )
def index(request): """Renders the default view for the netbox group page :param request: :type request: django.http.HttpRequest """ navpath = get_netboxgroup_path() groups = NetboxGroup.objects.none() if request.method == 'GET' and 'query' in request.GET: form = NetboxGroupForm(request.GET) if form.is_valid(): query = request.GET['query'] id_filter = Q(pk__icontains=query) netbox_filter = Q(netbox__sysname__icontains=query) groups = NetboxGroup.objects.filter( id_filter | netbox_filter).distinct().order_by('id') else: form = NetboxGroupForm() groups = NetboxGroup.objects.all() return render(request, 'info/netboxgroup/list_groups.html', {'netboxgroups': groups, 'searchform': form, 'navpath': navpath, 'title': create_title(navpath)})
def service_list(request, handler=None): """List services with given handler or any handler""" page = request.GET.get('page', '1') services = Service.objects.select_related('netbox').order_by( 'netbox__sysname', 'handler') if handler: services = services.filter(handler=handler) handler_list = Service.objects.values('handler').distinct() navpath = NAVPATH + [('Service List', )] # Pass on to generic view return SubListView.as_view( queryset=services, paginate_by=100, template_name='ipdevinfo/service-list.html', allow_empty=True, extra_context={ 'show_ipdev_info': True, 'handler_list': handler_list, 'handler': handler, 'title': create_title(navpath), 'navpath': navpath, 'heading': navpath[-1][0], 'services': services, 'page': page, 'template_object_name': 'service' }, )(request)
def add_threshold(request, metric=None): """Controller for threshold search""" if request.method == 'POST': form = ThresholdForm(request.POST) metric = request.POST.get('target') if form.is_valid(): handle_threshold_form(form, request) return redirect('threshold-index') else: if metric: form = ThresholdForm(initial={'target': metric}) else: form = ThresholdForm() heading = 'Add threshold rule' navpath = get_path() + [(heading, )] title = create_title(navpath) context = { 'heading': heading, 'form': form, 'metric': metric, 'title': title, 'navpath': navpath, 'id': None, } return render(request, 'threshold/set_threshold.html', context)
def upload_image(request, roomid): """Controller for uploading an image""" room = get_object_or_404(Room, pk=roomid) navpath = get_path() + [ (room.id, reverse('room-info', kwargs={'roomid': room.id})), ('Edit images',) ] account = get_account(request) if request.method == 'POST': _logger.debug('Uploading images') images = request.FILES.getlist('images') for image in images: try: handle_image(image, room, uploader=account) messages.success( request, 'Image «%s» uploaded' % image.name) except IOError as e: _logger.error(e) messages.error(request, 'Image «%s» not saved - ' 'perhaps unsupported type' % image.name) return redirect("room-info-upload", roomid=room.id) return render_to_response("info/room/upload.html", {"room": room, "navpath": navpath, "title": create_title(navpath)}, context_instance=RequestContext(request))
def index(request): """Main controller""" searchproviders = [] navpath = [('Home', '/'), ('Search', reverse('info-search'))] titles = navpath if "query" in request.GET: form = SearchForm(request.GET, auto_id=False) if form.is_valid(): titles.append(('Search for "%s"' % request.GET["query"], )) searchproviders = process_form(form) if has_only_one_result(searchproviders): return HttpResponseRedirect(searchproviders[0].results[0].href) else: form = SearchForm() return render_to_response("info/base.html", { "form": form, "searchproviders": searchproviders, "navpath": navpath, "title": create_title(titles) }, context_instance=RequestContext(request))
def service_list(request, handler=None): """List services with given handler or any handler""" page = request.GET.get('page', '1') services = Service.objects.select_related(depth=1).order_by( 'netbox__sysname', 'handler') if handler: services = services.filter(handler=handler) handler_list = Service.objects.values('handler').distinct() navpath = NAVPATH + [('Service List', )] # Pass on to generic view return object_list(request, services, paginate_by=100, page=page, template_name='ipdevinfo/service-list.html', extra_context={ 'show_ipdev_info': True, 'handler_list': handler_list, 'handler': handler, 'title': create_title(navpath), 'navpath': navpath, 'heading': navpath[-1][0] }, allow_empty=True, context_processors=[search_form_processor], template_object_name='service')
def search(request): """Controller for searching for rooms""" navpath = get_path() rooms = Room.objects.none() titles = navpath if "query" in request.GET: searchform = RoomSearchForm(request.GET, auto_id=False) if searchform.is_valid(): titles.append(("Search for %s" % request.GET['query'],)) rooms = process_searchform(searchform) for room in rooms: room.netboxes = filter_netboxes(room) else: searchform = RoomSearchForm() return render( request, "info/room/base.html", { "searchform": searchform, "rooms": rooms, "navpath": navpath, "title": create_title(titles) } )
def search(request): """Search for an IP device""" titles = NAVPATH errors = [] netboxes = None query = None if 'query' in request.GET: search_form = SearchForm(request.GET) if search_form.is_valid(): # Preprocess query string query = search_form.cleaned_data['query'].strip().lower() titles = titles + [("Search for %s" % query,)] netboxes = find_netboxes(errors, query) # If only one hit, redirect to details view if netboxes and len(netboxes) == 1: return ipdev_details(request, name=netboxes[0].sysname) else: search_form = SearchForm() return render_to_response('ipdevinfo/search.html', {'errors': errors, 'netboxes': netboxes, 'navpath': NAVPATH, 'query': query, 'title': create_title(titles), 'search_form': search_form}, context_instance=RequestContext( request, processors=[search_form_processor]))
def service_matrix(request): """Show service status in a matrix with one IP Device per row and one service handler per column""" handler_list = [ h['handler'] for h in Service.objects.values('handler').distinct() ] matrix_dict = {} for service in Service.objects.select_related(depth=1): if service.netbox.id not in matrix_dict: matrix_dict[service.netbox.id] = { 'sysname': service.netbox.sysname, 'netbox': service.netbox, 'services': [None for _ in handler_list], } index = handler_list.index(service.handler) matrix_dict[service.netbox.id]['services'][index] = service matrix = matrix_dict.values() navpath = NAVPATH + [('Service Matrix', )] return render_to_response('ipdevinfo/service-matrix.html', { 'handler_list': handler_list, 'matrix': matrix, 'title': create_title(navpath), 'navpath': navpath, 'heading': navpath[-1][0] }, context_instance=RequestContext( request, processors=[search_form_processor]))
def service_list(request, handler=None): """List services with given handler or any handler""" page = request.GET.get('page', '1') services = Service.objects.select_related(depth=1).order_by( 'netbox__sysname', 'handler') if handler: services = services.filter(handler=handler) handler_list = Service.objects.values('handler').distinct() navpath = NAVPATH + [('Service List',)] # Pass on to generic view return object_list( request, services, paginate_by=100, page=page, template_name='ipdevinfo/service-list.html', extra_context={ 'show_ipdev_info': True, 'handler_list': handler_list, 'handler': handler, 'title': create_title(navpath), 'navpath': navpath, 'heading': navpath[-1][0] }, allow_empty=True, context_processors=[search_form_processor], template_object_name='service')
def vlan_details(request, vlanid): """Render details for a vlan""" vlan = get_object_or_404(Vlan.objects.select_related(depth=1), pk=vlanid) prefixes = sorted(vlan.prefix_set.all(), key=methodcaller('get_prefix_size')) has_v6 = False has_v4 = False for prefix in prefixes: version = IP(prefix.net_address).version() if version == 6: has_v6 = True elif version == 4: has_v4 = True navpath = get_path([(str(vlan), '')]) return render_to_response('info/vlan/vlandetails.html', {'vlan': vlan, 'prefixes': prefixes, 'gwportprefixes': find_gwportprefixes(vlan), 'navpath': navpath, 'has_v4': has_v4, 'has_v6': has_v6, 'title': create_title(navpath)}, context_instance=RequestContext(request))
def search(request): """Search for an IP device""" titles = NAVPATH errors = [] netboxes = None query = None if 'query' in request.GET: search_form = SearchForm(request.GET) if search_form.is_valid(): # Preprocess query string query = search_form.cleaned_data['query'].strip().lower() titles = titles + [("Search for %s" % query, )] netboxes = find_netboxes(errors, query) # If only one hit, redirect to details view if netboxes and len(netboxes) == 1: return ipdev_details(request, name=netboxes[0].sysname) else: search_form = SearchForm() return render_to_response('ipdevinfo/search.html', { 'errors': errors, 'netboxes': netboxes, 'navpath': NAVPATH, 'query': query, 'title': create_title(titles), 'search_form': search_form }, context_instance=RequestContext( request, processors=[search_form_processor]))
def group_edit(request, groupid): """Renders the view for editing device groups :param request: :type request: django.http.HttpRequest """ group = get_object_or_404(NetboxGroup, pk=groupid) navpath = get_netboxgroup_path([(group.pk, ), ('edit', )]) if request.method == 'POST': return handle_edit_request(request, group) netboxes = Netbox.objects.exclude( pk__in=group.netbox_set.all().values_list('id', flat=True)) return render( request, 'info/netboxgroup/group_edit.html', { 'netboxgroup': group, 'netboxes': netboxes, 'navpath': navpath, 'title': create_title(navpath), }, )
def group_detail(request, groupid): """Renders the view for group detail :param request: :type request: django.http.HttpRequest """ group = get_object_or_404(NetboxGroup, pk=groupid) netboxes = group.netbox_set.select_related('organization', 'category', 'type') availabilities = get_netboxes_availability(netboxes, data_sources=['availability'], time_frames=['week', 'month']) navpath = get_netboxgroup_path([(group.pk, )]) return render( request, 'info/netboxgroup/group_detail.html', { 'netboxgroup': group, 'netboxes': netboxes, 'availabilities': availabilities, 'navpath': navpath, 'title': create_title(navpath), }, )
def account_charts(request): """Displays the page for account charts""" context = {} if 'send' in request.GET: form = AccountChartsForm(request.GET) if form.is_valid(): days = form.cleaned_data['days'] tables = [] for chart in form.cleaned_data['charts']: query = AcctChartsQuery(chart, days) query.execute() tables.append( (query.table_title, query.result)) context['tables'] = tables else: form = AccountChartsForm() navpath = get_navpath(('Account Charts', )) context.update({ 'navpath': navpath, 'title': create_title(navpath), 'form': form, 'acctcharts': True }) return render_to_response('radius/account_charts.html', context, context_instance=RequestContext(request))
def account_charts(request): """Displays the page for account charts""" context = {} if 'send' in request.GET: form = AccountChartsForm(request.GET) if form.is_valid(): days = form.cleaned_data['days'] tables = [] for chart in form.cleaned_data['charts']: query = AcctChartsQuery(chart, days) query.execute() tables.append((query.table_title, query.result)) context['tables'] = tables else: form = AccountChartsForm() navpath = get_navpath(('Account Charts', )) context.update({ 'navpath': navpath, 'title': create_title(navpath), 'form': form, 'acctcharts': True }) return render_to_response('radius/account_charts.html', context, context_instance=RequestContext(request))
def service_matrix(request): """Show service status in a matrix with one IP Device per row and one service handler per column""" handler_list = [h['handler'] for h in Service.objects.values('handler').distinct()] matrix_dict = {} for service in Service.objects.select_related(depth=1): if service.netbox.id not in matrix_dict: matrix_dict[service.netbox.id] = { 'sysname': service.netbox.sysname, 'netbox': service.netbox, 'services': [None for _ in handler_list], } index = handler_list.index(service.handler) matrix_dict[service.netbox.id]['services'][index] = service matrix = matrix_dict.values() navpath = NAVPATH + [('Service Matrix',)] return render_to_response( 'ipdevinfo/service-matrix.html', { 'handler_list': handler_list, 'matrix': matrix, 'title': create_title(navpath), 'navpath': navpath, 'heading': navpath[-1][0] }, context_instance=RequestContext(request, processors=[search_form_processor]))
def edit_threshold(request, rule_id): """Controller for editing threshold rules""" rule = get_object_or_404(ThresholdRule, pk=rule_id) if request.method == 'POST': form = ThresholdForm(request.POST, instance=rule) metric = request.POST.get('target') if form.is_valid(): handle_threshold_form(form, request) return redirect('threshold-index') else: form = ThresholdForm(instance=rule) metric = rule.target heading = 'Edit threshold rule' navpath = get_path() + [(heading, )] title = create_title(navpath) context = { 'heading': heading, 'form': form, 'metric': metric, 'title': title, 'navpath': navpath, 'id': rule.id, } return render(request, 'threshold/set_threshold.html', context)
def vlan_details(request, vlanid): """Render details for a vlan""" vlan = get_object_or_404(Vlan, pk=vlanid) prefixes = sorted(vlan.prefix_set.all(), key=methodcaller('get_prefix_size')) has_v6 = False has_v4 = False for prefix in prefixes: version = IP(prefix.net_address).version() if version == 6: has_v6 = True elif version == 4: has_v4 = True navpath = get_path([(str(vlan), '')]) return render( request, 'info/vlan/vlandetails.html', { 'vlan': vlan, 'prefixes': prefixes, 'gwportprefixes': find_gwportprefixes(vlan), 'navpath': navpath, 'has_v4': has_v4, 'has_v6': has_v6, 'title': create_title(navpath), }, )
def index(request): """Controller for vlan landing page and search""" vlans = Vlan.objects.none() navpath = get_path() if "query" in request.GET: searchform = VlanSearchForm(request.GET) if searchform.is_valid(): navpath = get_path([('Search for "%s"' % request.GET['query'],)]) vlans = process_searchform(searchform) else: searchform = VlanSearchForm() _logger.debug(vlans) return render( request, "info/vlan/base.html", { 'navpath': navpath, 'title': create_title(navpath), 'form': searchform, 'vlans': vlans, }, )
def index(request): """Renders the default view for the netbox group page :param request: :type request: django.http.HttpRequest """ navpath = get_netboxgroup_path() groups = NetboxGroup.objects.none() if request.method == 'GET' and 'query' in request.GET: form = NetboxGroupForm(request.GET) if form.is_valid(): query = request.GET['query'] id_filter = Q(pk__icontains=query) netbox_filter = Q(netbox__sysname__icontains=query) groups = NetboxGroup.objects.filter( id_filter | netbox_filter).distinct().order_by('id') else: form = NetboxGroupForm() groups = NetboxGroup.objects.all() return render( request, 'info/netboxgroup/list_groups.html', { 'netboxgroups': groups, 'searchform': form, 'navpath': navpath, 'title': create_title(navpath) })
def get_context(): """Returns common context""" navpath = ( ('Home', '/'), ('Event details', ''), ) return {'navpath': navpath, 'title': utils.create_title(navpath)}
def create_context(path, context): """Create a dictionary for use in context based on path""" navpath = NAVPATH + [(path,)] path_context = { 'navpath': navpath, 'title': create_title(navpath) } return dict(path_context.items() + context.items())
def render_page(request, extra_context): """Render the page with a given context""" navpath = [('Home', '/'), ('Unrecognized Neighbors', )] context = { 'navpath': navpath, 'title': create_title(navpath), } context.update(extra_context) return render(request, 'neighbors/base.html', context)
def create_context(path, context): """Create a dictionary for use in context based on path""" navpath = NAVPATH + [(path,)] path_context = { 'navpath': navpath, 'title': create_title(navpath) } path_context.update(context) return path_context
def log_search(request): """Displays the page for doing a radius log search""" context = {} if 'send' in request.GET: form = ErrorLogSearchForm(request.GET) if form.is_valid(): data = form.cleaned_data searchstring = data.get('query')[1] searchtype = data.get('query')[0] hours = timestamp = slack = '' time = data.get('time') timemode = time[0] if time and len(time) == 2 else '' if timemode == 'hours': hours = time[0] elif timemode == 'timestamp': timestamp, slack = split_time(time[1]) query = LogSearchQuery( searchstring, searchtype, data.get('log_entry_type'), timemode, timestamp, slack, hours, 'time', 'DESC' ) query.execute() field_desc = [ LOG_FIELDDESCRIPTIONS[field] for field in LOG_SEARCHRESULTFIELDS ] context.update({ 'field_desc': field_desc, 'result': query.result }) else: context['errors'] = form.errors else: form = ErrorLogSearchForm() navpath = get_navpath(('Error Log',)) context.update({ 'navpath': navpath, 'title': create_title(navpath), 'form': form, 'logsearch': True }) return render_to_response('radius/error_log.html', context, context_instance=RequestContext(request))
def get_base_context(additional_paths=None, form=None): """Returns a base context for portadmin :type additional_paths: list of tuple """ navpath = [('Home', '/'), ('PortAdmin', reverse('portadmin-index'))] if additional_paths: navpath += additional_paths form = form if form else SearchForm() return {'navpath': navpath, 'title': create_title(navpath), 'form': form}
def account_search(request): """Displays the page for doing an account log search""" context = {} if 'send' in request.GET: form = AccountLogSearchForm(request.GET) if form.is_valid(): data = form.cleaned_data days = timestamp = slack = '' time = data.get('time') timemode = time[0] if time and len(time) == 2 else '' if timemode == 'days': days = time[1] elif timemode == 'timestamp': timestamp, slack = split_time(time[1]) dns_lookup = data.get('dns_lookup') query = AcctSearchQuery( data.get('query')[1], data.get('query')[0], data.get('port_type'), timemode, timestamp, slack, days, 'userdns' in dns_lookup, 'nasdns' in dns_lookup, 'acctstarttime', 'DESC' ) query.execute() (total_time, total_sent, total_received) = query.make_stats() context.update({ 'result': query.result, 'total_time': total_time, 'total_sent': total_sent, 'total_received': total_received, }) else: context['errors'] = form.errors else: form = AccountLogSearchForm() navpath = get_navpath(('Account Log', )) context.update({ 'title': create_title(navpath), 'navpath': navpath, 'form': form, 'acctsearch': True }) return render_to_response('radius/account_log.html', context, context_instance=RequestContext(request))
def render_index(request): """Controller for WatchDog index""" navpath = [('Home', '/'), ('WatchDog', )] context = { 'navpath': navpath, 'title': create_title(navpath), 'tests': get_statuses() } return render(request, 'watchdog/base.html', context)
def render_index(request): """Controller for WatchDog index""" navpath = [('Home', '/'), ('WatchDog', )] context = { 'navpath': navpath, 'title': create_title(navpath), 'tests': get_statuses() } return render(request, 'watchdog/base.html', context)
def render_index(request): """Controller for WatchDog index""" navpath = [("Home", "/"), ("WatchDog", )] context = { "navpath": navpath, "title": create_title(navpath), "tests": get_statuses(), } return render(request, "watchdog/base.html", context)
def get_context(prefix=None): """Returns a context for a page with a possible prefix""" navpath = [('Home', '/'), ('Search', reverse('info-search')), ('Prefix', reverse('prefix-index'))] if prefix: navpath.append((prefix.net_address, )) return { 'prefix': prefix, 'navpath': navpath, 'title': utils.create_title(navpath) }
def get_context_data(self, **kwargs): verbs = list(LogEntry.objects.order_by().values_list( 'verb', flat=True).distinct()) verbs.sort() navpath = (get_navpath_root(), ('Audit Log', )) context = { 'auditlog_verbs': verbs, 'navpath': navpath, 'title': create_title(navpath), } context.update(**kwargs) return super(AuditlogOverview, self).get_context_data(**context)
def locationinfo(request, locationid): """Controller for displaying locationinfo""" location = get_object_or_404(Location, id=locationid) navpath = get_path() + [(location.id, )] location.sorted_data = sorted(location.data.items()) return render( request, "info/location/locationinfo.html", { "location": location, "navpath": navpath, "images": location.image_set.all(), "title": create_title(navpath) })
def roominfo(request, roomid): """Controller for displaying roominfo""" room = get_object_or_404(Room, id=roomid) images = room.image_set.all() navpath = get_path() + [(room.id,)] room.sorted_data = sorted(room.data.items()) room.meta_data = get_room_meta(room) return render_to_response("info/room/roominfo.html", {"room": room, "navpath": navpath, "title": create_title(navpath), "images": images}, context_instance=RequestContext(request))
def roominfo(request, roomid): """Controller for displaying roominfo""" room = get_object_or_404(Room, id=roomid) images = room.image_set.all() navpath = get_path() + [(room.id,)] room.sorted_data = sorted(room.data.items()) return render_to_response("info/room/roominfo.html", {"room": room, "navpath": navpath, "title": create_title(navpath), "images": images}, context_instance=RequestContext(request))
def group_detail(request, groupid): """Renders the view for group detail :param request: :type request: django.http.HttpRequest """ group = get_object_or_404(NetboxGroup, pk=groupid) navpath = get_netboxgroup_path([(group.pk,)]) return render(request, 'info/netboxgroup/group_detail.html', {'netboxgroup': group, 'navpath': navpath, 'title': create_title(navpath)})
def upload_image(request, roomid): """Controller for uploading an image""" room = get_object_or_404(Room, pk=roomid) navpath = get_path() + [ (room.id, reverse('room-info', kwargs={'roomid': room.id})), ('Edit images', ) ] account = get_account(request) if request.method == 'POST': _logger.debug('Uploading image') uploadform = UploadForm(request.POST, request.FILES) if uploadform.is_valid(): image = request.FILES['roomimage'].read() original_name = request.FILES['roomimage'].name imagename = "%s%s" % (create_hash( image, True), get_extension(original_name)) imagedirectory = create_hash(room.id) imagedirectorypath = join(ROOMIMAGEPATH, imagedirectory) title = request.POST.get('title') or original_name create_image_directory(imagedirectorypath) save_image(image, join(imagedirectorypath, imagename)) save_thumbnail(imagename, imagedirectorypath, join(imagedirectorypath, 'thumbs')) Image(title=title, path=imagedirectory, name=imagename, room=room, priority=get_next_priority(room), uploader=account).save() messages.success(request, 'Image uploaded') return redirect("room-info-upload", roomid=room.id) else: _logger.debug('Showing upload form') uploadform = UploadForm() return render_to_response("info/room/upload.html", { "room": room, "navpath": navpath, "title": create_title(navpath), 'uploadform': uploadform }, context_instance=RequestContext(request))
def get_base_context(additional_paths=None, form=None): """Returns a base context for portadmin :type additional_paths: list of tuple """ navpath = [('Home', '/'), ('PortAdmin', reverse('portadmin-index'))] if additional_paths: navpath += additional_paths form = form if form else SearchForm() return { 'header': {'name': 'PortAdmin', 'description': 'Configure interfaces on ip devices'}, 'navpath': navpath, 'title': create_title(navpath), 'form': form }
def upload_image(request, roomid): """Controller for uploading an image""" room = get_object_or_404(Room, pk=roomid) navpath = get_path() + [ (room.id, reverse('room-info', kwargs={'roomid': room.id})), ('Edit images',) ] account = get_account(request) if request.method == 'POST': _logger.debug('Uploading image') uploadform = UploadForm(request.POST, request.FILES) if uploadform.is_valid(): image = request.FILES['roomimage'].read() original_name = request.FILES['roomimage'].name imagename = "%s%s" % (create_hash(image, True), get_extension(original_name)) imagedirectory = create_hash(room.id) imagedirectorypath = join(ROOMIMAGEPATH, imagedirectory) title = request.POST.get('title') or original_name create_image_directory(imagedirectorypath) save_image(image, join(imagedirectorypath, imagename)) save_thumbnail(imagename, imagedirectorypath, join(imagedirectorypath, 'thumbs')) Image(title=title, path=imagedirectory, name=imagename, room=room, priority=get_next_priority(room), uploader=account).save() messages.success(request, 'Image uploaded') return redirect("room-info-upload", roomid=room.id) else: _logger.debug('Showing upload form') uploadform = UploadForm() return render_to_response("info/room/upload.html", {"room": room, "navpath": navpath, "title": create_title(navpath), 'uploadform': uploadform}, context_instance=RequestContext(request))
def group_edit(request, groupid): """Renders the view for editing device groups :param request: :type request: django.http.HttpRequest """ group = get_object_or_404(NetboxGroup, pk=groupid) navpath = get_netboxgroup_path([(group.pk,), ('edit',)]) if request.method == 'POST': return handle_edit_request(request, group) netboxes = Netbox.objects.exclude( pk__in=group.netbox_set.all().values_list('id', flat=True)) return render(request, 'info/netboxgroup/group_edit.html', {'netboxgroup': group, 'netboxes': netboxes, 'navpath': navpath, 'title': create_title(navpath)})
def log_detail(request, accountid, template): """Displays log details for accountid with the given template""" query = LogDetailQuery(accountid) query.execute() result = query.result[0] field_desc = [ LOG_FIELDDESCRIPTIONS[field] for field in LOG_DETAILFIELDS] fields = zip(field_desc, result) navpath = get_navpath(('Log Detail', )) context = { 'reverse': reverse('radius-log_detail', args=(accountid, )), 'title': create_title(navpath), 'navpath': navpath, 'fields': fields, } return render_to_response(template, context, context_instance=RequestContext(request))
def index(request): """Controller for vlan landing page and search""" vlans = Vlan.objects.none() navpath = get_path() if "query" in request.GET: searchform = SearchForm(request.GET) if searchform.is_valid(): navpath = get_path([('Search for "%s"' % request.GET['query'], )]) vlans = process_searchform(searchform) else: searchform = SearchForm() LOGGER.debug(vlans) return render_to_response("info/vlan/base.html", {'navpath': navpath, 'title': create_title(navpath), 'form': searchform, 'vlans': vlans}, context_instance=RequestContext(request))
def account_detail(request, accountid, template): """Finds account details for a specific accountid""" query = AcctDetailQuery(accountid) query.execute() result = query.result[0] field_desc = [ ACCT_DBFIELDSDESCRIPTIONS[field] for field in ACCT_DETAILSFIELDS] fields = zip(field_desc, result) navpath = get_navpath(('Account Detail',)) context = { 'reverse': reverse('radius-account_detail', args=(accountid, )), 'title': create_title(navpath), 'navpath': navpath, 'fields': fields, 'result': query.result } return render_to_response(template, context, context_instance=RequestContext(request))
def search(request): """Controller for searching for rooms""" navpath = get_path() rooms = Room.objects.none() titles = navpath if "query" in request.GET: searchform = SearchForm(request.GET, auto_id=False) if searchform.is_valid(): titles.append(("Search for %s" % request.GET['query'],)) rooms = process_searchform(searchform) for room in rooms: room.netboxes = filter_netboxes(room) else: searchform = SearchForm() return render_to_response("info/room/base.html", {"searchform": searchform, "rooms": rooms, "navpath": navpath, "title": create_title(titles)}, context_instance=RequestContext(request))
def index(request): """Main controller""" searchproviders = [] navpath = [('Home', '/'), ('Search', reverse('info-search'))] titles = navpath if "query" in request.GET: form = SearchForm(request.GET, auto_id=False) if form.is_valid(): titles.append(('Search for "%s"' % request.GET["query"],)) searchproviders = process_form(form) if has_only_one_result(searchproviders): return HttpResponseRedirect(searchproviders[0].results[0].href) else: form = SearchForm() return render_to_response("info/base.html", {"form": form, "searchproviders": searchproviders, "navpath": navpath, "title": create_title(titles)}, context_instance=RequestContext(request))
def ipdev_details(request, name=None, addr=None, netbox_id=None): """Show detailed view of one IP device""" if netbox_id: netbox = get_object_or_404(Netbox, id=netbox_id) return HttpResponseRedirect(netbox.get_absolute_url()) def get_netbox(name=None, addr=None): """Lookup IP device in NAV by either hostname or IP address""" # Prefetch related objects as to reduce number of database queries netboxes = Netbox.objects.select_related(depth=2) netbox = None if name: try: netbox = netboxes.get(Q(sysname=name) | Q(ip=name)) except Netbox.DoesNotExist: pass elif addr: try: netbox = netboxes.get(ip=addr) except Netbox.DoesNotExist: pass if not netbox: host_information = get_host_info(name or addr) for address in host_information['addresses']: if 'name' in address: try: netbox = netboxes.get(sysname=address['name']) break # Exit loop at first match except Netbox.DoesNotExist: pass return netbox def get_recent_alerts(netbox, days_back=7, max_num_alerts=15): """Returns the most recents alerts related to a netbox""" # Limit to alerts which where closed in the last days or which are # still open lowest_end_time = dt.datetime.now() - dt.timedelta(days=days_back) filter_stateful = Q(end_time__gt=lowest_end_time) filter_stateless = (Q(end_time__isnull=True) & Q(start_time__gt=lowest_end_time)) queryset = netbox.alerthistory_set.filter( filter_stateful | filter_stateless ).order_by('-start_time') count = queryset.count() raw_alerts = queryset[:max_num_alerts] alerts = [] has_unresolved_alerts = False for alert in raw_alerts: if alert.source.name == 'serviceping': try: alert_type = Service.objects.get(id=alert.subid).handler except Service.DoesNotExist: alert_type = '%s (%s)' % (alert.event_type, alert.subid) else: alert_type = '%s' % alert.event_type try: message = alert.messages.filter(type='sms')[0].message except IndexError: message = None if not has_unresolved_alerts and alert.is_open(): has_unresolved_alerts = True alerts.append({ 'alert': alert, 'type': alert_type, 'message': message, }) return { 'days_back': days_back, 'alerts': alerts, 'count': count, 'is_more_alerts': count > max_num_alerts, 'has_unresolved_alerts': has_unresolved_alerts } def get_prefix_info(addr): """Return prefix based on address""" ipaddr = is_valid_ip(addr) if ipaddr: prefixes = Prefix.objects.select_related().extra( select={"mask_size": "masklen(netaddr)"}, where=["%s << netaddr AND nettype <> 'scope'"], order_by=["-mask_size"], params=[ipaddr])[0:1] if prefixes: return prefixes[0] return None def get_arp_info(addr): """Return arp based on address""" ipaddr = is_valid_ip(addr) if ipaddr: arp_info = Arp.objects.extra( where=["ip = %s"], params=[ipaddr]).order_by('-end_time', '-start_time')[0:1] if arp_info: return arp_info[0] return None def get_cam_info(mac): """Return cam objects based on mac address""" cam_info = Cam.objects.filter(mac=mac).order_by('-end_time', '-start_time')[0:1] return cam_info[0] if cam_info else None # Get data needed by the template addr = is_valid_ip(addr) host_info = None netbox = get_netbox(name=name, addr=addr) # Assign default values to variables no_netbox = { 'prefix': None, 'arp': None, 'cam': None, 'dt_max': dt.datetime.max, 'days_since_active': 7, } alert_info = None job_descriptions = None system_metrics = netbox_availability = [] graphite_error = False # If addr or host not a netbox it is not monitored by NAV if netbox is None: host_info = get_host_info(name or addr) if not addr and len(host_info['addresses']) > 0: # Picks the first address in array if addr not specified addr = host_info['addresses'][0]['addr'] no_netbox['prefix'] = get_prefix_info(addr) netboxgroups = None navpath = NAVPATH + [(host_info['host'], '')] if no_netbox['prefix']: no_netbox['arp'] = get_arp_info(addr) if no_netbox['arp']: no_netbox['cam'] = get_cam_info(no_netbox['arp'].mac) if no_netbox['arp'].end_time < dt.datetime.max: no_netbox['days_since_active'] = \ (dt.datetime.now() - no_netbox['arp'].end_time).days else: alert_info = get_recent_alerts(netbox) netboxgroups = netbox.netboxcategory_set.all() navpath = NAVPATH + [(netbox.sysname, '')] job_descriptions = get_job_descriptions() try: system_metrics = netbox.get_system_metrics() except GraphiteUnreachableError: graphite_error = True try: netbox_availability = netbox.get_availability() except GraphiteUnreachableError: graphite_error = True return render_to_response( 'ipdevinfo/ipdev-details.html', { 'host_info': host_info, 'netbox': netbox, 'interfaces': (netbox.interface_set.order_by('ifindex') if netbox else None), 'counter_types': ('Octets', 'UcastPkts', 'Errors', 'Discards'), 'heading': navpath[-1][0], 'alert_info': alert_info, 'no_netbox': no_netbox, 'netboxgroups': netboxgroups, 'job_descriptions': job_descriptions, 'navpath': navpath, 'title': create_title(navpath), 'system_metrics': system_metrics, 'netbox_availability': netbox_availability, 'graphite_error': graphite_error, }, context_instance=RequestContext(request, processors=[search_form_processor]))
def module_details(request, netbox_sysname, module_name): """Show detailed view of one IP device module""" def get_module_view(module_object, perspective, activity_interval=None): """ Returns a dict structure with all ports on the module. Arguments: perspective -- decides what kind of ports are included. activity_interval -- number of days to check for port activity. """ module = utils.get_module_view( module_object, perspective, activity_interval) if activity_interval is not None: module['activity_interval'] = activity_interval module['activity_interval_start'] = ( dt.datetime.now() - dt.timedelta(days=activity_interval)) # Check if we got data for the entire search interval try: module['activity_data_start'] = ( module_object.netbox.cam_set.order_by( 'start_time')[0].start_time) module['activity_data_interval'] = ( dt.datetime.now() - module['activity_data_start']).days module['activity_complete_data'] = ( module['activity_data_start'] < module['activity_interval_start']) except IndexError: module['activity_data_start'] = None module['activity_data_interval'] = 0 module['activity_complete_data'] = False return module # Get port activity search interval from form activity_interval = 30 if 'interval' in request.GET: activity_interval_form = ActivityIntervalForm(request.GET) if activity_interval_form.is_valid(): activity_interval = activity_interval_form.cleaned_data[ 'interval'] else: activity_interval_form = ActivityIntervalForm( initial={'interval': activity_interval}) module = get_object_or_404(Module.objects.select_related(depth=1), netbox__sysname=netbox_sysname, name=module_name) swportstatus_view = get_module_view(module, 'swportstatus') swportactive_view = get_module_view( module, 'swportactive', activity_interval) gwportstatus_view = get_module_view(module, 'gwportstatus') navpath = NAVPATH + [('Module Details',)] return render_to_response( 'ipdevinfo/module-details.html', { 'module': module, 'swportstatus_view': swportstatus_view, 'swportactive_view': swportactive_view, 'gwportstatus_view': gwportstatus_view, 'activity_interval_form': activity_interval_form, 'activity_interval': activity_interval, 'navpath': navpath, 'heading': navpath[-1][0], 'title': create_title(navpath) }, context_instance=RequestContext(request, processors=[search_form_processor]))
def _build_context(request): nav_path = [('Home', '/'), ('Syslogger', reverse('logger_index'))] results = [] context = {} aggregates = {} if len(request.GET.keys()) > 0: query_dict = request.GET.copy() form = LoggerGroupSearchForm(query_dict) if form.is_valid(): results = LogMessage.objects.filter(time__gte=form.cleaned_data['timestamp_from'], time__lte=form.cleaned_data['timestamp_to']).select_related() if 'priority' in form.cleaned_data and form.cleaned_data['priority']: priority_keyword = form.cleaned_data['priority'] if not isinstance(form.cleaned_data['priority'], list): priority_keyword = [form.cleaned_data['priority']] results = results.filter(newpriority__keyword__in=priority_keyword) if 'mnemonic' in form.cleaned_data and form.cleaned_data['mnemonic']: message_type_mnemonic = form.cleaned_data['mnemonic'] if not isinstance(form.cleaned_data['mnemonic'], list): message_type_mnemonic = [form.cleaned_data['mnemonic']] results = results.filter(type__mnemonic__in=message_type_mnemonic) if 'facility' in form.cleaned_data and form.cleaned_data['facility']: message_type_facility = form.cleaned_data['facility'] if not isinstance(form.cleaned_data['facility'], list): message_type_facility = [form.cleaned_data['facility']] results = results.filter(type__facility__in=message_type_facility) if form.cleaned_data["category"]: categories = form.cleaned_data['category'] if not isinstance(form.cleaned_data['category'], list): categories = [form.cleaned_data['category']] results = results.filter(origin__category__in=categories) if 'origin' in form.cleaned_data and form.cleaned_data['origin']: origin_name = form.cleaned_data['origin'] if not isinstance(form.cleaned_data['origin'], list): origin_name = [form.cleaned_data['origin']] results = results.filter(origin__name__in=origin_name) priorities = results.values('newpriority__keyword').annotate(sum=Count('newpriority__keyword')) priorities_headers = ['Priority'] message_types = results.values('type__facility', 'type__priority__keyword', 'type__mnemonic').annotate(sum=Count('type')) message_types_headers = ['Facility', 'Priority', 'State'] origins = results.values('origin__name').annotate(sum=Count('origin__name')) origins_headers = ['Origin'] aggregates.update({'Priorities' : { 'values': priorities, 'headers': priorities_headers, 'colspan': 1} }) aggregates.update({'Type': { 'values': message_types, 'headers': message_types_headers, 'colspan': 3 }}) aggregates.update({'Origin': { 'values': origins, 'headers': origins_headers, 'colspan': 1 }}) def _update_show_log_context(value, results): if value: context.update({'log_messages': results}) context.update({'show_log': value}) form.data = form.data.copy() # mutable QueryDict, yes please form.data['show_log'] = value if 'show_log' in form.cleaned_data and form.cleaned_data['show_log']: show_log = bool(form.cleaned_data['show_log']) _update_show_log_context(show_log, results) if len(priorities) <= 1 and len(origins) <= 1: _update_show_log_context(True, results) elif len(message_types) <= 1 and len(priorities) <= 1: _update_show_log_context(True, results) else: initial_context = { 'timestamp_from': (datetime.datetime.now() - datetime.timedelta(days=1)), 'timestamp_to': datetime.datetime.now() } form = LoggerGroupSearchForm(initial=initial_context) strip_query_args = _strip_empty_arguments(request) strip_query_args = strip_query_args.urlencode() if strip_query_args else "" context.update({ 'form': form, 'bookmark': "{0}?{1}".format(reverse(index), strip_query_args), 'aggregates': aggregates, 'timestamp': datetime.datetime.now().strftime(DATEFORMAT), 'domain_strip': simplejson.dumps(DOMAIN_SUFFICES), 'navpath': nav_path, 'title': create_title(nav_path) }) return context