radarsys Commit - r32:e512425c47f1 · Jicamarca Repository

DDS app updated...

Miguel Urco -

r32:e512425c47f1

parent child

Context file:

r32:e512425c47f1

Collapse all files

apps/dds/files.py created 644 +93 0

@@ -0,0 +1,93
	1	'''
	2	Created on Feb 8, 2016
	3
	4	@author: Miguel Urco
	5	'''
	6
	7	import string
	8
	9	def read_dds_file(fp):
	10	"""
	11	Function to extract the parameters from a text file with the next format:
	12
	13	Input:
	14
	15	File with the next content:
	16
	17	Phase Adjust Register 1
	18	-----------------------
	19	00000000
	20	00000000
	21
	22	.....
	23
	24	-----------------------
	25	Frequency Tuning Word 1
	26	-----------------------
	27	00110101
	28	01111111
	29	11111111
	30	11111111
	31	10100000
	32	00000000
	33
	34	Output:
	35	Return configuration parameters for DDS: multiplier, frequency, phase, amplitude, etc.
	36
	37	"""
	38
	39	kwargs = {}
	40	dds_registers = []
	41
	42	for this_line in fp:
	43	this_line = str.strip(this_line)
	44
	45	if not str.isdigit(this_line):
	46	continue
	47
	48	if len(this_line) != 8:
	49	continue
	50
	51	dds_registers.append(string.atoi(this_line,2))
	52
	53	if len(dds_registers) != 40:
	54	return kwargs
	55
	56	kwargs['clock'] = 60.0
	57
	58	kwargs['phase_bin'] = dds_registers[0](2*8) + dds_registers[1]
	59	kwargs['phase_mod_bin'] = dds_registers[2](2*8) + dds_registers[3]
	60
	61	kwargs['frequency_bin'] = dds_registers[4](240) + dds_registers[5](2*32) + dds_registers[6](2*24) + dds_registers[7](2*16) + dds_registers[8](2**8) + dds_registers[9]
	62	kwargs['frequency_mod_bin'] = dds_registers[10](240) + dds_registers[11](2*32) + dds_registers[12](2*24) + dds_registers[13](2*16) + dds_registers[14](2**8) + dds_registers[15]
	63
	64	kwargs['delta_frequency'] = dds_registers[16](240) + dds_registers[17](2*32) + dds_registers[18](2*24) + dds_registers[19](2*16) + dds_registers[20](2**8) + dds_registers[21]
	65
	66	kwargs['update_clock'] = dds_registers[22](224) + dds_registers[23](2*16) + dds_registers[24](2**8) + dds_registers[25]
	67
	68	kwargs['ramp_rate_clock'] = dds_registers[26](216) + dds_registers[27](2**8) + dds_registers[28]
	69
	70	kwargs['control_register'] = dds_registers[29](224) + dds_registers[30](2*16) + dds_registers[31](2**8) + dds_registers[32]
	71
	72	kwargs['multiplier'] = dds_registers[30] & 0x1F
	73	kwargs['modulation'] = (dds_registers[31] & 0x0E) >> 1
	74	kwargs['amplitude_enabled'] = (dds_registers[32] & 0x20) >> 5
	75
	76	kwargs['amplitude_ch_A'] = (dds_registers[33](2*8) + dds_registers[34]) & 0x0FFF
	77	kwargs['amplitude_ch_B'] = (dds_registers[35](2*8) + dds_registers[36]) & 0x0FFF
	78
	79	kwargs['amplitude_ramp_rate'] = dds_registers[37]
	80
	81	return kwargs
	82
	83	def read_json_file(fp):
	84
	85	kwargs = {}
	86
	87	return kwargs
	88
	89	def write_dds_file(filename):
	90	pass
	91
	92	def write_json_file(filename):
	93	pass No newline at end of file

apps/dds/templates/dds_conf_import.html created 644 +7 0

@@ -0,0 +1,7
	1	{% extends "dev_conf_edit.html" %}
	2	{% load bootstrap3 %}
	3	{% load static %}
	4	{% load main_tags %}
	5
	6	{% block extra-js%}
	7	{% endblock %} No newline at end of file

apps/dds/forms.py +10 0

             from django import forms
             from apps.main.models import Device
             from .models import DDSConfiguration
             # from django.core.validators import MinValueValidator, MaxValueValidator
+            EXT_TYPES = (
+                ('dds', '.dds'),
+                ('json', '.json'),
+            )
             class DDSConfigurationForm(forms.ModelForm):
             #     frequency_bin = forms.IntegerField(label='Frequency (Binary)', required=False)
             #     phase_bin = forms.IntegerField(label='Phase (Binary)', required=False)
             #     frequency_mod_bin = forms.IntegerField(label='Frequency Mod (Binary)', required=False)
             #     phase_mod_bin = forms.IntegerField(label='Phase Mod (Binary)', required=False)
                 field_order = ['experiment', 'device',
                                'clock', 'multiplier',
                                'frequency',
                                'frequency_bin',
                                'phase',
                                'phase_bin',
                                'amplitude_chA', 'amplitude_chB',
                                'modulation',
                                'frequency_mod',
                                'frequency_mod_bin',
                                'phase_mod',
                                'phase_mod_bin']
                 def __init__(self, *args, **kwargs):
                     #request = kwargs.pop('request')
                     super(DDSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='dds')
                         self.fields['experiment'].widget.attrs['readonly'] = True
                         self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                 def clean(self):
                     # Custom validation to force an integer when type of unit = "Unit"
                     return
                 class Meta:
                     model = DDSConfiguration
                     exclude = ('type','parameters')
+            class UploadFileForm(forms.Form):
+                title = forms.ChoiceField(label='Extension Type', choices=EXT_TYPES)
+                file = forms.FileField()
  No newline at end of file

apps/dds/models.py +54 -5

             from django.db import models
             from apps.main.models import Configuration
             # Create your models here.
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.exceptions import ValidationError
+            from files import read_dds_file, read_json_file
             MOD_TYPES = (
                 (0, 'Single Tone'),
                 (1, 'FSK'),
                 (2, 'Ramped FSK'),
                 (3, 'Chirp'),
                 (4, 'BPSK'),
             )
             class DDSConfiguration(Configuration):
                 DDS_NBITS = 48
-                clock = models.FloatField(verbose_name='Clock Master (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True)
+                clock = models.FloatField(verbose_name='Clock Input (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True)
                 multiplier = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=4)
-                frequency = models.DecimalField(verbose_name='Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=18, decimal_places=16)
+                frequency = models.DecimalField(verbose_name='Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16)
                 frequency_bin = models.BigIntegerField(verbose_name='Frequency (Binary)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)])
                 phase = models.FloatField(verbose_name='Phase (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], default=0)
             #     phase_binary = models.PositiveIntegerField(verbose_name='Phase (Binary)',validators=[MinValueValidator(0), MaxValueValidator(2**14-1)])
-                amplitude_ch_A = models.PositiveIntegerField(verbose_name='Amplitude CH A',validators=[MinValueValidator(0), MaxValueValidator(2**10-1)], blank=True, null=True)
+                amplitude_ch_A = models.PositiveIntegerField(verbose_name='Amplitude CH A',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
-                amplitude_ch_B = models.PositiveIntegerField(verbose_name='Amplitude CH B',validators=[MinValueValidator(0), MaxValueValidator(2**10-1)], blank=True, null=True)
+                amplitude_ch_B = models.PositiveIntegerField(verbose_name='Amplitude CH B',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
                 modulation = models.PositiveIntegerField(verbose_name='Modulation Type', choices = MOD_TYPES, default = 0)
-                frequency_mod = models.DecimalField(verbose_name='Mod: Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=18, decimal_places=16, blank=True, null=True)
+                frequency_mod = models.DecimalField(verbose_name='Mod: Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 frequency_mod_bin = models.BigIntegerField(verbose_name='Mod: Frequency (Binary)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 phase_mod = models.FloatField(verbose_name='Mod: Phase (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], blank=True, null=True)
             #     phase_binary_mod = models.PositiveIntegerField(verbose_name='Phase Mod (Binary)',validators=[MinValueValidator(0), MaxValueValidator(2**14-1)], blank=True, null=True)
                 def get_nbits(self):
                     return self.DDS_NBITS
                 def clean(self):
                     if self.modulation in [1,2,3]:
                         if self.frequency_mod is None or self.frequency_mod_bin is None:
                             raise ValidationError({
                                 'frequency_mod': 'Frequency modulation has to be defined when FSK or Chirp modulation is selected'
                             })
                     if self.modulation in [4,]:
                         if self.phase_mod is None:
                             raise ValidationError({
                                 'phase_mod': 'Phase modulation has to be defined when BPSK modulation is selected'
                             })
                 def verify_frequencies(self):
                     return True
                 def freq2binary(self, freq, mclock):
                     binary = (float(freq)/mclock)*(2**self.DDS_NBITS)
                     return binary
                 def binary2freq(self, binary, mclock):
                     freq = (float(binary)/(2**self.DDS_NBITS))*mclock
                     return freq
+                def phase2binary(self, phase):
+                    binary = phase*8192/180.0
+                    return binary
+                def binary2phase(self, binary):
+                    phase = binary*180.0/8192
+                    return phase
+                def export_file(self, ext_file="dds"):
+                    pass
+                def update_from_file(self, fp, ext_file="dds"):
+                    if ext_file == "dds":
+                        kwargs = read_dds_file(fp)
+                    else:
+                        kwargs = read_json_file(fp)
+                    if not kwargs:
+                        return False
+                    self.clock = kwargs['clock']
+                    self.multiplier = kwargs['multiplier']
+                    mclock = self.clock*self.multiplier
+                    self.frequency = self.binary2freq(kwargs['frequency_bin'], mclock)
+                    self.frequency_bin = kwargs['frequency_bin']
+                    self.frequency_mod = self.binary2freq(kwargs['frequency_mod_bin'], mclock)
+                    self.frequency_mod_bin = kwargs['frequency_mod_bin']
+                    self.phase = self.binary2phase(kwargs['phase_bin'])
+                    self.phase_mod = self.binary2phase(kwargs['phase_mod_bin'])
+                    self.modulation = kwargs['modulation']
+                    self.amplitude_ch_A = kwargs['amplitude_ch_A']
+                    self.amplitude_ch_B = kwargs['amplitude_ch_B']
+                    return True
                 class Meta:
                     db_table = 'dds_configurations'
   No newline at end of file

apps/dds/urls.py +1 -1

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^(?P<id_conf>-?\d+)/$', 'apps.dds.views.dds_conf', name='url_dds_conf'),
                 url(r'^(?P<id_conf>-?\d+)/(?P<message>-?\d+)/$', 'apps.dds.views.dds_conf', name='url_dds_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', 'apps.dds.views.dds_conf_edit', name='url_edit_dds_conf'),
                 url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.dds.views.dds_conf_write', name='url_write_dds_conf'),
                 url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.dds.views.dds_conf_read', name='url_read_dds_conf'),
-                url(r'^(?P<id_conf>-?\d+)/import/$', 'apps.main.views.dev_conf_import', name='url_import_dds_conf'),
+                url(r'^(?P<id_conf>-?\d+)/import/$', 'apps.dds.views.dds_conf_import', name='url_import_dds_conf'),
                 url(r'^(?P<id_conf>-?\d+)/export/$', 'apps.main.views.dev_conf_export', name='url_export_dds_conf'),
             )

apps/dds/views.py +73 -15

             # Create your views here.
             from django.contrib import messages
             from django.shortcuts import redirect, render, get_object_or_404
+            from django.core.exceptions import ValidationError
             # from apps.main.models import Experiment, Configuration
             from apps.main.views import sidebar
             from .models import DDSConfiguration
-            from .forms import DDSConfigurationForm
+            from .forms import DDSConfigurationForm, UploadFileForm
             # Create your views here.
             from radarsys_api import dds
             def dds_conf(request, id_conf):
                 conf = get_object_or_404(DDSConfiguration, pk=id_conf)
                 answer = dds.echo(ip=str(conf.device.ip_address), port=conf.device.port_address)
                 kwargs = {}
                 kwargs['connected'] = (answer[0] == "1")
+                if not kwargs['connected']:
+                    messages.error(request, message=answer)
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['experiment', 'device',
                                            'clock', 'multiplier',
                                            'frequency',
                                             'frequency_bin',
                                             'phase',
             #                                'phase_binary',
                                            'amplitude_ch_A', 'amplitude_ch_B',
                                             'modulation',
                                             'frequency_mod',
                                             'frequency_mod_bin',
                                             'phase_mod']
             #                                'phase_binary_mod']
                 kwargs['title'] = 'DDS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'dds_conf.html', kwargs)
             def dds_conf_edit(request, id_conf):
                 conf = get_object_or_404(DDSConfiguration, pk=id_conf)
                 if request.method=='GET':
                     form = DDSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = DDSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         if conf.verify_frequencies():
                             conf.save()
                             return redirect('url_dds_conf', id_conf=conf.id)
                         ##ERRORS
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'dds_conf_edit.html', kwargs)
             def dds_conf_write(request, id_conf):
                 conf = get_object_or_404(DDSConfiguration, pk=id_conf)
                 answer = dds.write_config(ip=str(conf.device.ip_address),
                                          port=conf.device.port_address,
                                          clock=conf.clock,
                                          multiplier=conf.multiplier,
                                          freq_regA=conf.frequency_bin,
                                          freq_regB=conf.frequency_mod_bin,
                                          modulation=conf.modulation,
-                                         phaseA=conf.phase,
+                                         phaseA=conf.phase2binary(conf.phase),
-                                         phaseB=conf.phase_mod,
+                                         phaseB=conf.phase2binary(conf.phase_mod),
                                          amplitude0=conf.amplitude_ch_A,
                                          amplitude1=conf.amplitude_ch_B)
                 if answer[0] == "1":
                     messages.success(request, answer[2:])
                     conf.pk = None
                     conf.id = None
                     conf.type = 1
                     conf.save()
                 else:
-                    messages.error(request, answer)
+                    messages.error(request, "Could not write the parameters to this device")
-                return redirect('url_dds_conf', id_conf=conf.id)
+                return redirect('url_dds_conf', id_conf=id_conf)
             def dds_conf_read(request, id_conf):
                 conf = get_object_or_404(DDSConfiguration, pk=id_conf)
                 if request.method=='POST':
                     form = DDSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         dds_model = form.save(commit=False)
                         if dds_model.verify_frequencies():
                             dds_model.save()
                             return redirect('url_dds_conf', id_conf=conf.id)
-                    messages.error(request, "Parameters could not be saved. Invalid parameters")
+                    messages.error(request, "Parameters could not be saved")
                     data = {}
                 if request.method=='GET':
                     #mult, freqA, freqB, modulation, phaseA, phaseB, amp0, amp1
                     parms = dds.read_config(ip=conf.device.ip_address,
                                       port=conf.device.port_address)
                     if not parms:
-                        messages.error(request, "Could not read parameters from Device")
+                        messages.error(request, "Could not read dds parameters from this device")
                         return redirect('url_dds_conf', id_conf=conf.id)
-                    data = {'experiment' : conf.experiment.id,
+                    data = {'multiplier' : parms[0],
-                            'device' : conf.device.id,
-                            'clock' : conf.clock,
-                            'multiplier' : parms[0],
                             'frequency' : conf.binary2freq(parms[1], parms[0]*conf.clock),
                             'frequency_bin' : parms[1],
-                            'phase' : parms[4],
+                            'phase' : conf.binary2phase(parms[4]),
                             'amplitude_ch_A' : parms[6],
                             'amplitude_ch_B' : parms[7],
                             'modulation' : parms[3],
                             'frequency_mod' : conf.binary2freq(parms[2], parms[0]*conf.clock),
                             'frequency_mod_bin' : parms[2],
-                            'phase_mod' : parms[5],
+                            'phase_mod' : conf.binary2phase(parms[5]),
                             }
-                form = DDSConfigurationForm(data)
+                    form = DDSConfigurationForm(initial=data, instance=conf)
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
-                return render(request, 'dds_conf_edit.html', kwargs)
  No newline at end of file
+                return render(request, 'dds_conf_edit.html', kwargs)
+            def dds_conf_import(request, id_conf):
+                conf = get_object_or_404(DDSConfiguration, pk=id_conf)
+                if request.method == 'POST':
+                    file_form = UploadFileForm(request.POST, request.FILES)
+                    if file_form.is_valid():
+                        if conf.update_from_file(request.FILES['file']):
+                            try:
+                                conf.full_clean()
+                            except ValidationError as e:
+                                messages.error(request, e)
+                            else:
+                                conf.save()
+                                messages.success(request, "Parameters imported from file: '%s'." %request.FILES['file'].name)
+                                messages.warning(request, "Clock Input could not be read from file, using %3.2fMhz by default. Please update it to its real value" %conf.clock)
+                                return redirect('url_dds_conf', id_conf=conf.id)
+                    messages.error(request, "Could not import parameters from file")
+                else:
+                    file_form = UploadFileForm()
+                kwargs = {}
+                kwargs['id_dev'] = conf.id
+                kwargs['title'] = 'Device Configuration'
+                kwargs['form'] = file_form
+                kwargs['suptitle'] = 'Importing file'
+                kwargs['button'] = 'Import'
+                kwargs.update(sidebar(conf))
+                return render(request, 'dds_conf_import.html', kwargs)
+            def handle_uploaded_file(f):
+                data = {'multiplier' : 5,
+                        'frequency' : 49.92,
+                        'frequency_bin' : 45678,
+                        'phase' : 0,
+                        'amplitude_ch_A' : 1024,
+                        'amplitude_ch_B' : 2014,
+                        'modulation' : 1,
+                        'frequency_mod' : 0,
+                        'frequency_mod_bin' : 0,
+                        'phase_mod' : 180,
+                        }
+                return data
  No newline at end of file

apps/main/models.py +3 -6

             from itertools import chain
             from django.db import models
             from polymorphic import PolymorphicModel
+            from django.core.urlresolvers import reverse
             CONF_TYPES = (
                       (0, 'Active'),
                       (1, 'Historical'),
                      )
             DEV_STATES = (
                       (0, 'No connected'),
                       (1, 'Connected'),
                       (2, 'Configured'),
                       (3, 'Running'),
                      )
             DEV_TYPES = (
                 ('', 'Select a device type'),
                 ('rc', 'Radar Controller'),
                 ('dds', 'Direct Digital Synthesizer'),
                 ('jars', 'Jicamarca Radar Acquisition System'),
                 ('usrp', 'Universal Software Radio Peripheral'),
                 ('cgs', 'Clock Generator System'),
                 ('abs', 'Automatic Beam Switching'),
             )
             # Create your models here.
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc')
                 description = models.TextField(blank=True, null=True)
             #     info = models.TextField(blank=True, null=True)
             #     status = models.PositiveSmallIntegerField(default=1, choices=STATES)
                 class Meta:
                     db_table = 'db_device_types'
                 def __unicode__(self):
                     return u'%s' % self.get_name_display()
             class Device(models.Model):
                 device_type = models.ForeignKey(DeviceType)
                 name = models.CharField(max_length=40, default='')
                 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description = models.TextField(blank=True, null=True)
                 status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES)
             #     serial_number = models.CharField(max_length=40, default='')
             #     mac_address = models.CharField(max_length = 20, null=True, blank=True)
                 class Meta:
                     db_table = 'db_devices'
                 def __unicode__(self):
                     return u'%s | %s' % (self.name, self.ip_address)
             class Campaign(models.Model):
                 name = models.CharField(max_length=40, unique=True)
                 start_date = models.DateTimeField(blank=True, null=True)
                 end_date = models.DateTimeField(blank=True, null=True)
                 tags = models.CharField(max_length=40)
                 description = models.TextField(blank=True, null=True)
                 template = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'db_campaigns'
                 def __unicode__(self):
                     return u'%s' % (self.name)
             class Experiment(models.Model):
                 campaign = models.ForeignKey(Campaign)
                 name = models.CharField(max_length=40, default='')
                 start_time = models.TimeField(default='00:00:00')
                 end_time = models.TimeField(default='23:59:59')
                 class Meta:
                     db_table = 'db_experiments'
                 def __unicode__(self):
                     return u'[%s]: %s' % (self.campaign.name, self.name)
             class Configuration(PolymorphicModel):
                 experiment = models.ForeignKey(Experiment)
                 device = models.ForeignKey(Device)
                 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters = models.TextField(default='{}')
                 class Meta:
                     db_table = 'db_configurations'
                 def __unicode__(self):
                     return u'[%s - %s]: %s' % (self.experiment.campaign.name,
                                             self.experiment.name,
                                             self.device.name)
                 def get_absolute_url(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_import(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_import_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_export(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_export_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_write(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_write_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_read(self):
-                    from django.core.urlresolvers import reverse
                     return reverse('url_read_%s_conf' % self.device.device_type.name, args=[str(self.id)])

apps/main/templates/base.html +2 -3

             <!DOCTYPE html>
             {% load static %}
             <html lang="en">
             <head>
                 <meta charset="utf-8">
                 <title>{% block title %}Jicamarca Integrated Radar System:::::{% endblock %}</title>
                 <meta name="description" content="">
                 <meta name="author" content="">
                 <meta name="viewport" content="width=device-width, initial-scale=1">
                 {# bootstrap_css #}
                 <link href="{% static 'css/bootstrap-flatly.min.css' %}" media="all" rel="stylesheet">
                 <style type="text/css">
                   body {padding-top: 60px}
                   .logo {padding-top: 5px; height: 50px}
                   .clickable-row {cursor: pointer;}
                 </style>
                 <!--[if lt IE 9]>
             	<script src="//html5shim.googlecode.com/svn/trunk/html5.js"></script>
             	<![endif]-->
                 {% block extra-head %}
                 {% endblock %}
             </head>
             <body>
             {% block main_menu %}
             <nav class="navbar navbar-default navbar-fixed-top" role="banner">
                 <div class="container-fluid">
                   <div class="navbar-header">
                     <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navigationbar">
                       <span class="sr-only">Toggle navigation</span>
                       <span class="icon-bar"></span>
                       <span class="icon-bar"></span>
                       <span class="icon-bar"></span>
                     </button>
                     <a class="navbar-brand" href="{% url 'index' %}" style="padding-top:1px"><img class="logo" alt="JRO" src="{% static "images/logo-jro-white-trans.png" %}"></a>
                   </div>
                   <div class="collapse navbar-collapse" id="navigationbar">
                     <ul class="nav navbar-nav">
                       <li class=" dropdown {% block dev-active %}{% endblock %}"><a href="{% url 'url_devices'%}">Devices</a>
                       </li>
                       <li class=" dropdown {% block camp-active %}{% endblock %}"><a href="{% url 'url_campaigns'%}">Campaigns</a>
                       </li>
                       <li class=" dropdown {% block exp-active %}{% endblock %}"><a href="{% url 'url_experiments'%}">Experiments</a>
                       </li>
                       <li class=" dropdown {% block conf-active %}{% endblock %}"><a href="{% url 'url_dev_confs'%}">Device Configurations</a>
                       </li>
                     </ul>
                     <ul class="nav navbar-nav navbar-right">
                       <li class="nav-divider"></li>
                       {% if user.is_authenticated %}
                       <li class="dropdown">
                         <a href="#" class="dropdown-toggle" data-toggle="dropdown">Hi {{ user.username }}<span class="caret"></span></a>
                          <ul class="dropdown-menu" role="menu">
                             <li><a href="#">Control Panel</a></li>
                             <li><a href="{% url 'django.contrib.auth.views.logout' %}">Logout</a></li>
                          </ul>
                       </li>
                       {% else %}
                       <li><a href="{% url 'django.contrib.auth.views.login' %}?next={{request.get_full_path}}">Login</a></li>
                       {% endif %}
                     </ul>
                   </div>
                 </div>
             </nav>
             <div style="clear: both;"></div>
             {% endblock %}
             <div class="container">
                 <div id="page" class="row" style="min-height:600px">
             	   <div class="col-md-3 hidden-xs hidden-sm" role="complementary">
             	   <br><br>
             	       <div id="sidebar">
             	       {% block sidebar%}
                        {% endblock %}
             	       </div>
             	   </div>
             	   <div class="col-md-9 col-xs-12" role="main">
             	   <div class="page-header">
                     <h1>{% block content-title %}{% endblock %} <small>{% block content-suptitle %}{% endblock %}</small></h1>
                    <hr>
                    </div>
                    {% block messages %}
             	       {% if messages %}
             	         {% for message in messages %}
             	         <div class="alert alert-{% if message.tags %}{% if 'error' in message.tags %}danger{% else %}{{ message.tags }}{% endif %}{% else %}info{% endif %} alert-dismissible" role="alert">
             	           <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
             	           <strong>{{message.tags|title}}!</strong> {{ message }}
             	         </div>
             	         {% endfor %}
-            	         <br>
             	       {% endif %}
                    {% endblock %}
             	   {% block content %}
             	   {% endblock %}
-            	   <br>
             	   </div>
             	</div><!--/row-->
             </div> <!-- container -->
             <div id="debug">{{debug}}</div>
             {% block footer %}
             <footer class="footer">
               <div class="container">
               <p><hr></p>
               <p>
               &copy; <a href="http://jro.igp.gob.pe">Jicamarca Radio Observatory</a> - {% now "Y" %}
               </p>
               </div>
             </footer>
             {% endblock %}
             {# bootstrap_javascript jquery=True #}
             <script src="{% static 'js/jquery.min.js' %}"></script>
             <script src="{% static 'js/bootstrap.min.js' %}"></script>
             <script src="{% static 'js/jquery-ui.min.js' %}"></script>
             {% block extra-js %}
             {% endblock%}
             </body>
             </html>

apps/main/templates/dev_conf_edit.html +7 -1

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block conf-active %}active{% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}{{suptitle}}{% endblock %}
             {% block content %}
-            <form class="form" method="post" action="">
+            {% if form.is_multipart %}
+                <form class="form" enctype="multipart/form-data" method="post" action="">
+            {% else %}
+                <form class="form" method="post" action="">
+            {% endif %}
               {% csrf_token %}
               {% bootstrap_form form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
               <br>
               <div class="pull-right">
               <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>
               <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
             </form>
             {% endblock %}
             {% block sidebar%}
             {% include "sidebar_devices.html" %}
             {% endblock %}
             {% block extra-js%}
             {% endblock %}

apps/main/views.py +8 -68

             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib import messages
             from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm
             from apps.cgs.forms import CGSConfigurationForm
             from apps.jars.forms import JARSConfigurationForm
             from apps.usrp.forms import USRPConfigurationForm
             from apps.abs.forms import ABSConfigurationForm
             from apps.rc.forms import RCConfigurationForm
             from apps.dds.forms import DDSConfigurationForm
             from .models import Campaign, Experiment, Device, Configuration
             from apps.cgs.models import CGSConfiguration
             from apps.jars.models import JARSConfiguration
             from apps.usrp.models import USRPConfiguration
             from apps.abs.models import ABSConfiguration
             from apps.rc.models import RCConfiguration
             from apps.dds.models import DDSConfiguration
             # Create your views here.
             CONF_FORMS = {
                 'rc': RCConfigurationForm,
                 'dds': DDSConfigurationForm,
                 'jars': JARSConfigurationForm,
                 'cgs': CGSConfigurationForm,
                 'abs': ABSConfigurationForm,
                 'usrp': USRPConfigurationForm,
             }
             CONF_MODELS = {
                 'rc': RCConfiguration,
                 'dds': DDSConfiguration,
                 'jars': JARSConfiguration,
                 'cgs': CGSConfiguration,
                 'abs': ABSConfiguration,
                 'usrp': USRPConfiguration,
             }
             def index(request):
                 kwargs = {}
                 return render(request, 'index.html', kwargs)
             def devices(request):
                 devices = Device.objects.all().order_by('device_type__name')
             #     keys = ['id', 'device_type__name', 'name', 'ip_address']
                 keys = ['id', 'name', 'ip_address', 'device_type']
                 kwargs = {}
                 kwargs['device_keys'] = keys[1:]
                 kwargs['devices'] = devices#.values(*keys)
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Device'
                 return render(request, 'devices.html', kwargs)
             def device(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 kwargs = {}
                 kwargs['device'] = device
                 kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Device'
                 return render(request, 'device.html', kwargs)
             def device_new(request):
                 if request.method == 'GET':
                     form = DeviceForm()
                 if request.method == 'POST':
                     form = DeviceForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'device_edit.html', kwargs)
             def device_edit(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='GET':
                     form = DeviceForm(instance=device)
                 if request.method=='POST':
                     form = DeviceForm(request.POST, instance=device)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'device_edit.html', kwargs)
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='POST':
                     if request.user.is_staff:
                         device.delete()
                         return redirect('url_devices')
                     return HttpResponse("Not enough permission to delete this object")
                 kwargs = {'object':device, 'dev_active':'active',
                           'url_cancel':'url_device', 'id_item':id_dev}
                 return render(request, 'item_delete.html', kwargs)
             def campaigns(request):
                 campaigns = Campaign.objects.all().order_by('start_date')
                 keys = ['id', 'name', 'start_date', 'end_date']
                 kwargs = {}
                 kwargs['campaign_keys'] = keys[1:]
                 kwargs['campaigns'] = campaigns#.values(*keys)
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Campaign'
                 return render(request, 'campaigns.html', kwargs)
             def campaign(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 experiments = Experiment.objects.filter(campaign=campaign)
                 form = CampaignForm(instance=campaign)
                 kwargs = {}
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
                 keys = ['id', 'name', 'start_time', 'end_time']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments.values(*keys)
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'Details'
                 kwargs['form'] = form
                 kwargs['button'] = 'Add Experiment'
                 return render(request, 'campaign.html', kwargs)
             def campaign_new(request):
                 if request.method == 'GET':
                     form = CampaignForm()
                 if request.method == 'POST':
                     form = CampaignForm(request.POST)
                     if form.is_valid():
                         campaign = form.save()
                         return redirect('url_campaign', id_camp=campaign.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'campaign_edit.html', kwargs)
             def campaign_edit(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method=='GET':
                     form = CampaignForm(instance=campaign)
                 if request.method=='POST':
                     form = CampaignForm(request.POST, instance=campaign)
                     if form.is_valid():
                         form.save()
                         return redirect('url_campaign', id_camp=id_camp)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'campaign_edit.html', kwargs)
             def campaign_delete(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         campaign.delete()
                         return redirect('url_campaigns')
                     return HttpResponse("Not enough permission to delete this object")
                 kwargs = {'object':campaign, 'camp_active':'active',
                           'url_cancel':'url_campaign', 'id_item':id_camp}
                 return render(request, 'item_delete.html', kwargs)
             def experiments(request):
                 experiment_list = Experiment.objects.all().order_by('campaign')
                 keys = ['id', 'name', 'start_time', 'end_time', 'campaign']
                 kwargs = {}
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiment_list#.values(*keys)
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Experiment'
                 return render(request, 'experiments.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 experiments = Experiment.objects.filter(campaign=experiment.campaign)
                 configurations = Configuration.objects.filter(experiment=experiment)
                 kwargs = {}
                 exp_keys = ['id', 'campaign', 'name', 'start_time', 'end_time']
                 conf_keys = ['id', 'device__name', 'device__device_type__name', 'device__ip_address']
                 kwargs['experiment_keys'] = exp_keys[1:]
                 kwargs['experiment'] = experiment
                 kwargs['experiments'] = experiments.values(*exp_keys)
                 kwargs['configuration_keys'] = conf_keys[1:]
                 kwargs['configurations'] = configurations.values(*conf_keys)
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Device'
                 return render(request, 'experiment.html', kwargs)
             def experiment_new(request, id_camp=0):
                 if request.method == 'GET':
                     form = ExperimentForm(initial={'campaign':id_camp})
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST, initial={'campaign':id_camp})
                     if form.is_valid():
                         experiment = form.save()
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'experiment_edit.html', kwargs)
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'GET':
                     form = ExperimentForm(instance=experiment)
                 if request.method=='POST':
                     form = ExperimentForm(request.POST, instance=experiment)
                     if form.is_valid():
                         experiment = form.save()
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'experiment_edit.html', kwargs)
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         id_camp = experiment.campaign.id
                         experiment.delete()
                         return redirect('url_campaign', id_camp=id_camp)
                     return HttpResponse("Not enough permission to delete this object")
                 kwargs = {'object':experiment, 'exp_active':'active',
                           'url_cancel':'url_experiment', 'id_item':id_exp}
                 return render(request, 'item_delete.html', kwargs)
             def dev_confs(request):
                 configurations = Configuration.objects.all().order_by('experiment')
             #     keys = ['id', 'device__device_type__name', 'device__name', 'experiment__campaign__name', 'experiment__name']
                 keys = ['id', 'device', 'experiment', 'type', 'programmed_date']
                 kwargs = {}
                 kwargs['configuration_keys'] = keys[1:]
                 kwargs['configurations'] = configurations#.values(*keys)
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Configuration'
                 return render(request, 'dev_confs.html', kwargs)
             def dev_conf(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 dev_conf = DevConfModel.objects.get(pk=id_conf)
                 kwargs = {}
                 kwargs['dev_conf'] = dev_conf
                 kwargs['dev_conf_keys'] = ['experiment', 'device']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'dev_conf.html', kwargs)
             def dev_conf_new(request, id_exp=0):
                 if request.method == 'GET':
                     form = ConfigurationForm(initial={'experiment':id_exp})
                 if request.method == 'POST':
                     form = ConfigurationForm(request.POST)
                     if form.is_valid():
                         experiment = Experiment.objects.get(pk=request.POST['experiment'])
                         device = Device.objects.get(pk=request.POST['device'])
                         exp_devices = Device.objects.filter(configuration__experiment=experiment)
                         if device.id not in exp_devices.values('id',):
                             DevConfModel = CONF_MODELS[device.device_type.name]
                             conf = DevConfModel(experiment=experiment, device=device)
                             conf.save()
                             return redirect('url_experiment', id_exp=experiment.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'dev_conf_edit.html', kwargs)
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 dev_conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method=='GET':
                     form = DevConfForm(instance=dev_conf)
                 if request.method=='POST':
                     form = DevConfForm(request.POST, instance=dev_conf)
                     if form.is_valid():
                         form.save()
                         return redirect('url_dev_conf', id_conf=id_conf)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'dev_conf_edit.html', kwargs)
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
-                DevConfModel = CONF_MODELS[conf.device.device_type.name]
+                messages.error(request, "Read View not implemented yet")
-                dev_conf = DevConfModel.objects.get(pk=id_conf)
-                kwargs = {}
-                kwargs['dev_conf'] = dev_conf
-                kwargs['dev_conf_keys'] = ['experiment', 'device']
-                kwargs['title'] = 'Configuration'
-                kwargs['suptitle'] = 'Details'
-                kwargs['button'] = 'Edit Configuration'
-                ###### SIDEBAR ######
-                kwargs.update(sidebar(conf))
-                messages.error(request, "Read View not implemented yet for this configuration")
+                return redirect('url_dev_conf', id_conf=conf.id)
-                return render(request, 'dev_conf.html', kwargs)
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
-                DevConfModel = CONF_MODELS[conf.device.device_type.name]
+                messages.error(request, "Write View not implemented yet")
-                dev_conf = DevConfModel.objects.get(pk=id_conf)
-                kwargs = {}
-                kwargs['dev_conf'] = dev_conf
-                kwargs['dev_conf_keys'] = ['experiment', 'device']
-                kwargs['title'] = 'Configuration'
-                kwargs['suptitle'] = 'Details'
-                kwargs['button'] = 'Edit Configuration'
-                ###### SIDEBAR ######
-                kwargs.update(sidebar(conf))
-                messages.error(request, "Write View not implemented yet for this configuration")
+                return redirect('url_dev_conf', id_conf=conf.id)
-                return render(request, 'dev_conf.html', kwargs)
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
-                DevConfModel = CONF_MODELS[conf.device.device_type.name]
+                messages.error(request, "Import View not implemented yet")
-                dev_conf = DevConfModel.objects.get(pk=id_conf)
-                kwargs = {}
-                kwargs['dev_conf'] = dev_conf
-                kwargs['dev_conf_keys'] = ['experiment', 'device']
-                kwargs['title'] = 'Configuration'
-                kwargs['suptitle'] = 'Details'
-                kwargs['button'] = 'Edit Configuration'
-                ###### SIDEBAR ######
-                kwargs.update(sidebar(conf))
-                messages.error(request, "Import View not implemented yet for this configuration")
+                return redirect('url_dev_conf', id_conf=conf.id)
-                return render(request, 'dev_conf.html', kwargs)
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
-                DevConfModel = CONF_MODELS[conf.device.device_type.name]
+                messages.error(request, "Export View not implemented yet")
-                dev_conf = DevConfModel.objects.get(pk=id_conf)
-                kwargs = {}
-                kwargs['dev_conf'] = dev_conf
-                kwargs['dev_conf_keys'] = ['experiment', 'device']
-                kwargs['title'] = 'Configuration'
-                kwargs['suptitle'] = 'Details'
-                kwargs['button'] = 'Edit Configuration'
-                ###### SIDEBAR ######
-                kwargs.update(sidebar(conf))
-                messages.error(request, "Export View not implemented yet for this configuration")
+                return redirect('url_dev_conf', id_conf=conf.id)
-                return render(request, 'dev_conf.html', kwargs)
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method=='POST':
                     if request.user.is_staff:
                         id_exp = conf.experiment.id
                         conf.delete()
                         return redirect('url_experiment', id_exp=id_exp)
                     return HttpResponse("Not enough permission to delete this object")
                 kwargs = {'object':conf, 'conf_active':'active',
                       'url_cancel':'url_dev_conf', 'id_item':id_conf}
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf))
                 return render(request, 'item_delete.html', kwargs)
             def sidebar(conf):
                 experiments = Experiment.objects.filter(campaign=conf.experiment.campaign)
                 configurations = Configuration.objects.filter(experiment=conf.experiment, type=0)
                 exp_keys = ['id', 'campaign', 'name', 'start_time', 'end_time']
                 conf_keys = ['id', 'device__name', 'device__device_type__name', 'device__ip_address']
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['experiment_keys'] = exp_keys[1:]
                 kwargs['experiments'] = experiments.values(*exp_keys)
                 kwargs['configuration_keys'] = conf_keys[1:]
                 kwargs['configurations'] = configurations.values(*conf_keys)
                 return kwargs

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages